Docs Help

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.

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

- 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.

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.

Ext JS 6.2.2 - Modern Toolkit


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

autoGroup : Boolean
private pri

true to sort by the grouper

Defaults to:

true

getAutoGroup : Boolean

Returns the value of autoGroup

Returns

Boolean

setAutoGroup (autoGroup)

Sets the value of autoGroup

Parameters

autoGroup :  Boolean

autoSort : Boolean
private pri

true to maintain sorted order when items are added regardless of requested insertion point, or when an item mutation results in a new sort position.

This does not affect a filtered Collection's reaction to mutations of the source Collection. If sorters are present when the source Collection is mutated, this Collection's sort order will always be maintained.

Defaults to:

true

getAutoSort : Boolean

Returns the value of autoSort

Returns

Boolean

setAutoSort (autoSort)

Sets the value of autoSort

Parameters

autoSort :  Boolean

decoder : Function

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

Defaults to:

null

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.

Defaults to:

null

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 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).

Defaults to:

null

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);
         }
     }
 });

Defaults to:

null

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.

Defaults to:

null

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.

Defaults to:

null

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).

Defaults to:

null

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.

Defaults to:

null

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

trackGroups : Boolean
private pri

true to track individual groups in a Ext.util.GroupCollection

Defaults to:

true

getTrackGroups : Boolean

Returns the value of trackGroups

Returns

Boolean

setTrackGroups (trackGroups)

Sets the value of trackGroups

Parameters

trackGroups :  Boolean

properties

Instance Properties

$className
private pri

Defaults to:

'Ext.Base'

$configPrefixed : Boolean
private pri

The value true causes config values to be stored on instances using a property name prefixed with an underscore ("_") character. A value of false stores config values as properties using their exact name (no prefix).

Defaults to:

true

Available since: 5.0.0

$configStrict : Boolean
private pri

The value true instructs the initConfig method to only honor values for properties declared in the config block of a class. When false, properties that are not declared in a config block will be placed on the instance.

Defaults to:

true

Available since: 5.0.0

$endUpdatePriority
private pri

Priority that is used for endupdate listeners on the filters and sorters. set to a very high priority so that our processing of these events takes place prior to user code - data must already be filtered/sorted when the user's handler runs

Defaults to:

1001

$eventOptions
private pri

Matches options property names within a listeners specification object - property names which are never used as event names.

Defaults to:

{
    scope: 1,
    delay: 1,
    buffer: 1,
    onFrame: 1,
    single: 1,
    args: 1,
    destroyable: 1,
    priority: 1,
    order: 1
}

$vetoClearingPrototypeOnDestroy
private pri

We don't want the base destructor to clear the prototype because our destroyObservable handler must be called the very last. It will take care of the prototype after completing Observable destruction sequence.

Defaults to:

true

clearPropertiesOnDestroy : Boolean / "async"
protected pro

Setting this property to false will prevent nulling object references on a Class instance after destruction. Setting this to "async" will delay the clearing for approx 50ms.

Defaults to:

true

Available since: 6.2.0

clearPrototypeOnDestroy : Boolean
private pri

Setting this property to true will result in setting the object's prototype to null after the destruction sequence is fully completed. After that, most attempts at calling methods on the object instance will result in "method not defined" exception. This can be very helpful with tracking down otherwise hard to find bugs like runaway Ajax requests, timed functions not cleared on destruction, etc.

Note that this option can only work in browsers that support Object.setPrototypeOf method, and is only available in debugging mode.

Defaults to:

false

Available since: 6.2.0

destroyed : Boolean
protected pro

This property is set to true after the destroy method is called.

Defaults to:

false

eventsSuspended
private pri

Initial suspended call count. Incremented when suspendEvents is called, decremented when resumeEvents is called.

Defaults to:

0

filtered : Boolean
readonly ro

A read-only flag indicating if this object is filtered.

Defaults to:

false

generation : Number
readonly ro

Mutation counter which is incremented when the collection changes.

Defaults to:

0

Available since: 5.0.0

grouped : Boolean
readonly ro

A read-only flag indicating if this object is grouped.

Defaults to:

false

hasListeners : Object
readonly ro

