ExtReact Docs Help

Introduction

The documentation for the ExtReact product diverges somewhat from the documentation of other Sencha products. The sections below describe documentation for all products except where indicated as unique to ExtReact.

Terms, Icons, and Labels

Many classes have shortcut names used when creating (instantiating) a class with a configuration object. The shortcut name is referred to as an alias (or xtype if the class extends Ext.Component). The alias/xtype is listed next to the class name of applicable classes for quick reference.

ExtReact component classes list the configurable name prominently at the top of the API class doc followed by the fully-qualified class name.

Access Levels

Framework classes or their members may be specified as private or protected. Else, the class / member is public. Public, protected, and private are access descriptors used to convey how and when the class or class member should be used.

Member Types

Member Syntax

Below is an example class member that we can disect to show the syntax of a class member (the lookupComponent method as viewed from the Ext.button.Button class in this case).

lookupComponent ( item ) : Ext.Component
protected

Called when a raw config object is added to this container either during initialization of the items config, or when new items are added), or {@link #insert inserted.

This method converts the passed object into an instanced child component.

This may be overridden in subclasses when special processing needs to be applied to child creation.

Parameters

item :  Object

The config object being added.

Returns
Ext.Component

The component to be added.

Let's look at each part of the member row:

Member Flags

The API documentation uses a number of flags to further commnicate the class member's function and intent. The label may be represented by a text label, an abbreviation, or an icon.

Class Icons

- Indicates a framework class

- A singleton framework class. *See the singleton flag for more information

- A component-type framework class (any class within the Ext JS framework that extends Ext.Component)

- Indicates that the class, member, or guide is new in the currently viewed version

Member Icons

- Indicates a class member of type config

Or in the case of an ExtReact component class this indicates a member of type prop

- Indicates a class member of type property

- Indicates a class member of type method

- Indicates a class member of type event

- Indicates a class member of type theme variable

- Indicates a class member of type theme mixin

- Indicates that the class, member, or guide is new in the currently viewed version

Class Member Quick-Nav Menu

Just below the class name on an API doc page is a row of buttons corresponding to the types of members owned by the current class. Each button shows a count of members by type (this count is updated as filters are applied). Clicking the button will navigate you to that member section. Hovering over the member-type button will reveal a popup menu of all members of that type for quick navigation.

Getter and Setter Methods

Getting and setter methods that correlate to a class config option will show up in the methods section as well as in the configs section of both the API doc and the member-type menus just beneath the config they work with. The getter and setter method documentation will be found in the config row for easy reference.

ExtReact component classes do not hoist the getter / setter methods into the prop. All methods will be described in the Methods section

History Bar

Your page history is kept in localstorage and displayed (using the available real estate) just below the top title bar. By default, the only search results shown are the pages matching the product / version you're currently viewing. You can expand what is displayed by clicking on the button on the right-hand side of the history bar and choosing the "All" radio option. This will show all recent pages in the history bar for all products / versions.

Within the history config menu you will also see a listing of your recent page visits. The results are filtered by the "Current Product / Version" and "All" radio options. Clicking on the button will clear the history bar as well as the history kept in local storage.

If "All" is selected in the history config menu the checkbox option for "Show product details in the history bar" will be enabled. When checked, the product/version for each historic page will show alongside the page name in the history bar. Hovering the cursor over the page names in the history bar will also show the product/version as a tooltip.

Search and Filters

Both API docs and guides can be searched for using the search field at the top of the page.

On API doc pages there is also a filter input field that filters the member rows using the filter string. In addition to filtering by string you can filter the class members by access level, inheritance, and read only. This is done using the checkboxes at the top of the page.

The checkbox at the bottom of the API class navigation tree filters the class list to include or exclude private classes.

Clicking on an empty search field will show your last 10 searches for quick navigation.

API Doc Class Metadata

Each API doc page (with the exception of Javascript primitives pages) has a menu view of metadata relating to that class. This metadata view will have one or more of the following:

Expanding and Collapsing Examples and Class Members

Runnable examples (Fiddles) are expanded on a page by default. You can collapse and expand example code blocks individually using the arrow on the top-left of the code block. You can also toggle the collapse state of all examples using the toggle button on the top-right of the page. The toggle-all state will be remembered between page loads.

Class members are collapsed on a page by default. You can expand and collapse members using the arrow icon on the left of the member row or globally using the expand / collapse all toggle button top-right.

Desktop -vs- Mobile View

Viewing the docs on narrower screens or browsers will result in a view optimized for a smaller form factor. The primary differences between the desktop and "mobile" view are:

Viewing the Class Source

The class source can be viewed by clicking on the class name at the top of an API doc page. The source for class members can be viewed by clicking on the "view source" link on the right-hand side of the member row.

ExtReact 6.6.0


top

Summary

This class manages uniquely keyed objects such as Ext.data.Model or Ext.Component.

Keys

Unlike Ext.util.MixedCollection this class can only manage objects whose key can be extracted from the instance. That is, this class does not support "external" keys. This makes this class more efficient because it does not need to track keys in parallel with items. It also means key-to-item lookup will be optimal and never need to perform a linear search.

Extra Keys

In some cases items may need to be looked up by multiple property values. To enable this there is the extraKeys config.

For example, to quickly look up items by their "name" property:

 var collection = new Ext.util.Collection({
     extraKeys: {
         byName: 'name' // based on "name" property of each item
     }
 });

Ranges

When methods accept index arguments to indicate a range of items, these are either an index and a number of items or a "begin" and "end" index.

In the case of "begin" and "end", the "end" is the first item outside the range. This definition makes it simple to expression empty ranges because "length = end - begin".

Negative Indices

When an item index is provided, negative values are treated as offsets from the end of the collection. In other words the follow are equivalent:

 +---+---+---+---+---+---+
 |   |   |   |   |   |   |
 +---+---+---+---+---+---+
   0   1   2   3   4   5
  -6  -5  -4  -3  -2  -1

Legacy Classes

The legacy classes Ext.util.MixedCollection' andExt.util.AbstractMixedCollection may be needed if external keys are required, but for all other situations this class should be used instead.

No members found using the current filters

configs

Optional Configs

decoder : Function

A function that can convert newly added items to a proper type before being added to this collection.

getDecoder : Function

Returns the value of decoder

Returns

Function

setDecoder (decoder)

Sets the value of decoder

Parameters

decoder :  Function

defaultSortDirection : String

The default sort direction to use if one is not specified.

Defaults to:

"ASC"

getDefaultSortDirection : String

Returns the value of defaultSortDirection

Returns

String

setDefaultSortDirection (defaultSortDirection)

Sets the value of defaultSortDirection

Parameters

defaultSortDirection :  String

extraKeys : Object

One or more Ext.util.CollectionKey configuration objects or key properties. Each property of the given object is the name of the CollectionKey instance that is stored on this collection. The value of each property configures the CollectionKey instance.

 var collection = new Ext.util.Collection({
     extraKeys: {
         byName: 'name' // based on "name" property of each item
     }
 });

Or equivalently:

 var collection = new Ext.util.Collection({
     extraKeys: {
         byName: {
             property: 'name'
         }
     }
 });

To provide a custom key extraction function instead:

 var collection = new Ext.util.Collection({
     extraKeys: {
         byName: {
             keyFn: function (item) {
                 return item.name;
             }
         }
     }
 });

Or to call a key getter method from each item:

 var collection = new Ext.util.Collection({
     extraKeys: {
         byName: {
             keyFn: 'getName'
         }
     }
 });

To use the above:

 var item = collection.byName.get('somename');

NOTE Either a property or keyFn must be be specified to define each key.

Available since: 5.0.0

getExtraKeys : Object

Returns the value of extraKeys

Returns

Object

setExtraKeys (extraKeys)

Sets the value of extraKeys

Parameters

extraKeys :  Object

filters : Array / Ext.util.FilterCollection

The collection of Ext.util.Filter for this collection. At the time a collection is created filters can be specified as a unit. After that time the normal setFilters method can also be given a set of replacement filters for the collection.

Individual filters can be specified as an Ext.util.Filter instance, a config object for Ext.util.Filter or simply a function that will be wrapped in a instance with its {@Ext.util.Filter#filterFn filterFn} set.

For fine grain control of the filters collection, call getFilters to return the Ext.util.Collection instance that holds this collection's filters.

 var collection = new Ext.util.Collection();
 var filters = collection.getFilters(); // an Ext.util.FilterCollection

 function legalAge (item) {
     return item.age >= 21;
 }

 filters.add(legalAge);

 //...

 filters.remove(legalAge);

Any changes to the filters collection will cause this collection to adjust its items accordingly (if autoFilter is true).

Available since: 5.0.0

getFilters ( [autoCreate] ) : Ext.util.FilterCollection

Returns the Ext.util.FilterCollection. Unless autoCreate is explicitly passed as false this collection will be automatically created if it does not yet exist.

Parameters

autoCreate :  Object (optional)

Pass false to disable auto-creation of the collection.

Defaults to: true

Returns

:Ext.util.FilterCollection

The collection of filters.

setFilters (filters)

Sets the value of filters

Parameters

filters :  Array / Ext.util.FilterCollection

grouper : Object

A configuration object for this collection's Ext.util.Grouper.

For example, to group items by the first letter of the last name:

 var collection = new Ext.util.Collection({
     grouper: {
         groupFn: function (item) {
             return item.lastName.substring(0, 1);
         }
     }
 });

getGrouper : Object

Returns the value of grouper

Returns

Object

setGrouper (grouper)

Sets the value of grouper

Parameters

grouper :  Object

groups : Ext.util.GroupCollection

The collection of to hold each group container. This collection is created and removed dynamically based on grouper. Application code should only need to call getGroups to retrieve the collection and not setGroups.

getGroups : Ext.util.GroupCollection

Returns the value of groups

Returns

Ext.util.GroupCollection

setGroups (groups)

Sets the value of groups

Parameters

groups :  Ext.util.GroupCollection

keyFn : Function

A function to retrieve the key of an item in the collection. If provided, this replaces the default getKey method. The default getKey method handles items that have either an "id" or "_id" property or failing that a getId method to call.

Available since: 5.0.0

listeners : Object

A config object containing one or more event handlers to be added to this object during initialization. This should be a valid listeners config object as specified in the addListener example for attaching multiple handlers at once.

DOM events from Ext JS Ext.Component

While some Ext JS Component classes export selected DOM events (e.g. "click", "mouseover" etc), this is usually only done when extra value can be added. For example the DataView's itemclick event passing the node clicked on. To access DOM events directly from a child element of a Component, we need to specify the element option to identify the Component property to add a DOM listener to:

new Ext.panel.Panel({
    width: 400,
    height: 200,
    dockedItems: [{
        xtype: 'toolbar'
    }],
    listeners: {
        click: {
            element: 'el', //bind to the underlying el property on the panel
            fn: function(){ console.log('click el'); }
        },
        dblclick: {
            element: 'body', //bind to the underlying body property on the panel
            fn: function(){ console.log('dblclick body'); }
        }
    }
});

setListeners ( listeners )

An alias for addListener. In versions prior to 5.1, listeners had a generated setter which could be called to add listeners. In 5.1 the listeners config is not processed using the config system and has no generated setter, so this method is provided for backward compatibility. The preferred way of adding listeners is to use the on method.

Parameters

listeners :  Object

The listeners

multiSortLimit : Number

The maximum number of sorters which may be applied to this Sortable when using the "multi" insertion position when adding sorters.

New sorters added using the "multi" insertion position are inserted at the top of the sorters list becoming the new primary sort key.

If the sorters collection has grown to longer then multiSortLimit, then the it is trimmed.

Defaults to:

3

getMultiSortLimit : Number

Returns the value of multiSortLimit

Returns

Number

setMultiSortLimit (multiSortLimit)

Sets the value of multiSortLimit

Parameters

multiSortLimit :  Number

rootProperty : String

The root property to use for aggregation, filtering and sorting. By default this is null but when containing things like Ext.data.Model this config would likely be set to "data" so that property names are applied to the fields of each record.

getRootProperty : String

Returns the value of rootProperty

Returns

String

setRootProperty (rootProperty)

Sets the value of rootProperty

Parameters

rootProperty :  String

sorters : Array / Ext.util.SorterCollection

Array of Ext.util.Sorter for this collection. At the time a collection is created the sorters can be specified as a unit. After that time the normal setSorters method can be also be given a set of replacement sorters.

Individual sorters can be specified as an Ext.util.Sorter instance, a config object for Ext.util.Sorter or simply the name of a property by which to sort.

An alternative way to extend the sorters is to call the sort method and pass a property or sorter config to add to the sorters.

For fine grain control of the sorters collection, call getSorters to return the Ext.util.Collection instance that holds this collection's sorters.

 var collection = new Ext.util.Collection();
 var sorters = collection.getSorters(); // an Ext.util.SorterCollection

 sorters.add('name');

 //...

 sorters.remove('name');

Any changes to the sorters collection will cause this collection to adjust its items accordingly (if autoSort is true).

Available since: 5.0.0

getSorters ( [autoCreate] ) : Ext.util.SorterCollection

Returns the Ext.util.SorterCollection. Unless autoCreate is explicitly passed as false this collection will be automatically created if it does not yet exist.

Parameters

autoCreate :  Object (optional)

Pass false to disable auto-creation of the collection.

Defaults to: true

Returns

:Ext.util.SorterCollection

The collection of sorters.

setSorters (sorters)

Sets the value of sorters

Parameters

sorters :  Array / Ext.util.SorterCollection

source : Ext.util.Collection

The base Collection. This collection contains the items to which filters are applied to populate this collection. In this configuration, only the root source collection can have items truly added or removed.

Available since: 5.0.0

getSource Ext.util.Collection

Returns all unfiltered items in the Collection when the Collection has been filtered. Returns null when the Collection is not filtered.

Returns

:Ext.util.Collection

items All unfiltered items (or null when the Collection is not filtered)

setSource (source)

Sets the value of source

Parameters

source :  Ext.util.Collection

properties

Instance Properties

isObservable : Boolean

true in this class to identify an object as an instantiated Observable, or subclass thereof.

Defaults to:

true

methods

Instance Methods

add ( item ) : Object/Object[]

Adds an item to the collection. If the item already exists or an item with the same key exists, the old item will be removed and the new item will be added to the end.

This method also accepts an array of items or simply multiple items as individual arguments. The following 3 code sequences have the same end result:

 // Call add() once per item (not optimal - best avoided):
 collection.add(itemA);
 collection.add(itemB);
 collection.add(itemC);
 collection.add(itemD);

 // Call add() with each item as an argument:
 collection.add(itemA, itemB, itemC, itemD);

 // Call add() with the items as an array:
 collection.add([ itemA, itemB, itemC, itemD ]);

The first form should be avoided where possible because the collection and all parties "watching" it will be updated 4 times.

Available since: 5.0.0

Parameters

item :  Object/Object[]

The item or items to add.

Returns

:Object/Object[]

The item or items added.

addListener ( eventName, [fn], [scope], [options], [order] ) : Object

The on method is shorthand for addListener.

Appends an event handler to this object. For example:

myGridPanel.on("itemclick", this.onItemClick, this);

The method also allows for a single argument to be passed which is a config object containing properties which specify multiple events. For example:

myGridPanel.on({
    cellclick: this.onCellClick,
    select: this.onSelect,
    viewready: this.onViewReady,
    scope: this // Important. Ensure "this" is correct during handler execution
});

One can also specify options for each event handler separately:

myGridPanel.on({
    cellclick: {fn: this.onCellClick, scope: this, single: true},
    viewready: {fn: panel.onViewReady, scope: panel}
});

Names of methods in a specified scope may also be used:

myGridPanel.on({
    cellclick: {fn: 'onCellClick', scope: this, single: true},
    viewready: {fn: 'onViewReady', scope: panel}
});

Parameters

eventName :  String/Object

The name of the event to listen for. May also be an object who's property names are event names.

fn :  Function/String (optional)

The method the event invokes or the name of the method within the specified scope. Will be called with arguments given to Ext.util.Observable#fireEvent plus the options parameter described below.

scope :  Object (optional)

The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event.

options :  Object (optional)

An object containing handler configuration.

Note: The options object will also be passed as the last argument to every event handler.

This object may contain any of the following properties:

scope :  Object

The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event.

delay :  Number

The number of milliseconds to delay the invocation of the handler after the event fires.

single :  Boolean

True to add a handler to handle just the next firing of the event, and then remove itself.

buffer :  Number

Causes the handler to be scheduled to run in an Ext.util.DelayedTask delayed by the specified number of milliseconds. If the event fires again within that time, the original handler is not invoked, but the new handler is scheduled in its place.

onFrame :  Number

Causes the handler to be scheduled to run at the next animation frame event. If the event fires again before that time, the handler is not rescheduled - the handler will only be called once when the next animation frame is fired, with the last set of arguments passed.

target :  Ext.util.Observable

Only call the handler if the event was fired on the target Observable, not if the event was bubbled up from a child Observable.

element :  String

This option is only valid for listeners bound to Ext.Component. The name of a Component property which references an Ext.dom.Element to add a listener to.

This option is useful during Component construction to add DOM event listeners to elements of Ext.Component which will exist only after the Component is rendered.

For example, to add a click listener to a Panel's body:

  var panel = new Ext.panel.Panel({
      title: 'The title',
      listeners: {
          click: this.handlePanelClick,
          element: 'body'
      }
  });

In order to remove listeners attached using the element, you'll need to reference the element itself as seen below.

 panel.body.un(...)

delegate :  String (optional)

A simple selector to filter the event target or look for a descendant of the target.

The "delegate" option is only available on Ext.dom.Element instances (or when attaching a listener to a Ext.dom.Element via a Component using the element option).

See the delegate example below.

capture :  Boolean (optional)

When set to true, the listener is fired in the capture phase of the event propagation sequence, instead of the default bubble phase.

The capture option is only available on Ext.dom.Element instances (or when attaching a listener to a Ext.dom.Element via a Component using the element option).

stopPropagation :  Boolean (optional)

This option is only valid for listeners bound to Ext.dom.Element. true to call stopPropagation on the event object before firing the handler.

preventDefault :  Boolean (optional)

This option is only valid for listeners bound to Ext.dom.Element. true to call preventDefault on the event object before firing the handler.

stopEvent :  Boolean (optional)

This option is only valid for listeners bound to Ext.dom.Element. true to call stopEvent on the event object before firing the handler.

args :  Array (optional)

Optional arguments to pass to the handler function. Any additional arguments passed to fireEvent will be appended to these arguments.

destroyable :  Boolean (optional)

When specified as true, the function returns a destroyable object. An object which implements the destroy method which removes all listeners added in this call. This syntax can be a helpful shortcut to using un; particularly when removing multiple listeners. NOTE - not compatible when using the element option. See un for the proper syntax for removing listeners added using the element config.

Defaults to:

false

priority :  Number (optional)

An optional numeric priority that determines the order in which event handlers are run. Event handlers with no priority will be run as if they had a priority of 0. Handlers with a higher priority will be prioritized to run sooner than those with a lower priority. Negative numbers can be used to set a priority lower than the default. Internally, the framework uses a range of 1000 or greater, and -1000 or lesser for handlers that are intended to run before or after all others, so it is recommended to stay within the range of -999 to 999 when setting the priority of event handlers in application-level code. A priority must be an integer to be valid. Fractional values are reserved for internal framework use.

order :  String (optional)

A legacy option that is provided for backward compatibility. It is recommended to use the priority option instead. Available options are:

  • 'before': equal to a priority of 100
  • 'current': equal to a priority of 0 or default priority
  • 'after': equal to a priority of -100

Defaults to:

'current'

order :  String (optional)

A shortcut for the order event option. Provided for backward compatibility. Please use the priority event option instead.

Combining Options

Using the options argument, it is possible to combine different types of listeners:

A delayed, one-time listener.

myPanel.on('hide', this.handleClick, this, {
    single: true,
    delay: 100
});

Attaching multiple handlers in 1 call

The method also allows for a single argument to be passed which is a config object containing properties which specify multiple handlers and handler configs.

grid.on({
    itemclick: 'onItemClick',
    itemcontextmenu: grid.onItemContextmenu,
    destroy: {
        fn: function () {
            // function called within the 'altCmp' scope instead of grid
        },
        scope: altCmp // unique scope for the destroy handler
    },
    scope: grid       // default scope - provided for example clarity
});

Delegate

This is a configuration option that you can pass along when registering a handler for an event to assist with event delegation. By setting this configuration option to a simple selector, the target element will be filtered to look for a descendant of the target. For example:

var panel = Ext.create({
    xtype: 'panel',
    renderTo: document.body,
    title: 'Delegate Handler Example',
    frame: true,
    height: 220,
    width: 220,
    html: '<h1 class="myTitle">BODY TITLE</h1>Body content'
});

// The click handler will only be called when the click occurs on the
// delegate: h1.myTitle ("h1" tag with class "myTitle")
panel.on({
    click: function (e) {
        console.log(e.getTarget().innerHTML);
    },
    element: 'body',
    delegate: 'h1.myTitle'
 });

Defaults to: 'current'

Returns

:Object

Only when the destroyable option is specified.

A Destroyable object. An object which implements the destroy method which removes all listeners added in this call. For example:

this.btnListeners =  = myButton.on({
    destroyable: true
    mouseover:   function() { console.log('mouseover'); },
    mouseout:    function() { console.log('mouseout'); },
    click:       function() { console.log('click'); }
});

And when those listeners need to be removed:

Ext.destroy(this.btnListeners);

or

this.btnListeners.destroy();

addManagedListener ( item, ename, [fn], [scope], [options] ) : Object

The addManagedListener method is used when some object (call it "A") is listening to an event on another observable object ("B") and you want to remove that listener from "B" when "A" is destroyed. This is not an issue when "B" is destroyed because all of its listeners will be removed at that time.

Example:

Ext.define('Foo', {
    extend: 'Ext.Component',

    initComponent: function () {
        this.addManagedListener(MyApp.SomeGlobalSharedMenu, 'show', this.doSomething);
        this.callParent();
    }
});

As you can see, when an instance of Foo is destroyed, it ensures that the 'show' listener on the menu (MyApp.SomeGlobalSharedMenu) is also removed.

As of version 5.1 it is no longer necessary to use this method in most cases because listeners are automatically managed if the scope object provided to addListener is an Observable instance. However, if the observable instance and scope are not the same object you still need to use mon or addManagedListener if you want the listener to be managed.

Parameters

item :  Ext.util.Observable/Ext.dom.Element

The item to which to add a listener/listeners.

ename :  Object/String

The event name, or an object containing event name properties.

fn :  Function/String (optional)

If the ename parameter was an event name, this is the handler function or the name of a method on the specified scope.

scope :  Object (optional)

If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed.

options :  Object (optional)

If the ename parameter was an event name, this is the addListener options.

Returns

:Object

Only when the destroyable option is specified.

A Destroyable object. An object which implements the destroy method which removes all listeners added in this call. For example:

this.btnListeners = myButton.mon({
    destroyable: true
     mouseover:   function() { console.log('mouseover'); },
    mouseout:    function() { console.log('mouseout'); },
    click:       function() { console.log('click'); }
});

And when those listeners need to be removed:

Ext.destroy(this.btnListeners);

or

this.btnListeners.destroy();

aggregate ( property, operation, [begin], [end], [scope] ) : Object

Returns the result of the specified aggregation operation against all items in this collection.

This method is not typically called directly because there are convenience methods for each of the supported operation values. These are:

  • average - Returns the average value.
  • bounds - Returns an array of [min, max].
  • max - Returns the maximum value or undefined if empty.
  • min - Returns the minimum value or undefined if empty.
  • sum - Returns the sum of all values.

For example:

 result = collection.aggregate('age', 'sum');

 result = collection.aggregate('age', 'sum', 2, 10); // the 8 items at index 2

To provide a custom operation function:

 function averageAgeOfMinors (items, values) {
     var sum = 0,
         count = 0;

     for (var i = 0; i < values.length; ++i) {
         if (values[i] < 18) {
             sum += values[i];
             ++count;
         }
     }

     return count ? sum / count : 0;
 }

 result = collection.aggregate('age', averageAgeOfMinors);

Parameters

property :  String

The name of the property to aggregate from each item.

operation :  String/Function

The operation to perform.

items :  Array

The items on which the operation function is to operate.

values :  Array

The values on which the operation function is to operate.

begin :  Number (optional)

The index of the first item in items to include in the aggregation.

end :  Number (optional)

The index at which to stop aggregating items. The item at this index will not be included in the aggregation.

scope :  Object (optional)

The this pointer to use if operation is a function. Defaults to this collection.

Returns

:Object

aggregateByGroup ( property, operation, [scope] ) : Object

See aggregate. The functionality is the same, however the aggregates are provided per group. Assumes this collection has an active grouper.

Parameters

property :  String

The name of the property to aggregate from each item.

operation :  String/Function

The operation to perform.

items :  Array

The items on which the operation function is to operate.

values :  Array

The values on which the operation function is to operate.

scope :  Object (optional)

The this pointer to use if operation is a function. Defaults to this collection.

Returns

:Object

average ( property, [begin], [end] ) : Object

Averages property values from some or all of the items in this collection.

Available since: 5.0.0

Parameters

property :  String

The name of the property to average from each item.

begin :  Number (optional)

The index of the first item to include in the average.

end :  Number (optional)

The index at which to stop averaging items. The item at this index will not be included in the average.

Returns

:Object

The result of averaging the specified property from the indicated items.

averageByGroup ( property ) : Object

See average. The result is partitioned by group.

Available since: 5.0.0

Parameters

property :  String

The name of the property to average from each item.

Returns

:Object

The result of average, partitioned by group. See aggregateByGroup.

beginUpdate

This method is called to indicate the start of multiple changes to the collection. Application code should seldom need to call this method as it is called internally when needed. If multiple collection changes are needed, consider wrapping them in an update call rather than calling beginUpdate directly.

Internally this method increments a counter that is decremented by endUpdate. It is important, therefore, that if you call beginUpdate directly you match that call with a call to endUpdate or you will prevent the collection from updating properly.

For example:

 var collection = new Ext.util.Collection();

 collection.beginUpdate();

 collection.add(item);
 // ...

 collection.insert(index, otherItem);
 //...

 collection.endUpdate();

Available since: 5.0.0

bounds ( property, [begin], [end] ) : Array

Determines the minimum and maximum values for the specified property over some or all of the items in this collection.

Available since: 5.0.0

Parameters

property :  String

The name of the property from each item.

begin :  Number (optional)

The index of the first item to include in the bounds.

end :  Number (optional)

The index at which to stop in items. The item at this index will not be included in the bounds.

Returns

:Array

An array [min, max] with the minimum and maximum of the specified property.

boundsByGroup ( property ) : Object

See bounds. The result is partitioned by group.

Available since: 5.0.0

Parameters

property :  String

The name of the property from each item.

Returns

:Object

The result of bounds, partitioned by group. See aggregateByGroup.

clear

Removes all items from the collection. This is similar to removeAll except that removeAll fire events to inform listeners. This means that this method should be called only when you are sure there are no listeners.

Available since: 5.0.0

clearListeners

Removes all listeners for this object including the managed listeners

clearManagedListeners

Removes all managed listeners for this object.

clone Ext.util.Collection

Creates a shallow copy of this collection

Available since: 5.0.0

Returns

:Ext.util.Collection

collect ( property, [root], [allowNull] ) : Array

Collects unique values of a particular property in this Collection.

Available since: 5.0.0

Parameters

property :  String

The property to collect on

root :  String (optional)

'root' property to extract the first argument from. This is used mainly when summing fields in records, where the fields are all stored inside the 'data' object

allowNull :  Boolean (optional)

Pass true to include null, undefined or empty string values.

Returns

:Array

The unique values

contains ( item ) : Boolean

Returns true if the collection contains the passed Object as an item.

Available since: 5.0.0

Parameters

item :  Object

The Object to look for in the collection.

Returns

:Boolean

true if the collection contains the Object as an item.

containsKey ( key ) : Boolean

Returns true if the collection contains the passed Object as a key.

Available since: 5.0.0

Parameters

key :  String

The key to look for in the collection.

Returns

:Boolean

True if the collection contains the Object as a key.

count Number

Determines the number of items in the collection.

Available since: 5.0.0

Returns

:Number

The number of items.

countByGroup Object

See count. The result is partitioned by group.

Available since: 5.0.0

Returns

:Object

The result of count, partitioned by group. See aggregateByGroup.

createFiltered ( property, value, [anyMatch], [caseSensitive], [exactMatch] ) : Ext.util.Collection

Creates a new collection that is a filtered subset of this collection. The filter passed can be a function, a simple property name and value, an Ext.util.Filter instance, an array of Ext.util.Filter instances.

If the passed filter is a function the second argument is its "scope" (or "this" pointer). The function should return true given each item in the collection if that item should be included in the filtered collection.

 var people = new Ext.util.Collection();

 people.add([
     { id: 1, age: 25, name: 'Ed' },
     { id: 2, age: 24, name: 'Tommy' },
     { id: 3, age: 24, name: 'Arne' },
     { id: 4, age: 26, name: 'Aaron' }
 ]);

 // Create a collection of people who are older than 24:
 var oldPeople = people.createFiltered(function (item) {
     return item.age > 24;
 });

If the passed filter is a Ext.util.Filter instance or array of Ext.util.Filter instances the filter(s) are used to produce the filtered collection and there are no further arguments.

If the passed filter is a string it is understood as the name of the property by which to filter. The second argument is the "value" used to compare each item's property value. This comparison can be further tuned with the anyMatch and caseSensitive (optional) arguments.

// Create a new Collection containing only the items where age == 24 var middleAged = people.createFiltered('age', 24);

Alternatively you can apply filters to this Collection by calling setFilters or modifying the filter collection returned by getFilters.

Available since: 5.0.0

Parameters

property :  Ext.util.Filter[]/String/Function

A property on your objects, an array of Ext.util.Filter objects or a filter function.

value :  Object

If property is a function, this argument is the "scope" (or "this" pointer) for the function. Otherwise this is either a RegExp to test property values or the value with which to compare.

anyMatch :  Boolean (optional)

True to match any part of the string, not just the beginning.

Defaults to: false

caseSensitive :  Boolean (optional)

True for case sensitive comparison.

Defaults to: false

exactMatch :  Boolean (optional)

true to force exact match (^ and $ characters added to the regex).

Defaults to: false

Returns

:Ext.util.Collection

The new, filtered collection.

destroy

Destroys this collection. This is only necessary if this collection uses a source collection as that relationship will keep a reference from the source to this collection and potentially leak memory.

Available since: 5.0.0

each ( fn, [scope] )

Executes the specified function once for every item in the collection. If the value returned by fn is false the iteration stops. In all cases, the last value that fn returns is returned by this method.

Available since: 5.0.0

Parameters

fn :  Function

The function to execute for each item.

item :  Object

The collection item.

index :  Number

The index of item.

len :  Number

Total length of collection.

scope :  Object (optional)

The scope (this reference) in which the function is executed. Defaults to this collection.

Defaults to: this

eachKey ( fn, [scope] )

Executes the specified function once for every key in the collection, passing each key, and its associated item as the first two parameters. If the value returned by fn is false the iteration stops. In all cases, the last value that fn returns is returned by this method.

Available since: 5.0.0

Parameters

fn :  Function

The function to execute for each item.

key :  String

The key of collection item.

item :  Object

The collection item.

index :  Number

The index of item.

len :  Number

Total length of collection.

scope :  Object (optional)

The scope (this reference) in which the function is executed. Defaults to this collection.

Defaults to: this

enableBubble ( eventNames )

Enables events fired by this Observable to bubble up an owner hierarchy by calling this.getBubbleTarget() if present. There is no implementation in the Observable base class.

This is commonly used by Ext.Components to bubble events to owner Containers. See Ext.Component#getBubbleTarget. The default implementation in Ext.Component returns the Component's immediate owner. But if a known target is required, this can be overridden to access the required target more quickly.

Example:

Ext.define('Ext.overrides.form.field.Base', {
    override: 'Ext.form.field.Base',

    //  Add functionality to Field's initComponent to enable the change event to bubble
    initComponent: function () {
        this.callParent();
        this.enableBubble('change');
    }
});

var myForm = Ext.create('Ext.form.Panel', {
    title: 'User Details',
    items: [{
        ...
    }],
    listeners: {
        change: function() {
            // Title goes red if form has been modified.
            myForm.header.setStyle('color', 'red');
        }
    }
});

Parameters

eventNames :  String/String[]

The event name to bubble, or an Array of event names.

endUpdate

This method is called after modifications are complete on a collection. For details see beginUpdate.

Available since: 5.0.0

extremes ( property, [begin], [end] ) : Array

Finds the items with the minimum and maximum for the specified property over some or all of the items in this collection.

Available since: 5.0.0

Parameters

property :  String

The name of the property from each item.

begin :  Number (optional)

The index of the first item to include.

end :  Number (optional)

The index at which to stop in items. The item at this index will not be included.

Returns

:Array

An array [minItem, maxItem] with the items that have the minimum and maximum of the specified property.

extremesByGroup ( property ) : Object

See extremes. The result is partitioned by group.

Available since: 5.0.0

Parameters

property :  String

The name of the property from each item.

Returns

:Object

The result of extremes, partitioned by group. See aggregateByGroup.

find ( property, value, [start], [startsWith], [endsWith], [ignoreCase] ) : Object

Finds the first matching object in this collection by a specific property/value.

Available since: 5.0.0

Parameters

property :  String

The name of a property on your objects.

value :  String/RegExp

A string that the property values should start with or a RegExp to test against the property.

start :  Number (optional)

The index to start searching at.

Defaults to: 0

startsWith :  Boolean (optional)

Pass false to allow a match start anywhere in the string. By default the value will match only at the start of the string.

Defaults to: true

endsWith :  Boolean (optional)

Pass false to allow the match to end before the end of the string. By default the value will match only at the end of the string.

Defaults to: true

ignoreCase :  Boolean (optional)

Pass false to make the RegExp case sensitive (removes the 'i' flag).

Defaults to: true

Returns

:Object

The first item in the collection which matches the criteria or null if none was found.

findBy ( fn, [scope], [start] ) : Object

Returns the first item in the collection which elicits a true return value from the passed selection function.

Available since: 5.0.0

Parameters

fn :  Function

The selection function to execute for each item.

item :  Object

The collection item.

key :  String

The key of collection item.

scope :  Object (optional)

The scope (this reference) in which the function is executed. Defaults to this collection.

Defaults to: this

start :  Number (optional)

The index at which to start searching.

Defaults to: 0

Returns

:Object

The first item in the collection which returned true from the selection function, or null if none was found.

findIndex ( property, value, [start], [startsWith], [endsWith], [ignoreCase] ) : Number

Finds the index of the first matching object in this collection by a specific property/value.

Available since: 5.0.0

Parameters

property :  String

The name of a property on your objects.

value :  String/RegExp

A string that the property values should start with or a RegExp to test against the property.

start :  Number (optional)

The index to start searching at.

Defaults to: 0

startsWith :  Boolean (optional)

Pass false to allow a match start anywhere in the string. By default the value will match only at the start of the string.

Defaults to: true

endsWith :  Boolean (optional)

Pass false to allow the match to end before the end of the string. By default the value will match only at the end of the string.

Defaults to: true

ignoreCase :  Boolean (optional)

Pass false to make the RegExp case sensitive (removes the 'i' flag).

Defaults to: true

Returns

:Number

The matched index or -1 if not found.

findIndexBy ( fn, [scope], [start] ) : Number

Find the index of the first matching object in this collection by a function. If the function returns true it is considered a match.

Available since: 5.0.0

Parameters

fn :  Function

The function to be called.

item :  Object

The collection item.

key :  String

The key of collection item.

scope :  Object (optional)

The scope (this reference) in which the function is executed. Defaults to this collection.

Defaults to: this

start :  Number (optional)

The index at which to start searching.

Defaults to: 0

Returns

:Number

The matched index or -1

fireEvent ( eventName, args ) : Boolean

Fires the specified event with the passed parameters (minus the event name, plus the options object passed to addListener).

An event may be set to bubble up an Observable parent hierarchy (See Ext.Component#getBubbleTarget) by calling enableBubble.

Parameters

eventName :  String

The name of the event to fire.

args :  Object...

Variable number of parameters are passed to handlers.

Returns

:Boolean

returns false if any of the handlers return false otherwise it returns true.

fireEventArgs ( eventName, args ) : Boolean

Fires the specified event with the passed parameter list.

An event may be set to bubble up an Observable parent hierarchy (See Ext.Component#getBubbleTarget) by calling enableBubble.

Parameters

eventName :  String

The name of the event to fire.

args :  Object[]

An array of parameters which are passed to handlers.

Returns

:Boolean

returns false if any of the handlers return false otherwise it returns true.

fireEventedAction ( eventName, args, fn, [scope], [fnArgs] )

Fires the specified event with the passed parameters and executes a function (action). Evented Actions will automatically dispatch a 'before' event passing. This event will be given a special controller that allows for pausing/resuming of the event flow.

By pausing the controller the updater and events will not run until resumed. Pausing, however, will not stop the processing of any other before events.

Parameters

eventName :  String

The name of the event to fire.

args :  Array

Arguments to pass to handlers and to the action function.

fn :  Function/String

The action function.

scope :  Object (optional)

The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event.

fnArgs :  Array/Boolean (optional)

Optional arguments for the action fn. If not given, the normal args will be used to call fn. If false is passed, the args are used but if the first argument is this instance it will be removed from the args passed to the action function.

first ( [grouped] ) : Object

Returns the first item in the collection.

Available since: 5.0.0

Parameters

grouped :  Boolean (optional)

true to extract the first item in each group. Only applies if a grouper is active in the collection.

Returns

:Object

The first item in the collection. If the grouped parameter is passed, see aggregateByGroup for information on the return type.

get ( key ) : Object

Returns the item associated with the passed key.

Available since: 5.0.0

Parameters

key :  String/Number

The key of the item.

Returns

:Object

The item associated with the passed key.

getAt ( index ) : Object

Returns the item at the specified index.

Available since: 5.0.0

Parameters

index :  Number

The index of the item.

Returns

:Object

The item at the specified index.

getByKey ( key ) : Object

Returns the item associated with the passed key.

Available since: 5.0.0

Parameters

key :  String/Number

The key of the item.

Returns

:Object

The item associated with the passed key.

getCount Number

Returns the number of items in the collection.

Available since: 5.0.0

Returns

:Number

the number of items in the collection.

getFilterFn Function

Returns the filter function.

Returns

:Function

sortFn The sort function.

getKey ( item ) : Object

A function which will be called, passing an object belonging to this collection. The function should return the key by which that object will be indexed. This key must be unique to this item as only one item with this key will be retained.

The default implementation looks basically like this (give or take special case handling of 0):

 function getKey (item) {
     return item.id || item._id || item.getId();
 }

You can provide your own implementation by passing the keyFn config.

For example, to hold items that have a unique "name" property:

var elementCollection = new Ext.util.Collection({
    keyFn: function (item) {
        return item.name;
    }
});

The collection can have extraKeys if items need to be quickly looked up by other (potentially non-unique) properties.

Available since: 5.0.0

Parameters

item :  Object

The item.

Returns

:Object

The key for the passed item.

getRange ( [begin], [end] ) : Array

Returns a range of items in this collection

Available since: 5.0.0

Parameters

begin :  Number (optional)

The index of the first item to get.

Defaults to: 0

end :  Number (optional)

The ending index. The item at this index is not included.

Returns

:Array

An array of items

getSortFn Function

Returns an up to date sort function.

Returns

:Function

The sort function.

getValues ( property, [root], [start], [end] ) : Array

Returns an array of values for the specified (sub) property.

For example, to get an array of "name" properties from a collection of records (of Ext.data.Model objects):

 var names = collection.getValues('name', 'data');

Available since: 5.0.0

Parameters

property :  String

The property to collect on

root :  String (optional)

'root' property to extract the first argument from. This is used mainly when operating on fields in records, where the fields are all stored inside the 'data' object.

start :  Number (optional)

The index of the first item to include.

Defaults to: 0

end :  Number (optional)

The index at which to stop getting values. The value of this item is not included.

Returns

:Array

The values.

hasListener ( eventName ) : Boolean

Checks to see if this object has any listeners for a specified event, or whether the event bubbles. The answer indicates whether the event needs firing or not.

Parameters

eventName :  String

The name of the event to check for

Returns

:Boolean

true if the event is being listened for or bubbles, else false

indexOf ( item ) : Number

Returns index within the collection of the passed Object.

Available since: 5.0.0

Parameters

item :  Object

The item to find.

Returns

:Number

The index of the item or -1 if not found.

indexOfKey ( key ) : Number

Returns index within the collection of the passed key.

Available since: 5.0.0

Parameters

key :  Object

The key to find.

Returns

:Number

The index of the item or -1 if not found.

insert ( index, item ) : Object/Object[]

Inserts one or more items to the collection. The index value is the position at which the first item will be placed. The items starting at that position will be shifted to make room.

Available since: 5.0.0

Parameters

index :  Number

The index at which to insert the item(s).

item :  Object/Object[]

The item or items to add.

Returns

:Object/Object[]

The item or items added.

isItemFiltered ( item ) : Boolean

This method can be used to conveniently test whether an individual item would be removed due to the current filter.

Parameters

item :  Object

The item to test.

Returns

:Boolean

The value true if the item would be "removed" from the collection due to filters or false otherwise.

isSuspended ( [event] ) : Boolean

Checks if all events, or a specific event, is suspended.

Parameters

event :  String (optional)

The name of the specific event to check

Returns

:Boolean

true if events are suspended

itemChanged ( item, [modified], [oldKey] )

This method should be called when an item in this collection has been modified. If the collection is sorted or filtered the result of modifying an item needs to be reflected in the collection. If the item's key is also being modified, it is best to pass the oldKey to this same call rather than call updateKey separately.

Available since: 5.0.0

Parameters

item :  Object

The item that was modified.

modified :  String[] (optional)

The names of the modified properties of the item.

oldKey :  String/Number (optional)

Passed if the item's key was also modified.

last ( [grouped] ) : Object

Returns the last item in the collection.

Available since: 5.0.0

Parameters

grouped :  Boolean (optional)

true to extract the first item in each group. Only applies if a grouper is active in the collection.

Returns

:Object

The last item in the collection. If the grouped parameter is passed, see aggregateByGroup for information on the return type.

max ( property, [begin], [end] ) : Object

Determines the maximum value for the specified property over some or all of the items in this collection.

Available since: 5.0.0

Parameters

property :  String

The name of the property from each item.

begin :  Number (optional)

The index of the first item to include in the maximum.

end :  Number (optional)

The index at which to stop in items. The item at this index will not be included in the maximum.

Returns

:Object

The maximum of the specified property from the indicated items.

maxByGroup ( property ) : Object

See max. The result is partitioned by group.

Available since: 5.0.0

Parameters

property :  String

The name of the property from each item.

Returns

:Object

The result of max, partitioned by group. See aggregateByGroup.

maxItem ( property, [begin], [end] ) : Object

Finds the item with the maximum value for the specified property over some or all of the items in this collection.

Available since: 5.0.0

Parameters

property :  String

The name of the property from each item.

begin :  Number (optional)

The index of the first item to include in the maximum.

end :  Number (optional)

The index at which to stop in items. The item at this index will not be included in the maximum.

Returns

:Object

The item with the maximum of the specified property from the indicated items.

maxItemByGroup ( property ) : Object

See maxItem. The result is partitioned by group.

Available since: 5.0.0

Parameters

property :  String

The name of the property from each item.

Returns

:Object

The result of maxItem, partitioned by group. See aggregateByGroup.

min ( property, [begin], [end] ) : Object

Determines the minimum value for the specified property over some or all of the items in this collection.

Available since: 5.0.0

Parameters

property :  String

The name of the property from each item.

begin :  Number (optional)

The index of the first item to include in the minimum.

end :  Number (optional)

The index at which to stop in items. The item at this index will not be included in the minimum.

Returns

:Object

The minimum of the specified property from the indicated items.

minByGroup ( property ) : Object

See min. The result is partitioned by group.

Available since: 5.0.0

Parameters

property :  String

The name of the property from each item.

Returns

:Object

The result of min, partitioned by group. See aggregateByGroup.

minItem ( property, [begin], [end] ) : Object

Finds the item with the minimum value for the specified property over some or all of the items in this collection.

Available since: 5.0.0

Parameters

property :  String

The name of the property from each item.

begin :  Number (optional)

The index of the first item to include in the minimum.

end :  Number (optional)

The index at which to stop in items. The item at this index will not be included in the minimum.

Returns

:Object

The item with the minimum of the specified property from the indicated items.

minItemByGroup ( property ) : Object

See minItem. The result is partitioned by group.

Available since: 5.0.0

Parameters

property :  String

The name of the property from each item.

Returns

:Object

The result of minItem, partitioned by group. See aggregateByGroup.

mon ( item, ename, [fn], [scope], [options] ) : Object

Shorthand for addManagedListener. The addManagedListener method is used when some object (call it "A") is listening to an event on another observable object ("B") and you want to remove that listener from "B" when "A" is destroyed. This is not an issue when "B" is destroyed because all of its listeners will be removed at that time.

Example:

Ext.define('Foo', {
    extend: 'Ext.Component',

    initComponent: function () {
        this.addManagedListener(MyApp.SomeGlobalSharedMenu, 'show', this.doSomething);
        this.callParent();
    }
});

As you can see, when an instance of Foo is destroyed, it ensures that the 'show' listener on the menu (MyApp.SomeGlobalSharedMenu) is also removed.

As of version 5.1 it is no longer necessary to use this method in most cases because listeners are automatically managed if the scope object provided to addListener is an Observable instance. However, if the observable instance and scope are not the same object you still need to use mon or addManagedListener if you want the listener to be managed.

Parameters

item :  Ext.util.Observable/Ext.dom.Element

The item to which to add a listener/listeners.

ename :  Object/String

The event name, or an object containing event name properties.

fn :  Function/String (optional)

If the ename parameter was an event name, this is the handler function or the name of a method on the specified scope.

scope :  Object (optional)

If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed.

options :  Object (optional)

If the ename parameter was an event name, this is the addListener options.

Returns

:Object

Only when the destroyable option is specified.

A Destroyable object. An object which implements the destroy method which removes all listeners added in this call. For example:

this.btnListeners = myButton.mon({
    destroyable: true
     mouseover:   function() { console.log('mouseover'); },
    mouseout:    function() { console.log('mouseout'); },
    click:       function() { console.log('click'); }
});

And when those listeners need to be removed:

Ext.destroy(this.btnListeners);

or

this.btnListeners.destroy();

mun ( item, ename, [fn], [scope] )

Shorthand for removeManagedListener. Removes listeners that were added by the mon method.

Parameters

item :  Ext.util.Observable/Ext.dom.Element

The item from which to remove a listener/listeners.

ename :  Object/String

The event name, or an object containing event name properties.

fn :  Function (optional)

If the ename parameter was an event name, this is the handler function.

scope :  Object (optional)

If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed.

on ( eventName, [fn], [scope], [options], [order] ) : Object

The on method is shorthand for addListener.

Appends an event handler to this object. For example:

myGridPanel.on("itemclick", this.onItemClick, this);

The method also allows for a single argument to be passed which is a config object containing properties which specify multiple events. For example:

myGridPanel.on({
    cellclick: this.onCellClick,
    select: this.onSelect,
    viewready: this.onViewReady,
    scope: this // Important. Ensure "this" is correct during handler execution
});

One can also specify options for each event handler separately:

myGridPanel.on({
    cellclick: {fn: this.onCellClick, scope: this, single: true},
    viewready: {fn: panel.onViewReady, scope: panel}
});

Names of methods in a specified scope may also be used:

myGridPanel.on({
    cellclick: {fn: 'onCellClick', scope: this, single: true},
    viewready: {fn: 'onViewReady', scope: panel}
});

Parameters

eventName :  String/Object

The name of the event to listen for. May also be an object who's property names are event names.

fn :  Function/String (optional)

The method the event invokes or the name of the method within the specified scope. Will be called with arguments given to Ext.util.Observable#fireEvent plus the options parameter described below.

scope :  Object (optional)

The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event.

options :  Object (optional)

An object containing handler configuration.

Note: The options object will also be passed as the last argument to every event handler.

This object may contain any of the following properties:

scope :  Object

The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event.

delay :  Number

The number of milliseconds to delay the invocation of the handler after the event fires.

single :  Boolean

True to add a handler to handle just the next firing of the event, and then remove itself.

buffer :  Number

Causes the handler to be scheduled to run in an Ext.util.DelayedTask delayed by the specified number of milliseconds. If the event fires again within that time, the original handler is not invoked, but the new handler is scheduled in its place.

onFrame :  Number

Causes the handler to be scheduled to run at the next animation frame event. If the event fires again before that time, the handler is not rescheduled - the handler will only be called once when the next animation frame is fired, with the last set of arguments passed.

target :  Ext.util.Observable

Only call the handler if the event was fired on the target Observable, not if the event was bubbled up from a child Observable.

element :  String

This option is only valid for listeners bound to Ext.Component. The name of a Component property which references an Ext.dom.Element to add a listener to.

This option is useful during Component construction to add DOM event listeners to elements of Ext.Component which will exist only after the Component is rendered.

For example, to add a click listener to a Panel's body:

  var panel = new Ext.panel.Panel({
      title: 'The title',
      listeners: {
          click: this.handlePanelClick,
          element: 'body'
      }
  });

In order to remove listeners attached using the element, you'll need to reference the element itself as seen below.

 panel.body.un(...)

delegate :  String (optional)

A simple selector to filter the event target or look for a descendant of the target.

The "delegate" option is only available on Ext.dom.Element instances (or when attaching a listener to a Ext.dom.Element via a Component using the element option).

See the delegate example below.

capture :  Boolean (optional)

When set to true, the listener is fired in the capture phase of the event propagation sequence, instead of the default bubble phase.

The capture option is only available on Ext.dom.Element instances (or when attaching a listener to a Ext.dom.Element via a Component using the element option).

stopPropagation :  Boolean (optional)

This option is only valid for listeners bound to Ext.dom.Element. true to call stopPropagation on the event object before firing the handler.

preventDefault :  Boolean (optional)

This option is only valid for listeners bound to Ext.dom.Element. true to call preventDefault on the event object before firing the handler.

stopEvent :  Boolean (optional)

This option is only valid for listeners bound to Ext.dom.Element. true to call stopEvent on the event object before firing the handler.

args :  Array (optional)

Optional arguments to pass to the handler function. Any additional arguments passed to fireEvent will be appended to these arguments.

destroyable :  Boolean (optional)

When specified as true, the function returns a destroyable object. An object which implements the destroy method which removes all listeners added in this call. This syntax can be a helpful shortcut to using un; particularly when removing multiple listeners. NOTE - not compatible when using the element option. See un for the proper syntax for removing listeners added using the element config.

Defaults to:

false

priority :  Number (optional)

An optional numeric priority that determines the order in which event handlers are run. Event handlers with no priority will be run as if they had a priority of 0. Handlers with a higher priority will be prioritized to run sooner than those with a lower priority. Negative numbers can be used to set a priority lower than the default. Internally, the framework uses a range of 1000 or greater, and -1000 or lesser for handlers that are intended to run before or after all others, so it is recommended to stay within the range of -999 to 999 when setting the priority of event handlers in application-level code. A priority must be an integer to be valid. Fractional values are reserved for internal framework use.

order :  String (optional)

A legacy option that is provided for backward compatibility. It is recommended to use the priority option instead. Available options are:

  • 'before': equal to a priority of 100
  • 'current': equal to a priority of 0 or default priority
  • 'after': equal to a priority of -100

Defaults to:

'current'

order :  String (optional)

A shortcut for the order event option. Provided for backward compatibility. Please use the priority event option instead.

Combining Options

Using the options argument, it is possible to combine different types of listeners:

A delayed, one-time listener.

myPanel.on('hide', this.handleClick, this, {
    single: true,
    delay: 100
});

Attaching multiple handlers in 1 call

The method also allows for a single argument to be passed which is a config object containing properties which specify multiple handlers and handler configs.

grid.on({
    itemclick: 'onItemClick',
    itemcontextmenu: grid.onItemContextmenu,
    destroy: {
        fn: function () {
            // function called within the 'altCmp' scope instead of grid
        },
        scope: altCmp // unique scope for the destroy handler
    },
    scope: grid       // default scope - provided for example clarity
});

Delegate

This is a configuration option that you can pass along when registering a handler for an event to assist with event delegation. By setting this configuration option to a simple selector, the target element will be filtered to look for a descendant of the target. For example:

var panel = Ext.create({
    xtype: 'panel',
    renderTo: document.body,
    title: 'Delegate Handler Example',
    frame: true,
    height: 220,
    width: 220,
    html: '<h1 class="myTitle">BODY TITLE</h1>Body content'
});

// The click handler will only be called when the click occurs on the
// delegate: h1.myTitle ("h1" tag with class "myTitle")
panel.on({
    click: function (e) {
        console.log(e.getTarget().innerHTML);
    },
    element: 'body',
    delegate: 'h1.myTitle'
 });

Defaults to: 'current'

Returns

:Object

Only when the destroyable option is specified.

A Destroyable object. An object which implements the destroy method which removes all listeners added in this call. For example:

this.btnListeners =  = myButton.on({
    destroyable: true
    mouseover:   function() { console.log('mouseover'); },
    mouseout:    function() { console.log('mouseout'); },
    click:       function() { console.log('click'); }
});

And when those listeners need to be removed:

Ext.destroy(this.btnListeners);

or

this.btnListeners.destroy();

onAfter ( eventName, fn, [scope], [options] )

Appends an after-event handler.

Same as addListener with order set to 'after'.

Parameters

eventName :  String/String[]/Object

The name of the event to listen for.

fn :  Function/String

The method the event invokes.

scope :  Object (optional)

The scope for fn.

options :  Object (optional)

An object containing handler configuration.

onBefore ( eventName, fn, [scope], [options] )

Appends a before-event handler. Returning false from the handler will stop the event.

Same as addListener with order set to 'before'.

Parameters

eventName :  String/String[]/Object

The name of the event to listen for.

fn :  Function/String

The method the event invokes.

scope :  Object (optional)

The scope for fn.

options :  Object (optional)

An object containing handler configuration.

onFilterChange ( filters )
template tpl

Called after a change of the filter is complete.

For example:

 onFilterChange: function (filters) {
     if (this.filtered) {
         // process filters
     } else {
         // no filters present
     }
 }

Parameters

filters :  Ext.util.FilterCollection

The filters collection.

This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.

onSortChange ( sorters )
template tpl

Called after a change of the sort is complete.

For example:

 onSortChange: function (sorters) {
     if (this.sorted) {
         // process sorters
     } else {
         // no sorters present
     }
 }

Parameters

sorters :  Ext.util.SorterCollection

The sorters collection.

This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.

relayEvents ( origin, events, [prefix] ) : Object

Relays selected events from the specified Observable as if the events were fired by this.

For example if you are extending Grid, you might decide to forward some events from store. So you can do this inside your initComponent:

this.relayEvents(this.getStore(), ['load']);

The grid instance will then have an observable 'load' event which will be passed the parameters of the store's load event and any function fired with the grid's load event would have access to the grid using the this keyword (unless the event is handled by a controller's control/listen event listener in which case 'this' will be the controller rather than the grid).

Parameters

origin :  Object

The Observable whose events this object is to relay.

events :  String[]/Object

Array of event names to relay or an Object with key/value pairs translating to ActualEventName/NewEventName respectively. For example: this.relayEvents(this, {add:'push', remove:'pop'});

Would now redispatch the add event of this as a push event and the remove event as a pop event.

prefix :  String (optional)

A common prefix to prepend to the event names. For example:

this.relayEvents(this.getStore(), ['load', 'clear'], 'store');

Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'.

Returns

:Object

A Destroyable object. An object which implements the destroy method which, when destroyed, removes all relayers. For example:

this.storeRelayers = this.relayEvents(this.getStore(), ['load', 'clear'], 'store');

Can be undone by calling

Ext.destroy(this.storeRelayers);

or this.store.relayers.destroy();

remove ( item ) : Number

Remove an item from the collection.

Available since: 5.0.0

Parameters

item :  Object/Object[]

The item or items to remove.

Returns

:Number

The number of items removed.

removeAll Ext.util.Collection

Remove all items in the collection.

Available since: 5.0.0

Returns

:Ext.util.Collection

This object.

removeAt ( index, [count] ) : Object/Number

Remove an item from a specified index in the collection.

Available since: 5.0.0

Parameters

index :  Number

The index within the collection of the item to remove.

count :  Number (optional)

The number of items to remove.

Defaults to: 1

Returns

:Object/Number

If count was 1 and the item was removed, that item is returned. Otherwise the number of items removed is returned.

removeByKey ( key ) : Object

Removes the item associated with the passed key from the collection.

Available since: 5.0.0

Parameters

key :  String

The key of the item to remove.

Returns

:Object

Only returned if removing at a specified key. The item removed or false if no item was removed.

removeListener ( eventName, fn, [scope] )

Removes an event handler.

Parameters

eventName :  String

The type of event the handler was associated with.

fn :  Function

The handler to remove. This must be a reference to the function passed into the addListener call.

scope :  Object (optional)

The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable#addListener or the listener will not be removed.

Convenience Syntax

You can use the addListener destroyable: true config option in place of calling un(). For example:

var listeners = cmp.on({
    scope: cmp,
    afterrender: cmp.onAfterrender,
    beforehide: cmp.onBeforeHide,
    destroyable: true
});

// Remove listeners
listeners.destroy();
// or
cmp.un(
    scope: cmp,
    afterrender: cmp.onAfterrender,
    beforehide: cmp.onBeforeHide
);

Exception - DOM event handlers using the element config option

You must go directly through the element to detach an event handler attached using the addListener element option.

panel.on({
    element: 'body',
    click: 'onBodyCLick'
});

panel.body.un({
    click: 'onBodyCLick'
});

removeManagedListener ( item, ename, [fn], [scope] )

Removes listeners that were added by the mon method.

Parameters

item :  Ext.util.Observable/Ext.dom.Element

The item from which to remove a listener/listeners.

ename :  Object/String

The event name, or an object containing event name properties.

fn :  Function (optional)

If the ename parameter was an event name, this is the handler function.

scope :  Object (optional)

If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed.

replaceAll ( item ) : Object/Object[]

Adds an item to the collection while removing any existing items. Similar to method-add.

Available since: 5.0.0

Parameters

item :  Object/Object[]

The item or items to add.

Returns

:Object/Object[]

The item or items added.

resumeEvent ( eventName )

Resumes firing of the named event(s).

After calling this method to resume events, the events will fire when requested to fire.

Note that if the suspendEvent method is called multiple times for a certain event, this converse method will have to be called the same number of times for it to resume firing.

Parameters

eventName :  String...

Multiple event names to resume.

resumeEvents ( [discardQueue] )

Resumes firing events (see suspendEvents).

If events were suspended using the queueSuspended parameter, then all events fired during event suspension will be sent to any listeners now.

Parameters

discardQueue :  Boolean (optional)

true to prevent any previously queued events from firing while we were suspended. See suspendEvents.

sort ( [property], [direction], [mode] ) : Ext.util.Collection

Updates the sorters collection and triggers sorting of this Sortable.

For example:

//sort by a single field
myStore.sort('myField', 'DESC');

//sorting by multiple fields
myStore.sort([{
    property : 'age',
    direction: 'ASC'
}, {
    property : 'name',
    direction: 'DESC'
}]);

When passing a single string argument to sort, the direction is maintained for each field and is toggled automatically. So this code:

store.sort('myField');
store.sort('myField');

Is equivalent to the following:

store.sort('myField', 'ASC');
store.sort('myField', 'DESC');

Parameters

property :  String/Function/Ext.util.Sorter[] (optional)

Either the name of a property (such as a field of a Ext.data.Model in a Store), an array of configurations for Ext.util.Sorter instances or just a comparison function.

direction :  String (optional)

The direction by which to sort the data. This parameter is only valid when property is a String, otherwise the second parameter is the mode.

mode :  String (optional)

Where to put new sorters in the collection. This should be one the following values:

  • **replace** : The new sorter(s) become the sole sorter set for this Sortable. This is the most useful call mode to programmatically sort by multiple fields.

  • **prepend** : The new sorters are inserted as the primary sorters. The sorter collection length must be controlled by the developer.

  • **multi** : Similar to **prepend** the new sorters are inserted at the front of the collection of sorters. Following the insertion, however, this mode trims the sorter collection to enforce the multiSortLimit config. This is useful for implementing intuitive "Sort by this" user interfaces.

  • **append** : The new sorters are added at the end of the collection.

Defaults to: "replace"

Returns

:Ext.util.Collection

This instance.

sortData ( data ) : Array

This method will sort an array based on the currently configured sorters.

Parameters

data :  Array

The array you want to have sorted.

Returns

:Array

The array you passed after it is sorted.

sortItems ( sortFn )

Sorts the items of the collection using the supplied function. This should only be called for collections that have no sorters defined.

Available since: 5.0.0

Parameters

sortFn :  Function

The function by which to sort the items.

splice ( index, toRemove, [toAdd] )

This method is basically the same as the JavaScript Array splice method.

Negative indexes are interpreted starting at the end of the collection. That is, a value of -1 indicates the last item, or equivalent to length - 1.

Available since: 5.0.0

Parameters

index :  Number

The index at which to add or remove items.

toRemove :  Number/Object[]

The number of items to remove or an array of the items to remove.

toAdd :  Object[] (optional)

The items to insert at the given index.

sum ( property, [begin], [end] ) : Object

Sums property values from some or all of the items in this collection.

Available since: 5.0.0

Parameters

property :  String

The name of the property to sum from each item.

begin :  Number (optional)

The index of the first item to include in the sum.

end :  Number (optional)

The index at which to stop summing items. The item at this index will not be included in the sum.

Returns

:Object

The result of summing the specified property from the indicated items.

sumByGroup ( property ) : Object

See sum. The result is partitioned by group.

Available since: 5.0.0

Parameters

property :  String

The name of the property to sum from each item.

Returns

:Object

The result of sum, partitioned by group. See aggregateByGroup.

suspendEvent ( eventName )

Suspends firing of the named event(s).

After calling this method to suspend events, the events will no longer fire when requested to fire.

Note that if this is called multiple times for a certain event, the converse method resumeEvent will have to be called the same number of times for it to resume firing.

Parameters

eventName :  String...

Multiple event names to suspend.

suspendEvents ( queueSuspended )

Suspends the firing of all events. (see resumeEvents)

Parameters

queueSuspended :  Boolean

true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events.

un ( eventName, fn, [scope] )

Shorthand for removeListener. Removes an event handler.

Parameters

eventName :  String

The type of event the handler was associated with.

fn :  Function

The handler to remove. This must be a reference to the function passed into the addListener call.

scope :  Object (optional)

The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable#addListener or the listener will not be removed.

Convenience Syntax

You can use the addListener destroyable: true config option in place of calling un(). For example:

var listeners = cmp.on({
    scope: cmp,
    afterrender: cmp.onAfterrender,
    beforehide: cmp.onBeforeHide,
    destroyable: true
});

// Remove listeners
listeners.destroy();
// or
cmp.un(
    scope: cmp,
    afterrender: cmp.onAfterrender,
    beforehide: cmp.onBeforeHide
);

Exception - DOM event handlers using the element config option

You must go directly through the element to detach an event handler attached using the addListener element option.

panel.on({
    element: 'body',
    click: 'onBodyCLick'
});

panel.body.un({
    click: 'onBodyCLick'
});

unAfter ( eventName, fn, [scope], [options] )

Removes a before-event handler.

Same as removeListener with order set to 'after'.

Parameters

eventName :  String/String[]/Object

The name of the event the handler was associated with.

fn :  Function/String

The handler to remove.

scope :  Object (optional)

The scope originally specified for fn.

options :  Object (optional)

Extra options object.

unBefore ( eventName, fn, [scope], [options] )

Removes a before-event handler.

Same as removeListener with order set to 'before'.

Parameters

eventName :  String/String[]/Object

The name of the event the handler was associated with.

fn :  Function/String

The handler to remove.

scope :  Object (optional)

The scope originally specified for fn.

options :  Object (optional)

Extra options object.

update ( fn, [scope] ) : Object

This method calls the supplied function fn between beginUpdate and endUpdate calls.

 collection.update(function () {
     // Perform multiple collection updates...

     collection.add(item);
     // ...

     collection.insert(index, otherItem);
     //...

     collection.remove(someItem);
 });

Available since: 5.0.0

Parameters

fn :  Function

The function to call that will modify this collection.

collection :  Ext.util.Collection

This collection.

scope :  Object (optional)

The this pointer to use when calling fn.

Defaults to: this

Returns

:Object

Returns the value returned from fn (typically undefined).

updateKey ( item, oldKey )

Change the key for an existing item in the collection. If the old key does not exist this call does nothing. Even so, it is highly recommended to avoid calling this method for an item that is not a member of this collection.

Available since: 5.0.0

Parameters

item :  Object

The item whose key has changed. The item should be a member of this collection.

oldKey :  String

The old key for the item.

Static Methods

override ( members ) : Ext.Base
static sta

Override members of this class. Overridden methods can be invoked via Ext.Base#callParent.

Ext.define('My.Cat', {
    constructor: function() {
        alert("I'm a cat!");
    }
});

My.Cat.override({
    constructor: function() {
        alert("I'm going to be a cat!");

        this.callParent(arguments);

        alert("Meeeeoooowwww");
    }
});

var kitty = new My.Cat(); // alerts "I'm going to be a cat!"
                          // alerts "I'm a cat!"
                          // alerts "Meeeeoooowwww"

Direct use of this method should be rare. Use Ext.define instead:

Ext.define('My.CatOverride', {
    override: 'My.Cat',
    constructor: function() {
        alert("I'm going to be a cat!");

        this.callParent(arguments);

        alert("Meeeeoooowwww");
    }
});

The above accomplishes the same result but can be managed by the Ext.Loader which can properly order the override and its target class and the build process can determine whether the override is needed based on the required state of the target class (My.Cat).

Parameters

members :  Object

The properties to add to this class. This should be specified as an object literal containing one or more properties.

Returns

:Ext.Base

this class

events

add ( collection, details, eOpts )

Fires after items have been added to the collection.

All add and remove events occur between beginupdate and endupdate events so it is best to do only the minimal amount of work in response to these events and move the more expensive side-effects to an endupdate listener.

Available since: 5.0.0

Parameters

collection :  Ext.util.Collection

The collection being modified.

details :  Object

An object describing the addition.

at :  Number

The index in the collection where the add occurred.

atItem :  Object

The item after which the new items were inserted or null if at the beginning of the collection.

items :  Object[]

The items that are now added to the collection.

keys :  Array (optional)

If available this array holds the keys (extracted by getKey) for each item in the items array.

next :  Object (optional)

If more add events are in queue to be delivered this is a reference to the details instance for the next add event. This will only be the case when the collection is sorted as the new items often need to be inserted at multiple locations to maintain the sort. In this case, all of the new items have already been added not just those described by the first add event.

replaced :  Object (optional)

If this addition has a corresponding set of remove events this reference holds the details object for the first remove event. That details object may have a next property if there are multiple associated remove events.

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

beforeitemchange ( collection, details, eOpts )

This event fires before an item change is reflected in the collection. This event is always followed by an itemchange event and, depending on the change, possibly an add, remove and/or updatekey event.

Available since: 5.0.0

Parameters

collection :  Ext.util.Collection

The collection being modified.

details :  Object

An object describing the change.

item :  Object

The item that has changed.

key :  String

The key of the item that has changed.

filterChanged :  Boolean

This is true if the filter status of the item has changed. That is, the item was previously filtered out and is no longer or the opposite.

keyChanged :  Boolean

This is true if the item has changed keys. If so, check oldKey for the old key. An updatekey event will follow.

indexChanged :  Boolean

This is true if the item needs to move to a new index in the collection due to sorting. The index can be seen in index. The old index is in oldIndex.

modified :  String[] (optional)

If known this property holds the array of names of the modified properties of the item.

filtered :  Boolean (optional)

This value is true if the item will be filtered out of the collection.

index :  Number (optional)

The new index in the collection for the item if the item is being moved (see indexChanged). If the item is being removed due to filtering, this will be -1.

oldIndex :  Number (optional)

The old index in the collection for the item if the item is being moved (see indexChanged). If the item was being removed due to filtering, this will be -1.

oldKey :  Object (optional)

The old key for the item if the item's key has changed (see keyChanged).

wasFiltered :  Boolean (optional)

This value is true if the item was filtered out of the collection.

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

beginupdate ( collection, eOpts )

Fired before changes are made to the collection. This event fires when the beginUpdate method is called and the counter it manages transitions from 0 to 1.

All add and remove events occur between beginupdate and endupdate events so it is best to do only the minimal amount of work in response to these events and move the more expensive side-effects to an endupdate listener.

Available since: 5.0.0

Parameters

collection :  Ext.util.Collection

The collection being modified.

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

endupdate ( collection, eOpts )

Fired after changes are made to the collection. This event fires when the endUpdate method is called and the counter it manages transitions from 1 to 0.

All add and remove events occur between beginupdate and endupdate events so it is best to do only the minimal amount of work in response to these events and move the more expensive side-effects to an endupdate listener.

Available since: 5.0.0

Parameters

collection :  Ext.util.Collection

The collection being modified.

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

itemchange ( collection, details, eOpts )

This event fires after an item change is reflected in the collection. This event always follows a beforeitemchange event and its corresponding add, remove and/or updatekey events.

Available since: 5.0.0

Parameters

collection :  Ext.util.Collection

The collection being modified.

details :  Object

An object describing the change.

item :  Object

The item that has changed.

key :  String

The key of the item that has changed.

filterChanged :  Boolean

This is true if the filter status of the item has changed. That is, the item was previously filtered out and is no longer or the opposite.

keyChanged :  Object

This is true if the item has changed keys. If so, check oldKey for the old key. An updatekey event will have been sent.

indexChanged :  Boolean

This is true if the item was moved to a new index in the collection due to sorting. The index can be seen in index. The old index is in oldIndex.

modified :  String[] (optional)

If known this property holds the array of names of the modified properties of the item.

filtered :  Boolean (optional)

This value is true if the item is filtered out of the collection.

index :  Number (optional)

The new index in the collection for the item if the item has been moved (see indexChanged). If the item is removed due to filtering, this will be -1.

oldIndex :  Number (optional)

The old index in the collection for the item if the item has been moved (see indexChanged). If the item was being removed due to filtering, this will be -1.

oldKey :  Object (optional)

The old key for the item if the item's key has changed (see keyChanged).

wasFiltered :  Boolean (optional)

This value is true if the item was filtered out of the collection.

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

refresh ( collection, eOpts )

This event fires when the collection has changed entirely. This event is fired in cases where the collection's filter is updated or the items are sorted. While the items previously in the collection may remain the same, the order at a minimum has changed in ways that cannot be simply translated to other events.

Parameters

collection :  Ext.util.Collection

The collection being modified.

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

remove ( collection, details, eOpts )

Fires after items have been removed from the collection. Some properties of this object may not be present if calculating them is deemed too expensive. These are marked as "optional".

All add and remove events occur between beginupdate and endupdate events so it is best to do only the minimal amount of work in response to these events and move the more expensive side-effects to an endupdate listener.

Available since: 5.0.0

Parameters

collection :  Ext.util.Collection

The collection being modified.

details :  Object

An object describing the removal.

at :  Number

The index in the collection where the removal occurred.

items :  Object[]

The items that are now removed from the collection.

keys :  Array (optional)

If available this array holds the keys (extracted by getKey) for each item in the items array.

map :  Object (optional)

If available this is a map keyed by the key of each item in the items array. This will often contain all of the items being removed and not just the items in the range described by this event. The value held in this map is the item.

next :  Object (optional)

If more remove events are in queue to be delivered this is a reference to the details instance for the next remove event.

replacement :  Object (optional)

If this removal has a corresponding add taking place this reference holds the details object for that add event. If the collection is sorted, the new items are pre-sorted but the at property for the replacement will not be correct. The new items will be added in one or more chunks at their proper index.

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

sort ( collection, eOpts )

This event fires after the contents of the collection have been sorted.

Parameters

collection :  Ext.util.Collection

The collection being sorted.

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

updatekey ( collection, details, eOpts )

Fires after the key for an item has changed.

Available since: 5.0.0

Parameters

collection :  Ext.util.Collection

The collection being modified.

details :  Object

An object describing the update.

item :  Object

The item whose key has changed.

newKey :  Object

The new key for the item.

oldKey :  Object

The old key for the item.

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

ExtReact 6.6.0