This object holds a key for any event that has a listener. The listener may be set directly on the instance, or on its class or a super class (via observe) or on the Ext.app.EventBus. The values of this object are truthy (a non-zero number) and falsy (0 or undefined). They do not represent an exact count of listeners. The value for an event is truthy if the event must be fired and is falsy if there is no need to fire the event.

The intended use of this property is to avoid the expense of fireEvent calls when there are no listeners. This can be particularly helpful when one would otherwise have to call fireEvent hundreds or thousands of times. It is used like this:

 if (this.hasListeners.foo) {
     this.fireEvent('foo', this, arg1);
 }

indexRebuilds : Number
readonly ro private pri

The number of times the indices have been rebuilt. This is for diagnostic use.

Defaults to:

0

Available since: 5.0.0

indices : Object
private pri

An object used as map to get the index of an item.

Defaults to:

null

Available since: 5.0.0

isCollection : Boolean
readonly ro

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

Defaults to:

true

isConfiguring : Boolean
readonly ro protected pro

This property is set to true during the call to initConfig.

Defaults to:

false

Available since: 5.0.0

isFirstInstance : Boolean
readonly ro protected pro

This property is set to true if this instance is the first of its class.

Defaults to:

false

Available since: 5.0.0

isInstance : Boolean
readonly ro protected pro

This value is true and is used to identify plain objects from instances of a defined class.

Defaults to:

true

isObservable : Boolean

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

Defaults to:

true

items : Object[]
private pri

An array containing the items.

Defaults to:

[]

Available since: 5.0.0

length : Number
readonly ro

The count of items in the collection.

Defaults to:

0

Available since: 5.0.0

manageSorters
private pri

true to destroy the sorter collection on destroy.

Defaults to:

true

map : Object
private pri

An object used as a map to find items based on their key.

Defaults to:

{}

Available since: 5.0.0

self : Ext.Class
protected pro

Get the reference to the current class from which this object was instantiated. Unlike Ext.Base#statics, this.self is scope-dependent and it's meant to be used for dynamic inheritance. See Ext.Base#statics for a detailed comparison

Ext.define('My.Cat', {
    statics: {
        speciesName: 'Cat' // My.Cat.speciesName = 'Cat'
    },

    constructor: function() {
        alert(this.self.speciesName); // dependent on 'this'
    },

    clone: function() {
        return new this.self();
    }
});


Ext.define('My.SnowLeopard', {
    extend: 'My.Cat',
    statics: {
        speciesName: 'Snow Leopard'         // My.SnowLeopard.speciesName = 'Snow Leopard'
    }
});

var cat = new My.Cat();                     // alerts 'Cat'
var snowLeopard = new My.SnowLeopard();     // alerts 'Snow Leopard'

var clone = snowLeopard.clone();
alert(Ext.getClassName(clone));             // alerts 'My.SnowLeopard'

Defaults to:

Base

sorted : Boolean
readonly ro

A read-only flag indicating if this object is sorted. This flag may not be correct during an update of the sorter collection but will be correct before onSortChange is called. This flag is true if grouped is true because the collection is at least sorted by the grouper.

Defaults to:

false

updating : Number
readonly ro

A counter that is increased by beginUpdate and decreased by endUpdate. When this transitions from 0 to 1 the beginupdate event is fired. When it transitions back from 1 to 0 the endupdate event is fired.

Defaults to:

0

Available since: 5.0.0

Static Properties

$onExtended
static sta private pri

Defaults to:

[]

methods

Instance Methods

_addDeclaredListeners ( listeners ) : Boolean
private pri

Adds declarative listeners as nested arrays of listener objects.

Parameters

listeners :  Array

Returns

:Boolean

true if any listeners were added

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.

addDeprecations ( deprecations )
private pri

This method applies a versioned, deprecation declaration to this class. This is typically called by the deprecated config.

Parameters

deprecations :  Object

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

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 set of arguments to pass to the handler function before the actual fired event arguments. For example, if args is set to ['foo', 42], the event handler function will be called with an arguments list like this:

 handler('foo', 42, <actual event 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();

addObserver ( observer )
private pri

Adds an observing object to this collection. Observers are given first view of all events that we may fire. For any event an observer may implement a method whose name starts with "onCollection" to receive the event. The add event for example would be passed to "onCollectionAdd".

The only restriction to observers is that they are not allowed to add or remove observers from inside these methods.

Available since: 5.0.0

Parameters

observer :  Ext.util.Collection

The observer instance.

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

aggregateGroups ( groups, property, operation, [scope] ) : Object
private pri

Aggregates a set of groups.

Parameters

groups :  Ext.util.GroupCollection

The groups

property :  String

The name of the property to aggregate from each item.

operation :  String/Function

The operation to perform.

values :  Array

The values on which the operation function is to operate.

items :  Array

The items on which the operation function is to operate.

index :  Number

The index in items at which the operation function is to start. The values.length indicates the number of items involved.

scope :  Object (optional)

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

Returns

:Object

aggregateItems ( items, property, operation, [begin], [end], [scope] ) : Object
private pri

Returns the result of the specified aggregation operation against the given items. For details see aggregate.

Parameters

items :  Array

The items to aggregate.

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

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.

callOverridden ( args ) : Object
deprecated dep protected pro

Call the original method that was previously overridden with Ext.Base#override

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.callOverridden();

        alert("Meeeeoooowwww");
    }
});

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

Parameters

args :  Array/Arguments

The arguments, either an array or the arguments object from the current method, for example: this.callOverridden(arguments)

Returns

:Object

Returns the result of calling the overridden method

Deprecated since version 4.1.0
Use method-callParent instead.

callParent ( args ) : Object
protected pro

Call the "parent" method of the current method. That is the method previously overridden by derivation or by an override (see Ext#define).

 Ext.define('My.Base', {
     constructor: function (x) {
         this.x = x;
     },

     statics: {
         method: function (x) {
             return x;
         }
     }
 });

 Ext.define('My.Derived', {
     extend: 'My.Base',

     constructor: function () {
         this.callParent([21]);
     }
 });

 var obj = new My.Derived();

 alert(obj.x);  // alerts 21

This can be used with an override as follows:

 Ext.define('My.DerivedOverride', {
     override: 'My.Derived',

     constructor: function (x) {
         this.callParent([x*2]); // calls original My.Derived constructor
     }
 });

 var obj = new My.Derived();

 alert(obj.x);  // now alerts 42

This also works with static and private methods.

 Ext.define('My.Derived2', {
     extend: 'My.Base',

     // privates: {
     statics: {
         method: function (x) {
             return this.callParent([x*2]); // calls My.Base.method
         }
     }
 });

 alert(My.Base.method(10));     // alerts 10
 alert(My.Derived2.method(10)); // alerts 20

Lastly, it also works with overridden static methods.

 Ext.define('My.Derived2Override', {
     override: 'My.Derived2',

     // privates: {
     statics: {
         method: function (x) {
             return this.callParent([x*2]); // calls My.Derived2.method
         }
     }
 });

 alert(My.Derived2.method(10); // now alerts 40

To override a method and replace it and also call the superclass method, use method-callSuper. This is often done to patch a method to fix a bug.

Parameters

args :  Array/Arguments

The arguments, either an array or the arguments object from the current method, for example: this.callParent(arguments)

Returns

:Object

Returns the result of calling the parent method

callSuper ( args ) : Object
protected pro

This method is used by an override to call the superclass method but bypass any overridden method. This is often done to "patch" a method that contains a bug but for whatever reason cannot be fixed directly.

Consider:

 Ext.define('Ext.some.Class', {
     method: function () {
         console.log('Good');
     }
 });

 Ext.define('Ext.some.DerivedClass', {
     extend: 'Ext.some.Class',

     method: function () {
         console.log('Bad');

         // ... logic but with a bug ...

         this.callParent();
     }
 });

To patch the bug in Ext.some.DerivedClass.method, the typical solution is to create an override:

 Ext.define('App.patches.DerivedClass', {
     override: 'Ext.some.DerivedClass',

     method: function () {
         console.log('Fixed');

         // ... logic but with bug fixed ...

         this.callSuper();
     }
 });

The patch method cannot use method-callParent to call the superclass method since that would call the overridden method containing the bug. In other words, the above patch would only produce "Fixed" then "Good" in the console log, whereas, using callParent would produce "Fixed" then "Bad" then "Good".

Parameters

args :  Array/Arguments

The arguments, either an array or the arguments object from the current method, for example: this.callSuper(arguments)

Returns

:Object

Returns the result of calling the superclass method

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.

createRelayer ( newName, [beginEnd] ) : Function
private pri

Creates an event handling function which re-fires the event from this object as the passed event name.

Parameters

newName :  String

The name under which to re-fire the passed parameters.

beginEnd :  Array (optional)

The caller can specify on which indices to slice.

Returns

:Function

decodeItems ( args, index ) : Object[]
private pri

Returns the items array on which to operate. This is called to handle the two possible forms used by various methods that accept items:

 collection.add(item1, item2, item3);
 collection.add([ item1, item2, item3 ]);

Things get interesting when other arguments are involved:

 collection.insert(index, item1, item2, item3);
 collection.insert(index, [ item1, item2, item3 ]);

As well as below because we have to distinguish the one item from from the array:

 collection.add(item);
 collection.insert(index, item);

Available since: 5.0.0

Parameters

args :  Arguments

The arguments object from the caller.

index :  Number

The index in args (the caller's arguments) of items.

Returns

:Object[]

The array of items on which to operate.

decodeRemoveItems
protected pro

This method is an alias for decodeItems but is called when items are being removed. If a decoder is provided it may be necessary to also override this method to achieve symmetry between adding and removing items. This is the case for Ext.util.FilterCollection' andExt.util.SorterCollection' for example.

Available since: 5.0.0

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

doFireEvent ( eventName, args, bubbles )
private pri

Continue to fire event.

Parameters

eventName :  String

args :  Array

bubbles :  Boolean

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.

filterBy ( fn, [scope] ) : Ext.util.Collection

Filter by a function. Returns a new collection that has been filtered. The passed function will be called with each object in the collection. If the function returns true, the value is included otherwise it is filtered.

Available since: 5.0.0

Parameters

fn :  Function

The function to be called.

item :  Mixed

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.

Returns

:Ext.util.Collection

The new filtered collection

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

fireAction ( eventName, args, fn, [scope], [options], [order] )
deprecated dep

Fires the specified event with the passed parameters and executes a function (action). By default, the action function will be executed after any "before" event handlers (as specified using the order option of addListener), but before any other handlers are fired. This gives the "before" handlers an opportunity to cancel the event by returning false, and prevent the action function from being called.

The action can also be configured to run after normal handlers, but before any "after" handlers (as specified using the order event option) by passing 'after' as the order parameter. This configuration gives any event handlers except for "after" handlers the opportunity to cancel the event and prevent the action function from being called.

Parameters

eventName :  String

The name of the event to fire.

args :  Array

Arguments to pass to handlers and to the action function.

fn :  Function

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.

options :  Object (optional)

Event options for the action function. Accepts any of the options of addListener

order :  String (optional)

The order to call the action function relative too the event handlers ('before' or 'after'). Note that this option is simply used to sort the action function relative to the event handlers by "priority". An order of 'before' is equivalent to a priority of 99.5, while an order of 'after' is equivalent to a priority of -99.5. See the priority option of addListener for more details.

Defaults to: 'before'

Deprecated since version 5.5
Use fireEventedAction instead.

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] ) : Boolean

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.

Returns

:Boolean

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.

getBubbleParent Ext.util.Observable
private pri

Gets the bubbling parent for an Observable

Returns

:Ext.util.Observable

The bubble parent. null is returned if no bubble target exists

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.

getConfig ( [name], [peek] ) : Object

Returns a specified config property value. If the name parameter is not passed, all current configuration options will be returned as key value pairs.

Parameters

name :  String (optional)

The name of the config property to get.

peek :  Boolean (optional)

true to peek at the raw value without calling the getter.

Defaults to: false

Returns

:Object

The config property value.

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.

getId String

Retrieves the id of this component. Will autogenerate an id if one has not already been set.

Returns

:String

id

getIndices Object
private pri

Returns the map of key to index for all items in this collection. This method will lazily populate this map on request. This map is maintained when doing so does not involve too much overhead. When this threshold is cross, the index map is discarded and must be rebuilt by calling this method.

Available since: 5.0.0

Returns

:Object

getInitialConfig ( [name] ) : Object/Mixed

Returns the initial configuration passed to the constructor when instantiating this class.

Given this example Ext.button.Button definition and instance:

Ext.define('MyApp.view.Button', {
    extend: 'Ext.button.Button',
    xtype: 'mybutton',

    scale: 'large',
    enableToggle: true
});

var btn = Ext.create({
    xtype: 'mybutton',
    renderTo: Ext.getBody(),
    text: 'Test Button'
});

Calling btn.getInitialConfig() would return an object including the config options passed to the create method:

xtype: 'mybutton',
renderTo: // The document body itself
text: 'Test Button'

Calling btn.getInitialConfig('text')returns 'Test Button'.

Parameters

name :  String (optional)

Name of the config option to return.

Returns

:Object/Mixed

The full config object or a single config value when name parameter specified.

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.

hasConfig ( name )
private pri

Parameters

name :  String

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.

initConfig ( instanceConfig ) : Ext.Base
chainable ch protected pro

Initialize configuration for this class. a typical example:

Ext.define('My.awesome.Class', {
    // The default config
    config: {
        name: 'Awesome',
        isAwesome: true
    },

    constructor: function(config) {
        this.initConfig(config);
    }
});

var awesome = new My.awesome.Class({
    name: 'Super Awesome'
});

alert(awesome.getName()); // 'Super Awesome'

Parameters

instanceConfig :  Object

Returns

:Ext.Base

this

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.

notify ( eventName, [args] )
private pri

This method wraps all fired events and gives observers first view of the change.

Available since: 5.0.0

Parameters

eventName :  String

The name of the event to fire.

args :  Array (optional)

The event arguments. This collection instance is inserted at the front of this array if there is any receiver for the notification.

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 set of arguments to pass to the handler function before the actual fired event arguments. For example, if args is set to ['foo', 42], the event handler function will be called with an arguments list like this:

 handler('foo', 42, <actual event 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.

onCollectionAdd ( source, details )
private pri

This method is called when items are added to the source collection. This is equivalent to the add event but is called before the add event is fired.

Available since: 5.0.0

Parameters

source :  Ext.util.Collection

The source collection.

details :  Object

The details of the add event.

onCollectionBeforeItemChange ( source, details )
private pri

This method is called when an item is modified in the source collection. This is equivalent to the beforeitemchange event but is called before the beforeitemchange event is fired.

Available since: 5.0.0

Parameters

source :  Ext.util.Collection

The source collection.

details :  Object

The details of the beforeitemchange event.

onCollectionBeginUpdate ( source )
private pri

This method is called when the source collection starts updating. This is equivalent to the beginupdate event but is called before the beginupdate event is fired.

Available since: 5.0.0

Parameters

source :  Ext.util.Collection

The source collection.

onCollectionEndUpdate ( source )
private pri

This method is called when the source collection finishes updating. This is equivalent to the endupdate event but is called before the endupdate event is fired.

Available since: 5.0.0

Parameters

source :  Ext.util.Collection

The source collection.

onCollectionItemChange ( source, details )
private pri

This method is called when an item is modified in the source collection. This is equivalent to the itemchange event but is called before the itemchange event is fired.

Available since: 5.0.0

Parameters

source :  Ext.util.Collection

The source collection.

details :  Object

The details of the itemchange event.

onCollectionRefresh ( source )
private pri

This method is called when the source collection refreshes. This is equivalent to the refresh event but is called before the refresh event is fired.

Available since: 5.0.0

Parameters

source :  Ext.util.Collection

The source collection.

onCollectionRemove ( source, details )
private pri

This method is called when items are removed from the source collection. This is equivalent to the remove event but is called before the remove event is fired.

Available since: 5.0.0

Parameters

source :  Ext.util.Collection

The source collection.

details :  Object

The details of the remove event.

onCollectionSort ( source )
private pri

This method is called when the source collection is sorted. This is equivalent to the sort event but is called before the sort event is fired.

Available since: 5.0.0

Parameters

source :  Ext.util.Collection

The source collection.

onCollectionUpdateKey ( source, details )
private pri

This method is called when key changes in the source collection. This is equivalent to the updatekey event but is called before the updatekey event is fired.

Available since: 5.0.0

Parameters

source :  Ext.util.Collection

The source collection.

details :  Object

The details of the updatekey event.

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
chainable ch

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] ) :
chainable ch

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'
});

Returns

:

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.

removeManagedListenerItem ( isClear, managedListener )
private pri

Remove a single managed listener item

Parameters

isClear :  Boolean

True if this is being called during a clear

managedListener :  Object

The managed listener item See removeManagedListener for other args

removeObserver ( observer )
private pri

Removes an observing object to this collection. See addObserver for details.

Available since: 5.0.0

Parameters

observer :  Ext.util.Collection

The observer instance.

replace ( item ) : Object
private pri

Replace an old entry with a new entry of the same key if the entry existed.

Parameters

item :  Object

The item to insert.

Returns

:Object

inserted The item inserted.

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.

resolveListenerScope ( [defaultScope] ) : Object
protected pro

Gets the default scope for firing late bound events (string names with no scope attached) at runtime.

Parameters

defaultScope :  Object (optional)

The default scope to return if none is found.

Defaults to: this

Returns

:Object

The default event scope

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.

setConfig ( name, [value] ) : Ext.Base
chainable ch

Sets a single/multiple configuration options.

Parameters

name :  String/Object

The name of the property to set, or a set of key value pairs to set.

value :  Object (optional)

The value to set for the name parameter.

Returns

:Ext.Base

this

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

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.

sortBy ( sorterFn )

Sorts the collection by a single sorter function

Parameters

sorterFn :  Function

The function to sort by

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] ) :
chainable ch

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.

Returns

:

spliceMerge ( newItems )
private pri

This method is what you might find in the core of a merge sort. We have an items array that is sorted so we sort the newItems and merge the two sorted arrays. In the general case, newItems will be no larger than all items so sorting it will be faster than simply concatenating the arrays and calling sort on it.

We take advantage of the nature of this process to generate add events as ranges.

Available since: 5.0.0

Parameters

newItems :  Object[]

statics Ext.Class
protected pro

Get the reference to the class from which this object was instantiated. Note that unlike Ext.Base#self, this.statics() is scope-independent and it always returns the class from which it was called, regardless of what this points to during run-time

Ext.define('My.Cat', {
    statics: {
        totalCreated: 0,
        speciesName: 'Cat' // My.Cat.speciesName = 'Cat'
    },

    constructor: function() {
        var statics = this.statics();

        alert(statics.speciesName);     // always equals to 'Cat' no matter what 'this' refers to
                                        // equivalent to: My.Cat.speciesName

        alert(this.self.speciesName);   // dependent on 'this'

        statics.totalCreated++;
    },

    clone: function() {
        var cloned = new this.self();   // dependent on 'this'

        cloned.groupName = this.statics().speciesName;   // equivalent to: My.Cat.speciesName

        return cloned;
    }
});


Ext.define('My.SnowLeopard', {
    extend: 'My.Cat',

    statics: {
        speciesName: 'Snow Leopard'     // My.SnowLeopard.speciesName = 'Snow Leopard'
    },

    constructor: function() {
        this.callParent();
    }
});

var cat = new My.Cat();                 // alerts 'Cat', then alerts 'Cat'

var snowLeopard = new My.SnowLeopard(); // alerts 'Cat', then alerts 'Snow Leopard'

var clone = snowLeopard.clone();
alert(Ext.getClassName(clone));         // alerts 'My.SnowLeopard'
alert(clone.groupName);                 // alerts 'Cat'

alert(My.Cat.totalCreated);             // alerts 3

Returns

:Ext.Class

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'
});

Returns

:

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

addConfig ( config, [mixinClass] )
static sta private pri

Adds new config properties to this class. This is called for classes when they are declared, then for any mixins that class may define and finally for any overrides defined that target the class.

Parameters

config :  Object

mixinClass :  Ext.Class (optional)

The mixin class if the configs are from a mixin.

addInheritableStatics ( members ) :
chainable ch static sta private pri

Parameters

members :  Object

Returns

:

addMember ( name, member ) :
chainable ch static sta private pri

Parameters

name :  Object

member :  Object

Returns

:

addMembers ( members, [isStatic], [privacy] ) :
chainable ch static sta

Add methods / properties to the prototype of this class.

Ext.define('My.awesome.Cat', {
    constructor: function() {
        ...
    }
});

 My.awesome.Cat.addMembers({
     meow: function() {
        alert('Meowww...');
     }
 });

 var kitty = new My.awesome.Cat();
 kitty.meow();

Parameters

members :  Object

The members to add to this class.

isStatic :  Boolean (optional)

Pass true if the members are static.

Defaults to: false

privacy :  Boolean (optional)

Pass true if the members are private. This only has meaning in debug mode and only for methods.

Defaults to: false

Returns

:

addStatics ( members ) : Ext.Base
chainable ch static sta

Add / override static properties of this class.

Ext.define('My.cool.Class', {
    ...
});

My.cool.Class.addStatics({
    someProperty: 'someValue',      // My.cool.Class.someProperty = 'someValue'
    method1: function() { ... },    // My.cool.Class.method1 = function() { ... };
    method2: function() { ... }     // My.cool.Class.method2 = function() { ... };
});

Parameters

members :  Object

Returns

:Ext.Base

this

borrow ( fromClass, members ) : Ext.Base
static sta private pri

Borrow another class' members to the prototype of this class.

Ext.define('Bank', {
    money: '$$$',
    printMoney: function() {
        alert('$$$$$$$');
    }
});

Ext.define('Thief', {
    ...
});

Thief.borrow(Bank, ['money', 'printMoney']);

var steve = new Thief();

alert(steve.money); // alerts '$$$'
steve.printMoney(); // alerts '$$$$$$$'

Parameters

fromClass :  Ext.Base

The class to borrow members from

members :  Array/String

The names of the members to borrow

Returns

:Ext.Base

this

callParent ( args )
static sta protected pro

Parameters

args :  Object

callSuper ( args )
static sta protected pro

Parameters

args :  Object

create Object
static sta

Create a new instance of this Class.

Ext.define('My.cool.Class', {
    ...
});

My.cool.Class.create({
    someConfig: true
});

All parameters are passed to the constructor of the class.

Returns

:Object

the created instance.

createAlias ( alias, origin )
static sta

Create aliases for existing prototype methods. Example:

Ext.define('My.cool.Class', {
    method1: function() { ... },
    method2: function() { ... }
});

var test = new My.cool.Class();

My.cool.Class.createAlias({
    method3: 'method1',
    method4: 'method2'
});

test.method3(); // test.method1()

My.cool.Class.createAlias('method5', 'method3');

test.method5(); // test.method3() -> test.method1()

Parameters

alias :  String/Object

The new method name, or an object to set multiple aliases. See flexSetter

origin :  String/Object

The original method name

extend ( parentClass )
static sta private pri

Parameters

parentClass :  Object

getConfigurator Ext.Configurator
static sta private pri

Returns the Ext.Configurator for this class.

Returns

:Ext.Configurator

getName String
static sta

Get the current class' name in string format.

Ext.define('My.cool.Class', {
    constructor: function() {
        alert(this.self.getName()); // alerts 'My.cool.Class'
    }
});

My.cool.Class.getName(); // 'My.cool.Class'

Returns

:String

className

mixin ( name, mixinClass ) :
chainable ch static sta private pri

Used internally by the mixins pre-processor

Parameters

name :  Object

mixinClass :  Object

Returns

:

onExtended ( fn, scope ) :
chainable ch static sta private pri

Parameters

fn :  Object

scope :  Object

Returns

:

override ( members ) : Ext.Base
chainable ch 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

triggerExtended
static sta private pri

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.

beforesort ( collection, sorters, eOpts )
private pri

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

Parameters

collection :  Ext.util.Collection

The collection being sorted.

sorters :  Ext.util.Sorter[]

Array of sorters applied to 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.

Ext JS 6.2.2 - Modern Toolkit