Ext JS Sencha Docs

Ext.data.Store

Hierarchy

Mixins

Inherited mixins

Requires

Subclasses

Uses

Files

The Store class encapsulates a client side cache of Model objects. Stores load data via a Proxy, and also provide functions for sorting, filtering and querying the model instances contained within it.

Creating a Store is easy - we just tell it the Model and the Proxy to use for loading and saving its data:

 // Set up a model to use in our Store
 Ext.define('User', {
     extend: 'Ext.data.Model',
     fields: [
         {name: 'firstName', type: 'string'},
         {name: 'lastName',  type: 'string'},
         {name: 'age',       type: 'int'},
         {name: 'eyeColor',  type: 'string'}
     ]
 });

 var myStore = Ext.create('Ext.data.Store', {
     model: 'User',
     proxy: {
         type: 'ajax',
         url: '/users.json',
         reader: {
             type: 'json',
             rootProperty: 'users'
         }
     },
     autoLoad: true
 });

In the example above we configured an AJAX proxy to load data from the url '/users.json'. We told our Proxy to use a JsonReader to parse the response from the server into Model object - see the docs on JsonReader for details.

Inline data

Stores can also load data inline. Internally, Store converts each of the objects we pass in as data into Model instances:

 Ext.create('Ext.data.Store', {
     model: 'User',
     data : [
         {firstName: 'Ed',    lastName: 'Spencer'},
         {firstName: 'Tommy', lastName: 'Maintz'},
         {firstName: 'Aaron', lastName: 'Conran'},
         {firstName: 'Jamie', lastName: 'Avins'}
     ]
 });

Loading inline data using the method above is great if the data is in the correct format already (e.g. it doesn't need to be processed by a reader). If your inline data requires processing to decode the data structure, use a MemoryProxy instead (see the MemoryProxy docs for an example).

Additional data can also be loaded locally using add.

Dynamic Loading

Stores can be dynamically updated by calling the load method:

store.load({
    params: {
        group: 3,
        type: 'user'
    },
    callback: function(records, operation, success) {
        // do something after the load finishes
    },
    scope: this
});

Here a bunch of arbitrary parameters is passed along with the load request and a callback function is set up to do something after the loading is over.

Loading Nested Data

Applications often need to load sets of associated data - for example a CRM system might load a User and her Orders. Instead of issuing an AJAX request for the User and a series of additional AJAX requests for each Order, we can load a nested dataset and allow the Reader to automatically populate the associated models. Below is a brief example, see the Ext.data.reader.Reader intro docs for a full explanation:

 var store = Ext.create('Ext.data.Store', {
     autoLoad: true,
     model: "User",
     proxy: {
         type: 'ajax',
         url: 'users.json',
         reader: {
             type: 'json',
             rootProperty: 'users'
         }
     }
 });

Which would consume a response like this:

 {
     "users": [{
         "id": 1,
         "name": "Ed",
         "orders": [{
             "id": 10,
             "total": 10.76,
             "status": "invoiced"
        },{
             "id": 11,
             "total": 13.45,
             "status": "shipped"
        }]
     }]
 }

See the Ext.data.reader.Reader intro docs for a full explanation.

Filtering and Sorting

Stores can be sorted and filtered - in both cases either remotely or locally. The sorters and filters are held inside MixedCollection instances to make them easy to manage. Usually it is sufficient to either just specify sorters and filters in the Store configuration or call sort or filter:

 var store = Ext.create('Ext.data.Store', {
     model: 'User',
     sorters: [{
         property: 'age',
         direction: 'DESC'
     }, {
         property: 'firstName',
         direction: 'ASC'
     }],

     filters: [{
         property: 'firstName',
         value: /Ed/
     }]
 });

The new Store will keep the configured sorters and filters in the MixedCollection instances mentioned above. By default, sorting and filtering are both performed locally by the Store - see remoteSort and remoteFilter to allow the server to perform these operations instead.

Filtering and sorting after the Store has been instantiated is also easy. Calling filter adds another filter to the Store and automatically filters the dataset (calling filter with no arguments simply re-applies all existing filters).

store.filter('eyeColor', 'Brown');

Change the sorting at any time by calling sort:

store.sort('height', 'ASC');

Note that all existing sorters will be removed in favor of the new sorter data (if sort is called with no arguments, the existing sorters are just reapplied instead of being removed). To keep existing sorters and add new ones, just add them to the MixedCollection:

store.sorters.add(new Ext.util.Sorter({
    property : 'shoeSize',
    direction: 'ASC'
}));

store.sort();

Registering with StoreManager

Any Store that is instantiated with a storeId will automatically be registered with the StoreManager. This makes it easy to reuse the same store in multiple views:

//this store can be used several times
Ext.create('Ext.data.Store', {
    model: 'User',
    storeId: 'usersStore'
});

new Ext.List({
    store: 'usersStore',
    //other config goes here
});

new Ext.view.View({
    store: 'usersStore',
    //other config goes here
});

Further Reading

Stores are backed up by an ecosystem of classes that enables their operation. To gain a full understanding of these pieces and how they fit together, see:

  • Proxy - overview of what Proxies are and how they are used
  • Model - the core class in the data package
  • Reader - used by any subclass of ServerProxy to read a response
Defined By

Config options

The owner of this store if the store is used as part of an association.

The owner of this store if the store is used as part of an association.

When a Store is used by only one DataView, and should only exist for the lifetime of that view, then configure the au...

When a Store is used by only one DataView, and should only exist for the lifetime of that view, then configure the autoDestroy flag as true. This causes the destruction of the view to trigger the destruction of its Store.

If data is not specified, and if autoLoad is true or an Object, this store's load method is automatically called afte...

If data is not specified, and if autoLoad is true or an Object, this store's load method is automatically called after creation. If the value of autoLoad is an Object, this Object will be passed to the store's load method.

Available since: 2.3.0

True to automatically sync the Store with its Proxy after every edit to one of its Records. ...

True to automatically sync the Store with its Proxy after every edit to one of its Records. Defaults to false.

Defaults to: false

Sets the updating behavior based on batch synchronization. ...

Sets the updating behavior based on batch synchronization. 'operation' (the default) will update the Store's internal representation of the data after each operation of the batch has completed, 'complete' will wait until the entire batch has been completed before updating the Store's data. 'complete' is a good choice for local storage proxies, 'operation' is better for remote proxies, where there is a comparatively high latency.

Defaults to: 'operation'

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

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

True to empty the store when loading another page via loadPage, nextPage or previousPage. ...

True to empty the store when loading another page via loadPage, nextPage or previousPage. Setting to false keeps existing records, allowing large data sets to be loaded one page at a time but rendered all together.

Defaults to: true

true to clear anything in the removed record collection when the store loads. ...

true to clear anything in the removed record collection when the store loads.

Defaults to: true

Array of Model instances or data objects to load locally. ...

Array of Model instances or data objects to load locally. See "Inline data" above for details.

Defaults to: 0

This may be used in place of specifying a model configuration. ...

This may be used in place of specifying a model configuration. The fields should be a set of Ext.data.Field configuration objects. The store will automatically create a Ext.data.Model with these fields. In general this configuration option should only be used for simple stores like a two-field store of ComboBox. For anything more complicated, such as specifying a particular id property or associations, a Ext.data.Model should be defined and specified for the model config.

Available since: 2.3.0

Array of Filters for this store. ...

Array of Filters for this store. Can also be passed array of functions which will be used as the filterFn config for filters:

filters: [
    function(item) {
        return item.weight > 0;
    }
]

To filter after the grid is loaded use the filterBy function.

The direction in which sorting should be applied when grouping. ...

The direction in which sorting should be applied when grouping. Supported values are "ASC" and "DESC".

Defaults to: 'ASC'

The field by which to group data in the store. ...

The field by which to group data in the store. Internally, grouping is very similar to sorting - the groupField and groupDir are injected as the first sorter (see sort). Stores support a single level of grouping, and groups can be fetched via the getGroups method.

The grouper by which to group the data store. ...

The grouper by which to group the data store. May also be specified by the groupField config, however they should not be used together.

A config object containing one or more event handlers to be added to this object during initialization. ...

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.

See the Event guide for more

Note: It is bad practice to specify a listener's config when you are defining a class using Ext.define(). Instead, only specify listeners when you are instantiating your class with Ext.create().

Name of the Model associated with this store. ...

Name of the Model associated with this store. See Ext.data.Model.entityName.

May also be the actual Model subclass.

This config is required for the store to be able to read data unless you have defined the fields config which will create an anonymous Ext.data.Model.

The number of records considered to form a 'page'. ...

The number of records considered to form a 'page'. This is used to power the built-in paging using the nextPage and previousPage functions when the grid is paged using a PagingToolbar Defaults to 25.

To disable paging, set the pageSize to 0.

Defaults to: 25

The Proxy to use for this Store. ...

The Proxy to use for this Store. This can be either a string, a config object or a Proxy instance - see setProxy for details.

Available since: 1.1.0

true to defer any filtering operation to the server. ...

true to defer any filtering operation to the server. If false, filtering is done locally on the client.

Defaults to: false

true if the sorting should be performed on the server side, false if it is local only. ...

true if the sorting should be performed on the server side, false if it is local only.

Defaults to: false

Ext.data.Store
view source
: Ext.data.schema.Roleprivate

The role for the associatedEntity.

The role for the associatedEntity.

The session for this store. ...

The session for this store. By specifying a session, it ensures any records that are added to this store are also included in the session. This store does not become a member of the session itself.

Available since: 5.0.0

If true, any sorters attached to this Store will be run after loading data, before the datachanged event is fired. ...

If true, any sorters attached to this Store will be run after loading data, before the datachanged event is fired. Defaults to true, ignored if remoteSort is true

Defaults to: true

Configure as true to have the filters saved when a client grid saves its state. ...

Configure as true to have the filters saved when a client grid saves its state.

Defaults to: false

Unique identifier for this store. ...

Unique identifier for this store. If present, this Store will be registered with the Ext.data.StoreManager, making it easy to reuse elsewhere.

Note that when store is instatiated by Controller, the storeId will be overridden by the name of the store.

This config controls whether removed records are remembered by this store for later saving to the server. ...

This config controls whether removed records are remembered by this store for later saving to the server.

Defaults to: true

Properties

Defined By

Instance properties

...

Defaults to: 'Ext.Base'

The value true causes config values to be stored on instances using a property name prefixed with an underscore ("_")...

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: false

Available since: 5.0.0

Overrides: Ext.Component.$configPrefixed, Ext.layout.Layout.$configPrefixed, Ext.data.AbstractStore.$configPrefixed, Ext.layout.container.boxOverflow.None.$configPrefixed

The value true instructs the initConfig method to only honor values for properties declared in the config block of a ...

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

Overrides: Ext.Component.$configStrict, Ext.layout.Layout.$configStrict, Ext.data.AbstractStore.$configStrict, Ext.layout.container.boxOverflow.None.$configStrict

Ext.data.Store
view source
: Objectprivate
Private. ...

Private. Used as parameter to loadRecords

Defaults to: {addRecords: true}

A counter to track suspensions. ...

A counter to track suspensions.

Defaults to: 0

Ext.data.Store
view source
: Booleanprivate
true once the store has loaded data from the server. ...

true once the store has loaded data from the server.

Defaults to: false

The page that the Store has most recently loaded (see loadPage) ...

The page that the Store has most recently loaded (see loadPage)

Defaults to: 1

Ext.data.Store
view source
: Ext.util.Collectionprivatereadonly

The data property is a Collection which holds this store's local cache of records.

The data property is a Collection which holds this store's local cache of records.

If this property is specified by the target class of this mixin its properties are used to configure the created Ext....

If this property is specified by the target class of this mixin its properties are used to configure the created Ext.Factory.

Defaults to: {defaultType: 'store', type: 'store'}

Overrides: Ext.mixin.Factoryable.factoryConfig

This object holds a key for any event that has a listener. ...

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 or on the MVC 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);
 }
...

Defaults to: /\.|[^\w\-]/g

True if a model was created implicitly for this Store. ...

True if a model was created implicitly for this Store. This happens if a fields array is passed to the Store's constructor instead of a model constructor or name.

Defaults to: false

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

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

Defaults to: false

Available since: 5.0.0

True if the Store has already been destroyed. ...

True if the Store has already been destroyed. If this is true, the reference to Store should be deleted as it will not function correctly any more.

Defaults to: false

Available since: 3.4.0

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

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

Defaults to: false

Available since: 5.0.0

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

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

Defaults to: true

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

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

Defaults to: true

Property to hold the last options from a load method call. ...

Property to hold the last options from a load method call. This object is used for the reload to reuse the same options. Please see reload for a simple example on how to use the lastOptions property.

...

Defaults to: /^(?:scope|order|delegate|single|delay|buffer|args|prepend|destroyable)$/

Ext.data.Store
view source
: Numberreadonly
The number of times records have been loaded into the store. ...

The number of times records have been loaded into the store. This includes loads via loadData & loadRecords.

Defaults to: 0

true if the Store is currently loading via its Proxy. ...

true if the Store is currently loading via its Proxy.

Defaults to: false

...

Defaults to: {id: 'localstore'}

Overrides: Ext.mixin.Observable.mixinConfig

...

Defaults to: 'factoryable'

Overrides: Ext.mixin.Identifiable.mixinId

...

Defaults to: 'observable'

Temporary cache in which removed model instances are kept until successfully synchronised with a Proxy, at which poin...

Temporary cache in which removed model instances are kept until successfully synchronised with a Proxy, at which point this is cleared.

This cache is maintained unless you set trackRemoved to false.

Defaults to: []

Get the reference to the current class from which this object was instantiated. ...

Get the reference to the current class from which this object was instantiated. Unlike statics, this.self is scope-dependent and it's meant to be used for dynamic inheritance. See 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'
A counter that is increased by beginUpdate and decreased by endUpdate. ...

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

Defined By

Static properties

...

Defaults to: []

Methods

Defined By

Instance methods

Ext.data.Store
view source
new( [config] ) : Ext.data.Store
Creates the store. ...

Creates the store.

Parameters

  • config : Object (optional)

    Config object.

Returns

Fires

Overrides: Ext.data.ProxyStore.constructor, Ext.data.Store.constructor

Ext.data.Store
view source
( model ) : Ext.data.Model[]
Adds Model instance to the Store. ...

Adds Model instance to the Store. This method accepts either:

  • An array of Model instances or Model configuration objects.
  • Any number of Model instance or Model configuration object arguments.

The new Model instances will be added at the end of the existing collection.

Sample usage:

myStore.add({some: 'data'}, {some: 'other data'});

Note that if this Store is sorted, the new Model instances will be inserted at the correct point in the Store to maintain the sort order.

Parameters

Returns

Fires

    ( eventName, fn, [scope], [options] )
    Appends an after-event handler. ...

    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.

    Fires

      ( eventName, fn, [scope], [options] )
      Appends a before-event handler. ...

      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.

      Fires

        ( deprecations )private
        This method applies a versioned, deprecation declaration to this class. ...

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

        Parameters

        ( selector, name, fn, scope, options, order )private
        ...

        Parameters

        Fires

          Adds the specified events to the list of events which this Observable may fire. ...

          Adds the specified events to the list of events which this Observable may fire.

          This method has been deprecated since 2.0

          It's no longer needed to add events before firing.

          Parameters

          • eventNames : Object/String...

            Either an object with event names as properties with a value of true or the first event name string if multiple event names are being passed as separate parameters.

          ...

          Parameters

          Fires

            Adds a new Filter to this Store's filter set and by default, applys the updated filter set to the Store's unfiltered ...

            Adds a new Filter to this Store's filter set and by default, applys the updated filter set to the Store's unfiltered dataset.

            Parameters

            Fires

              ( eventName, fn, [scope], [options], [order] )
              Appends an event handler to this object. ...

              Appends an event handler to this object. You can review the available handlers by looking at the 'events' section of the documentation for the component you are working with.

              Combining Options

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

              A delayed, one-time listener:

              container.addListener('tap', this.handleTap, 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 events. For example:

              container.addListener({
                  tap  : this.onTap,
                  swipe: this.onSwipe,
              
                  scope: this // Important. Ensure "this" is correct during handler execution
              });
              

              One can also specify options for each event handler separately:

              container.addListener({
                  tap  : { fn: this.onTap, scope: this, single: true },
                  swipe: { fn: button.onSwipe, scope: button }
              });
              

              See the Events Guide for more.

              Parameters

              • eventName : String/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

                The method the event invokes. Will be called with arguments given to 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.

                This object may contain any of the following properties:

                • scope : Object (optional)

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

                • delay : Number (optional)

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

                • single : Boolean (optional)

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

                • order : String (optional)

                  The order of when the listener should be added into the listener queue.

                  If you set an order of before and the event you are listening to is preventable, you can return false and it will stop the event.

                  Available options are before, current and after.

                  Defaults to: current

                • buffer : Number (optional)

                  Causes the handler to be 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.

                • element : String (optional)

                  If this observable is a Component, allows you to add a listener onto a element of the component using the element's reference.

                  Ext.create('Ext.Component', {
                      listeners: {
                          element: 'element',
                          tap: function() {
                              alert('element tap!');
                          }
                      }
                  });
                  

                  In Sencha Touch, All components have the element reference, which is the outer most element of the component. Ext.Container also has the innerElement element which contains all children. In most cases element is adequate.

                • delegate : String (optional)

                  For Elements, a simple DOM selector to filter the target or look for a descendant of the target.

                  Sencha Touch Components can use Ext.ComponentQuery selectors to filter child Components.

                  // Create a container with a two children; a button and a toolbar
                  var container = Ext.create('Ext.Container', {
                      items: [
                          {
                              xtype: 'toolbar',
                              docked: 'top',
                              title: 'My Toolbar'
                          },
                          {
                             xtype: 'button',
                             text: 'My Button'
                          }
                      ]
                  });
                  
                  container.addListener({
                      // Ext.Buttons have an xtype of 'button', so we use that are a selector for our delegate
                      delegate: 'button',
                  
                      tap: function() {
                          alert('Button tapped!');
                      }
                  });
                  
                • capture : Boolean

                  true to initiate capture which will fire the listeners on the target Element before any descendant Elements. Normal events start with the target element and propagate upward to ancestor elements, whereas captured events propagate from the top of the DOM downward to descendant elements. This option achieves the same result as the useCapture parameter in the standard JavaScript addEventListener method.

              • order : String (optional)

                The order of when the listener should be added into the listener queue. Possible values are before, current and after.

                Defaults to: 'current'

              Fires

                ( object, eventName, [fn], [scope], [options] )deprecated
                Adds listeners to any Observable object (or Element) which are automatically removed when this Component is destroyed. ...

                Adds listeners to any Observable object (or Element) which are automatically removed when this Component is destroyed.

                This method has been deprecated since 2.0

                All listeners are now automatically managed where necessary. Simply use addListener.

                Parameters

                • object : Ext.mixin.Observable/HTMLElement

                  The item to which to add a listener/listeners.

                • eventName : Object/String

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

                • fn : Function (optional)

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

                • scope : Object (optional)

                  If the eventName parameter was an event name, this is the scope in which the handler function is executed.

                • options : Object (optional)

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

                ...

                Parameters

                Ext.data.Store
                view source
                ( record )
                (Local sort only) Inserts the passed Record into the Store at the index where it should go based on the current sort ...

                (Local sort only) Inserts the passed Record into the Store at the index where it should go based on the current sort information.

                Parameters

                Fires

                  ...

                  Parameters

                  Ext.data.Store
                  view source
                  ( record )private
                  A model instance should call this method on the Store it has been joined to. ...

                  A model instance should call this method on the Store it has been joined to.

                  Parameters

                  Fires

                    Overrides: Ext.data.ProxyStore.afterCommit

                    Ext.data.Store
                    view source
                    ( record )private
                    ...

                    Parameters

                    Fires

                      Ext.data.Store
                      view source
                      ( record, modifiedFieldNames )private
                      ...

                      Parameters

                      Fires

                        ...

                        Parameters

                        Fires

                          Ext.data.Store
                          view source
                          ( record )private
                          A model instance should call this method on the Store it has been joined to.. ...

                          A model instance should call this method on the Store it has been joined to..

                          Parameters

                          Fires

                            Overrides: Ext.data.ProxyStore.afterReject

                            Ext.data.Store
                            view source
                            ( fn, [scope], [grouped], field ) : Object
                            Runs the aggregate function for all the records in the store. ...

                            Runs the aggregate function for all the records in the store.

                            When store is filtered, only items within the filter are aggregated.

                            Parameters

                            • fn : Function

                              The function to execute. The function is called with a single parameter, an array of records for that group.

                            • scope : Object (optional)

                              The scope to execute the function in. Defaults to the store.

                            • grouped : Boolean (optional)

                              True to perform the operation for each group in the store. The value returned will be an object literal with the key being the group name and the group average being the value. The grouped parameter is only honored if the store has a groupField.

                            • field : String

                              The field to get the value from

                            Returns

                            • Object

                              An object literal with the group names and their appropriate values.

                            Overrides: Ext.data.LocalStore.aggregate

                            ...

                            Parameters

                            Fires

                              Ext.data.Store
                              view source
                              ( data, dataCollection )private
                              ...

                              Parameters

                              Fires

                              ...

                              Parameters

                              Fires

                                ( filters, filtersCollection )private
                                ...

                                Parameters

                                Fires

                                  ...

                                  Parameters

                                  Fires

                                  ...

                                  Parameters

                                  Fires

                                    ...

                                    Parameters

                                    Fires

                                      ...

                                      Parameters

                                      Fires

                                        ( sorters, sortersCollection )private
                                        ...

                                        Parameters

                                        Fires

                                          Restores state to the passed state ...

                                          Restores state to the passed state

                                          Parameters

                                          Fires

                                            ...

                                            Parameters

                                            Fires

                                            Ext.data.Store
                                            view source
                                            ( field, [grouped] ) : Object
                                            Gets the average value in the store. ...

                                            Gets the average value in the store.

                                            When store is filtered, only items within the filter are aggregated.

                                            Parameters

                                            • field : String

                                              The field in each record

                                            • grouped : Boolean (optional)

                                              True to perform the operation for each group in the store. The value returned will be an object literal with the key being the group name and the group average being the value. The grouped parameter is only honored if the store has a groupField.

                                            Returns

                                            • Object

                                              The average value, if no items exist, 0.

                                            Overrides: Ext.data.LocalStore.average

                                            This method may be called to indicate the start of multiple changes to the store. ...

                                            This method may be called to indicate the start of multiple changes to the store.

                                            Automatic synchronization as configured by the autoSync flag is deferred until the endUpdate method is called, so multiple mutations can be coalesced into one synchronization operation.

                                            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 store = Ext.StoreManager.lookup({
                                                 //...
                                                 autoSync: true
                                             });
                                            
                                             store.beginUpdate();
                                            
                                             record.set('fieldName', 'newValue');
                                            
                                             store.add(item);
                                             // ...
                                            
                                             store.insert(index, otherItem);
                                             //...
                                            
                                             // Interested parties will listen for the endupdate event
                                             store.endUpdate();
                                            

                                            Available since: 5.0.0

                                            Fires

                                            ...

                                            Parameters

                                            ...

                                            Parameters

                                            ( args ) : Objectdeprecatedprotected
                                            Call the original method that was previously overridden with override Ext.define('My.Cat', { constructor: functi...

                                            Call the original method that was previously overridden with 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"
                                            

                                            This method has been deprecated

                                            Use callParent instead.

                                            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

                                            Call the "parent" method of the current method. ...

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

                                             Ext.define('My.Derived2', {
                                                 extend: 'My.Base',
                                            
                                                 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',
                                            
                                                 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 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

                                            This method is used by an override to call the superclass method but bypass any overridden method. ...

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

                                            ( actionFn, eventName, fn, scope, options, order )private
                                            ...

                                            Parameters

                                            Ext.data.Store
                                            view source
                                            ( isLoad, data )private
                                            private ...

                                            private

                                            Parameters

                                            Fires

                                              Overrides: Ext.data.ProxyStore.clearData

                                              Reverts to a view of the Record cache with no filtering applied. ...

                                              Reverts to a view of the Record cache with no filtering applied.

                                              Parameters

                                              • suppressEvent : Boolean (optional)

                                                If true the filter is cleared silently.

                                                For a locally filtered Store, this means that the filter collection is cleared without firing the datachanged event.

                                                For a remotely filtered Store, this means that the filter collection is cleared, but the store is not reloaded from the server.

                                              Fires

                                                Clear the store grouping ...

                                                Clear the store grouping

                                                Fires

                                                Removes all listeners for this object. ...

                                                Removes all listeners for this object.

                                                Fires

                                                  ...

                                                  Parameters

                                                  Fires

                                                    Ext.data.Store
                                                    view source
                                                    ( dataIndex, [allowNull], [bypassFilter] ) : Object[]
                                                    Collects unique values for a particular dataIndex from this store. ...

                                                    Collects unique values for a particular dataIndex from this store.

                                                    Parameters

                                                    • dataIndex : String

                                                      The property to collect

                                                    • allowNull : Boolean (optional)

                                                      Pass true to allow null, undefined or empty string values

                                                    • bypassFilter : Boolean (optional)

                                                      Pass true to collect from all records, even ones which are filtered.

                                                    Returns

                                                    • Object[]

                                                      An array of the unique values

                                                    Overrides: Ext.data.LocalStore.collect

                                                    Ext.data.Store
                                                    view source
                                                    ( )
                                                    Commits all Records with outstanding changes. ...

                                                    Commits all Records with outstanding changes. To handle updates for changes, subscribe to the Store's update event, and perform updating when the third parameter is Ext.data.Record.COMMIT.

                                                    Fires

                                                      Inherit docs ...

                                                      Inherit docs

                                                      Parameters

                                                      Fires

                                                        Overrides: Ext.data.AbstractStore.contains

                                                        Ext.data.Store
                                                        view source
                                                        ( [grouped] ) : Number
                                                        Gets the count of items in the store. ...

                                                        Gets the count of items in the store.

                                                        When store is filtered, only items within the filter are counted.

                                                        Parameters

                                                        • grouped : Boolean (optional)

                                                          True to perform the operation for each group in the store. The value returned will be an object literal with the key being the group name and the count for each group being the value. The grouped parameter is only honored if the store has a groupField.

                                                        Returns

                                                        Overrides: Ext.data.LocalStore.count

                                                        ( data, options )private
                                                        saves any phantom records ...

                                                        saves any phantom records

                                                        Parameters

                                                        Fires

                                                          ...

                                                          Parameters

                                                          Fires

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

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

                                                            Parameters

                                                            Returns

                                                            Fires

                                                              Ext.data.Store
                                                              view source
                                                              ( record ) : Ext.data.Modelprivate
                                                              Converts a literal to a model, if it's not a model already ...

                                                              Converts a literal to a model, if it's not a model already

                                                              Parameters

                                                              Returns

                                                              Fires

                                                                This method is called to cleanup an object and its resources. ...
                                                                ( name, fn, scope, options, order ) : Booleanprivate
                                                                ...

                                                                Parameters

                                                                Returns

                                                                Fires

                                                                  ( eventName, args, action, connectedController )private
                                                                  ...

                                                                  Parameters

                                                                  Fires

                                                                    ( name, fn, scope, options, order )private
                                                                    ...

                                                                    Parameters

                                                                    Fires

                                                                      Ext.data.Store
                                                                      view source
                                                                      ( fn, [scope] )
                                                                      Calls the specified function for each record in the store. ...

                                                                      Calls the specified function for each record in the store.

                                                                      When store is filtered, only loops over the filtered records.

                                                                      Parameters

                                                                      • fn : Function

                                                                        The function to call. The Record is passed as the first parameter. Returning false aborts and exits the iteration.

                                                                      • scope : Object (optional)

                                                                        The scope (this reference) in which the function is executed. Defaults to the current record in the iteration.

                                                                      Overrides: Ext.data.LocalStore.each

                                                                      Enables events fired by this Observable to bubble up an owner hierarchy by calling this.getBubbleTarget() if present. ...

                                                                      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.

                                                                      Parameters

                                                                      • events : String/String[]

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

                                                                      Fires

                                                                        This method is called after modifications are complete on a store. ...

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

                                                                        Available since: 5.0.0

                                                                        Fires

                                                                        tells the attached proxy to destroy the given records ...

                                                                        tells the attached proxy to destroy the given records

                                                                        Available since: 3.4.0

                                                                        Parameters

                                                                        Fires

                                                                          ...

                                                                          Parameters

                                                                          Fires

                                                                            Filters by a function. ...

                                                                            Filters by a function. The specified function will be called for each Record in this Store. If the function returns true the Record is included, otherwise it is filtered out.

                                                                            When store is filtered, most of the methods for accessing store data will be working only within the set of filtered records. The notable exception is getById.

                                                                            Parameters

                                                                            • fn : Function

                                                                              The function to be called. It will be passed the following parameters:

                                                                              Parameters

                                                                            • scope : Object (optional)

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

                                                                            Fires

                                                                              Filter function for new records. ...

                                                                              Filter function for new records.

                                                                              Parameters

                                                                              Ext.data.Store
                                                                              view source
                                                                              ( item )private
                                                                              ...

                                                                              Parameters

                                                                              Ext.data.Store
                                                                              view source
                                                                              ( item )private
                                                                              ...

                                                                              Parameters

                                                                              Filter function for updated records. ...

                                                                              Filter function for updated records.

                                                                              Parameters

                                                                              ( property, value, [startIndex], [anyMatch], [caseSensitive], [exactMatch] ) : Number
                                                                              Finds the index of the first matching Record in this store by a specific field value. ...

                                                                              Finds the index of the first matching Record in this store by a specific field value.

                                                                              When store is filtered, finds records only within filter.

                                                                              **IMPORTANT

                                                                              If this store is Buffered, this can ONLY find records which happen to be cached in the page cache. This will be parts of the dataset around the currently visible zone, or recently visited zones if the pages have not yet been purged from the cache.**

                                                                              Parameters

                                                                              • property : String

                                                                                The name of the Record field to test.

                                                                              • value : String/RegExp

                                                                                Either a string that the field value should begin with, or a RegExp to test against the field.

                                                                              • startIndex : Number (optional)

                                                                                The index to start searching at

                                                                                Defaults to: 0

                                                                              • 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). Ignored if anyMatch is true.

                                                                                Defaults to: false

                                                                              Returns

                                                                              • Number

                                                                                The matched index or -1

                                                                              Fires

                                                                                ( fn, [scope], [startIndex] ) : Number
                                                                                Find the index of the first matching Record in this Store by a function. ...

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

                                                                                When store is filtered, finds records only within filter.

                                                                                **IMPORTANT

                                                                                If this store is Buffered, this can ONLY find records which happen to be cached in the page cache. This will be parts of the dataset around the currently visible zone, or recently visited zones if the pages have not yet been purged from the cache.**

                                                                                Parameters

                                                                                • fn : Function

                                                                                  The function to be called. It will be passed the following parameters:

                                                                                  Parameters

                                                                                • scope : Object (optional)

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

                                                                                • startIndex : Number (optional)

                                                                                  The index to start searching at

                                                                                  Defaults to: 0

                                                                                Returns

                                                                                • Number

                                                                                  The matched index or -1

                                                                                Fires

                                                                                  ( fieldName, value, [startIndex] ) : Number
                                                                                  Finds the index of the first matching Record in this store by a specific field value. ...

                                                                                  Finds the index of the first matching Record in this store by a specific field value.

                                                                                  When store is filtered, finds records only within filter.

                                                                                  **IMPORTANT

                                                                                  If this store is Buffered, this can ONLY find records which happen to be cached in the page cache. This will be parts of the dataset around the currently visible zone, or recently visited zones if the pages have not yet been purged from the cache.**

                                                                                  Parameters

                                                                                  • fieldName : String

                                                                                    The name of the Record field to test.

                                                                                  • value : Object

                                                                                    The value to match the field against.

                                                                                  • startIndex : Number (optional)

                                                                                    The index to start searching at

                                                                                    Defaults to: 0

                                                                                  Returns

                                                                                  • Number

                                                                                    The matched index or -1

                                                                                  Fires

                                                                                    ( fieldName, value, [startIndex], [anyMatch], [caseSensitive], [exactMatch] ) : Ext.data.Model
                                                                                    Finds the first matching Record in this store by a specific field value. ...

                                                                                    Finds the first matching Record in this store by a specific field value.

                                                                                    When store is filtered, finds records only within filter.

                                                                                    **IMPORTANT

                                                                                    If this store is Buffered, this can ONLY find records which happen to be cached in the page cache. This will be parts of the dataset around the currently visible zone, or recently visited zones if the pages have not yet been purged from the cache.**

                                                                                    Parameters

                                                                                    • fieldName : String

                                                                                      The name of the Record field to test.

                                                                                    • value : String/RegExp

                                                                                      Either a string that the field value should begin with, or a RegExp to test against the field.

                                                                                    • startIndex : Number (optional)

                                                                                      The index to start searching at

                                                                                      Defaults to: 0

                                                                                    • 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). Ignored if anyMatch is true.

                                                                                      Defaults to: false

                                                                                    Returns

                                                                                    Fires

                                                                                      ( eventName, args, fn, scope ) : Object
                                                                                      Fires the specified event with the passed parameters and execute a function (action) at the end if there are no liste...

                                                                                      Fires the specified event with the passed parameters and execute a function (action) at the end if there are no listeners that return false.

                                                                                      Parameters

                                                                                      • eventName : String

                                                                                        The name of the event to fire.

                                                                                      • args : Array

                                                                                        Arguments to pass to handers.

                                                                                      • fn : Function

                                                                                        Action.

                                                                                      • scope : Object

                                                                                        Scope of fn.

                                                                                      Returns

                                                                                      Fires

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

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

                                                                                        The first argument is the name of the event. Every other argument passed will be available when you listen for the event.

                                                                                        Example

                                                                                        Firstly, we set up a listener for our new event.

                                                                                        this.on('myevent', function(arg1, arg2, arg3, arg4, options, e) {
                                                                                            console.log(arg1); // true
                                                                                            console.log(arg2); // 2
                                                                                            console.log(arg3); // { test: 'foo' }
                                                                                            console.log(arg4); // 14
                                                                                            console.log(options); // the options added when adding the listener
                                                                                            console.log(e); // the event object with information about the event
                                                                                        });
                                                                                        

                                                                                        And then we can fire off the event.

                                                                                        this.fireEvent('myevent', true, 2, { test: 'foo' }, 14);
                                                                                        

                                                                                        An event may be set to bubble up an Observable parent hierarchy 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.

                                                                                        Fires

                                                                                          Fires the specified event with the passed parameter list. ...

                                                                                          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.

                                                                                          Fires

                                                                                            Ext.data.Store
                                                                                            view source
                                                                                            ( [grouped] ) : Ext.data.Model/undefined
                                                                                            Convenience function for getting the first model instance in the store. ...

                                                                                            Convenience function for getting the first model instance in the store.

                                                                                            When store is filtered, will return first item within the filter.

                                                                                            Parameters

                                                                                            • grouped : Boolean (optional)

                                                                                              True to perform the operation for each group in the store. The value returned will be an object literal with the key being the group name and the first record being the value. The grouped parameter is only honored if the store has a groupField.

                                                                                            Returns

                                                                                            • Ext.data.Model/undefined

                                                                                              The first model instance in the store, or undefined

                                                                                            Overrides: Ext.data.LocalStore.first

                                                                                            ( fn, scope, records, field )private
                                                                                            ...

                                                                                            Parameters

                                                                                            Returns the value of associatedEntity. ...

                                                                                            Returns the value of associatedEntity.

                                                                                            Returns

                                                                                            Get the Record at the specified index. ...

                                                                                            Get the Record at the specified index.

                                                                                            The index is effected by filtering.

                                                                                            Parameters

                                                                                            • index : Number

                                                                                              The index of the Record to find.

                                                                                            Returns

                                                                                            • Ext.data.Model

                                                                                              The Record at the passed index. Returns undefined if not found.

                                                                                            Fires

                                                                                              Returns the value of autoDestroy. ...

                                                                                              Returns the value of autoDestroy.

                                                                                              Returns

                                                                                              Returns the value of autoFilter. ...

                                                                                              Returns the value of autoFilter.

                                                                                              Returns

                                                                                              Returns the value of autoLoad. ...

                                                                                              Returns the value of autoLoad.

                                                                                              Available since: 2.3.0

                                                                                              Returns

                                                                                              Returns the value of autoSort. ...

                                                                                              Returns the value of autoSort.

                                                                                              Returns

                                                                                              Returns the value of autoSync. ...

                                                                                              Returns the value of autoSync.

                                                                                              Returns

                                                                                              Returns an object which is passed in as the listeners argument to proxy.batch inside this.sync. ...

                                                                                              Returns an object which is passed in as the listeners argument to proxy.batch inside this.sync. This is broken out into a separate function to allow for customisation of the listeners

                                                                                              Returns

                                                                                              Returns the value of batchUpdateMode. ...

                                                                                              Returns the value of batchUpdateMode.

                                                                                              Returns

                                                                                              Returns the value of bubbleEvents. ...

                                                                                              Returns the value of bubbleEvents.

                                                                                              Returns

                                                                                              Ext.data.Store
                                                                                              view source
                                                                                              ( id ) : Ext.data.Model
                                                                                              Get the Record with the specified id. ...

                                                                                              Get the Record with the specified id.

                                                                                              This method is not affected by filtering, lookup will be performed from all records inside the store, filtered or not.

                                                                                              Parameters

                                                                                              • id : Mixed

                                                                                                The id of the Record to find.

                                                                                              Returns

                                                                                              • Ext.data.Model

                                                                                                The Record with the passed id. Returns null if not found.

                                                                                              Overrides: Ext.data.LocalStore.getById

                                                                                              Ext.data.Store
                                                                                              view source
                                                                                              ( internalId ) : Ext.data.Model
                                                                                              Get the Record with the specified internalId. ...

                                                                                              Get the Record with the specified internalId.

                                                                                              This method is not effected by filtering, lookup will be performed from all records inside the store, filtered or not.

                                                                                              Parameters

                                                                                              • internalId : Mixed

                                                                                                The id of the Record to find.

                                                                                              Returns

                                                                                              • Ext.data.Model

                                                                                                The Record with the passed internalId. Returns null if not found.

                                                                                              Overrides: Ext.data.LocalStore.getByInternalId

                                                                                              Returns the value of clearOnPageLoad. ...

                                                                                              Returns the value of clearOnPageLoad.

                                                                                              Returns

                                                                                              Returns the value of clearRemovedOnLoad. ...

                                                                                              Returns the value of clearRemovedOnLoad.

                                                                                              Returns

                                                                                              Returns a specified config property value. ...

                                                                                              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.

                                                                                              Gets the number of records in store. ...

                                                                                              Gets the number of records in store.

                                                                                              If using paging, this may not be the total size of the dataset. If the data object used by the Reader contains the dataset size, then the Ext.data.ProxyStore.getTotalCount function returns the dataset size. Note: see the Important note in Ext.data.ProxyStore.load.

                                                                                              When store is filtered, it's the number of records matching the filter.

                                                                                              Returns

                                                                                              • Number

                                                                                                The number of Records in the Store.

                                                                                              Fires

                                                                                                Returns the value of data. ...

                                                                                                Returns the value of data.

                                                                                                Returns

                                                                                                Returns the value of fields. ...

                                                                                                Returns the value of fields.

                                                                                                Available since: 2.3.0

                                                                                                Returns

                                                                                                Returns the value of filters. ...

                                                                                                Returns the value of filters.

                                                                                                Returns

                                                                                                Returns the value of groupDir. ...

                                                                                                Returns the value of groupDir.

                                                                                                Returns

                                                                                                Returns an array containing the result of applying grouping to the records in this store. ...

                                                                                                Returns an array containing the result of applying grouping to the records in this store. See groupField, groupDir. Example for a store containing records with a color field:

                                                                                                var myStore = Ext.create('Ext.data.Store', {
                                                                                                    groupField: 'color',
                                                                                                    groupDir  : 'DESC'
                                                                                                });
                                                                                                
                                                                                                myStore.getGroups(); // returns:
                                                                                                [
                                                                                                    {
                                                                                                        name: 'yellow',
                                                                                                        children: [
                                                                                                            // all records where the color field is 'yellow'
                                                                                                        ]
                                                                                                    },
                                                                                                    {
                                                                                                        name: 'red',
                                                                                                        children: [
                                                                                                            // all records where the color field is 'red'
                                                                                                        ]
                                                                                                    }
                                                                                                ]
                                                                                                

                                                                                                Group contents are effected by filtering.

                                                                                                Returns

                                                                                                Fires

                                                                                                  Retrieves the id of this component. ...

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

                                                                                                  Returns

                                                                                                  Fires

                                                                                                    Overrides: Ext.mixin.Identifiable.getId

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

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

                                                                                                    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.

                                                                                                    Returns the value of listeners. ...

                                                                                                    Returns the value of listeners.

                                                                                                    Returns

                                                                                                    ...

                                                                                                    Parameters

                                                                                                    Returns the value of model. ...

                                                                                                    Returns the value of model.

                                                                                                    Returns

                                                                                                    Gets all records added or updated since the last commit. ...

                                                                                                    Gets all records added or updated since the last commit. Note that the order of records returned is not deterministic and does not indicate the order in which records were modified. Note also that removed records are not included (use getRemovedRecords for that).

                                                                                                    Returns

                                                                                                    Fires

                                                                                                      Returns all Model instances that are either currently a phantom (e.g. ...

                                                                                                      Returns all Model instances that are either currently a phantom (e.g. have no id), or have an ID but have not yet been saved on this Store (this happens when adding a non-phantom record from another Store into this one)

                                                                                                      Returns

                                                                                                      Fires

                                                                                                        Overrides: Ext.data.ProxyStore.getNewRecords, Ext.data.Store.getNewRecords

                                                                                                        Returns the value of pageSize. ...

                                                                                                        Returns the value of pageSize.

                                                                                                        Returns

                                                                                                        Returns the value of proxy. ...

                                                                                                        Returns the value of proxy.

                                                                                                        Available since: 1.1.0

                                                                                                        Returns

                                                                                                        Gathers a range of Records between specified indices. ...

                                                                                                        Gathers a range of Records between specified indices.

                                                                                                        This method is affected by filtering.

                                                                                                        Parameters

                                                                                                        • start : Number

                                                                                                          The starting index. Defaults to zero.

                                                                                                        • end : Number

                                                                                                          The ending index. Defaults to the last record. The end index is included.

                                                                                                        Returns

                                                                                                        Fires

                                                                                                          Ext.data.Store
                                                                                                          view source
                                                                                                          ( )private
                                                                                                          ...

                                                                                                          Fires

                                                                                                            Returns the value of remoteFilter. ...

                                                                                                            Returns the value of remoteFilter.

                                                                                                            Returns

                                                                                                            Returns the value of remoteSort. ...

                                                                                                            Returns the value of remoteSort.

                                                                                                            Returns

                                                                                                            Returns any records that have been removed from the store but not yet destroyed on the proxy. ...

                                                                                                            Returns any records that have been removed from the store but not yet destroyed on the proxy.

                                                                                                            Returns

                                                                                                            Ext.data.Store
                                                                                                            view source
                                                                                                            ( ) : Ext.data.schema.Roleprivate
                                                                                                            Returns the value of role. ...

                                                                                                            Returns the value of role.

                                                                                                            Returns

                                                                                                            Returns the value of session. ...

                                                                                                            Returns the value of session.

                                                                                                            Available since: 5.0.0

                                                                                                            Returns

                                                                                                            Returns the value of sortOnLoad. ...

                                                                                                            Returns the value of sortOnLoad.

                                                                                                            Returns

                                                                                                            Returns the value of sorters. ...

                                                                                                            Returns the value of sorters.

                                                                                                            Returns

                                                                                                            Returns the grouping, sorting and filtered state of this Store. ...

                                                                                                            Returns the grouping, sorting and filtered state of this Store.

                                                                                                            Fires

                                                                                                              Returns the value of statefulFilters. ...

                                                                                                              Returns the value of statefulFilters.

                                                                                                              Returns

                                                                                                              Returns the value of storeId. ...

                                                                                                              Returns the value of storeId.

                                                                                                              Returns

                                                                                                              Returns the total number of Model instances that the Proxy indicates exist. ...

                                                                                                              Returns the total number of Model instances that the Proxy indicates exist. This will usually differ from getCount when using paging - getCount returns the number of records loaded into the Store at the moment, getTotalCount returns the number of records that could be loaded into the Store if the Store contained all data

                                                                                                              Returns

                                                                                                              • Number

                                                                                                                The total number of Model instances available via the Proxy. 0 returned if no value has been set via the reader.

                                                                                                              Returns the value of trackRemoved. ...

                                                                                                              Returns the value of trackRemoved.

                                                                                                              Returns

                                                                                                              Ext.data.Store
                                                                                                              view source
                                                                                                              ( )private
                                                                                                              ...

                                                                                                              Fires

                                                                                                                Returns all valid, non-phantom Model instances that have been updated in the Store but not yet synchronized with the ...

                                                                                                                Returns all valid, non-phantom Model instances that have been updated in the Store but not yet synchronized with the Proxy.

                                                                                                                Returns

                                                                                                                Fires

                                                                                                                  Overrides: Ext.data.ProxyStore.getUpdatedRecords, Ext.data.Store.getUpdatedRecords

                                                                                                                  Groups data inside the store. ...

                                                                                                                  Groups data inside the store.

                                                                                                                  Parameters

                                                                                                                  • grouper : String/Object

                                                                                                                    Either a string name of one of the fields in this Store's configured Model, or an object, or a grouper configuration object.

                                                                                                                  • direction : String (optional)

                                                                                                                    The overall direction to group the data by. Defaults to the value of groupDir.

                                                                                                                  Fires

                                                                                                                  ...

                                                                                                                  Parameters

                                                                                                                  Checks to see if this object has any listeners for a specified event ...

                                                                                                                  Checks to see if this object has any listeners for a specified event

                                                                                                                  Parameters

                                                                                                                  • eventName : String

                                                                                                                    The name of the event to check for

                                                                                                                  Returns

                                                                                                                  • Boolean

                                                                                                                    True if the event is being listened for, else false

                                                                                                                  Fires

                                                                                                                    Returns true if the store has a pending load task. ...

                                                                                                                    Returns true if the store has a pending load task.

                                                                                                                    Returns

                                                                                                                    • Boolean

                                                                                                                      true if the store has a pending load task.

                                                                                                                    Fires

                                                                                                                      Overrides: Ext.data.AbstractStore.hasPendingLoad

                                                                                                                      Ext.data.Store
                                                                                                                      view source
                                                                                                                      ( record ) : Number
                                                                                                                      Get the index of the record within the store. ...

                                                                                                                      Get the index of the record within the store.

                                                                                                                      When store is filtered, records outside of filter will not be found.

                                                                                                                      Parameters

                                                                                                                      Returns

                                                                                                                      • Number

                                                                                                                        The index of the passed Record. Returns -1 if not found.

                                                                                                                      Overrides: Ext.data.LocalStore.indexOf

                                                                                                                      Ext.data.Store
                                                                                                                      view source
                                                                                                                      ( id ) : Number
                                                                                                                      Get the index within the store of the Record with the passed id. ...

                                                                                                                      Get the index within the store of the Record with the passed id.

                                                                                                                      Like indexOf, this method is effected by filtering.

                                                                                                                      Parameters

                                                                                                                      • id : String

                                                                                                                        The id of the Record to find.

                                                                                                                      Returns

                                                                                                                      • Number

                                                                                                                        The index of the Record. Returns -1 if not found.

                                                                                                                      Overrides: Ext.data.LocalStore.indexOfId

                                                                                                                      ( config ) : Ext.Basechainableprotected
                                                                                                                      Initialize configuration for this class. ...

                                                                                                                      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

                                                                                                                      Returns

                                                                                                                      Fires

                                                                                                                        Ext.data.Store
                                                                                                                        view source
                                                                                                                        ( index, records ) : Ext.data.Model[]
                                                                                                                        Inserts Model instances into the Store at the given index and fires the add event. ...

                                                                                                                        Inserts Model instances into the Store at the given index and fires the add event. See also add.

                                                                                                                        Parameters

                                                                                                                        Returns

                                                                                                                        Fires

                                                                                                                          Tests whether the store currently has any active filters. ...

                                                                                                                          Tests whether the store currently has any active filters.

                                                                                                                          Returns

                                                                                                                          • Boolean

                                                                                                                            true if the store is filtered.

                                                                                                                          Fires

                                                                                                                            Tests whether the store currently has an active grouper. ...

                                                                                                                            Tests whether the store currently has an active grouper.

                                                                                                                            Returns

                                                                                                                            • Boolean

                                                                                                                              true if the store is grouped.

                                                                                                                            Fires

                                                                                                                              Returns true if the Store has been loaded. ...

                                                                                                                              Returns true if the Store has been loaded.

                                                                                                                              Returns

                                                                                                                              • Boolean

                                                                                                                                true if the Store has been loaded.

                                                                                                                              Returns true if the Store is currently performing a load operation ...

                                                                                                                              Returns true if the Store is currently performing a load operation

                                                                                                                              Returns

                                                                                                                              • Boolean

                                                                                                                                true if the Store is currently loading

                                                                                                                              Overrides: Ext.data.AbstractStore.isLoading

                                                                                                                              Tests whether the store currently has any active sorters. ...

                                                                                                                              Tests whether the store currently has any active sorters.

                                                                                                                              Returns

                                                                                                                              • Boolean

                                                                                                                                true if the store is sorted.

                                                                                                                              Fires

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

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

                                                                                                                                Parameters

                                                                                                                                • eventName : String (optional)

                                                                                                                                  The name of the specific event to check

                                                                                                                                Returns

                                                                                                                                • Boolean

                                                                                                                                  true if events are suspended

                                                                                                                                Ext.data.Store
                                                                                                                                view source
                                                                                                                                ( [grouped] ) : Ext.data.Model/undefined
                                                                                                                                Convenience function for getting the last model instance in the store. ...

                                                                                                                                Convenience function for getting the last model instance in the store.

                                                                                                                                When store is filtered, will return last item within the filter.

                                                                                                                                Parameters

                                                                                                                                • grouped : Boolean (optional)

                                                                                                                                  True to perform the operation for each group in the store. The value returned will be an object literal with the key being the group name and the last record being the value. The grouped parameter is only honored if the store has a groupField.

                                                                                                                                Returns

                                                                                                                                • Ext.data.Model/undefined

                                                                                                                                  The last model instance in the store, or undefined

                                                                                                                                Overrides: Ext.data.LocalStore.last

                                                                                                                                Ext.data.Store
                                                                                                                                view source
                                                                                                                                ( [options] )
                                                                                                                                Loads data into the Store via the configured proxy. ...

                                                                                                                                Loads data into the Store via the configured proxy. This uses the Proxy to make an asynchronous call to whatever storage backend the Proxy uses, automatically adding the retrieved instances into the Store and calling an optional callback if required. Example usage:

                                                                                                                                store.load({
                                                                                                                                    scope: this,
                                                                                                                                    callback: function(records, operation, success) {
                                                                                                                                        // the operation object
                                                                                                                                        // contains all of the details of the load operation
                                                                                                                                        console.log(records);
                                                                                                                                    }
                                                                                                                                });
                                                                                                                                

                                                                                                                                If the callback scope does not need to be set, a function can simply be passed:

                                                                                                                                store.load(function(records, operation, success) {
                                                                                                                                    console.log('loaded records');
                                                                                                                                });
                                                                                                                                

                                                                                                                                Parameters

                                                                                                                                • options : Object/Function (optional)

                                                                                                                                  config object, passed into the Ext.data.operation.Operation object before loading. Additionally addRecords: true can be specified to add these records to the existing records, default is to remove the Store's existing records first.

                                                                                                                                Fires

                                                                                                                                  Overrides: Ext.data.ProxyStore.load

                                                                                                                                  Ext.data.Store
                                                                                                                                  view source
                                                                                                                                  ( data, [append] )
                                                                                                                                  Loads an array of data straight into the Store. ...

                                                                                                                                  Loads an array of data straight into the Store.

                                                                                                                                  Using this method is great if the data is in the correct format already (e.g. it doesn't need to be processed by a reader). If your data requires processing to decode the data structure, use a MemoryProxy or loadRawData.

                                                                                                                                  Parameters

                                                                                                                                  • data : Ext.data.Model[]/Object[]

                                                                                                                                    Array of data to load. Any non-model instances will be cast into model instances first.

                                                                                                                                  • append : Boolean (optional)

                                                                                                                                    true to add the records to the existing records in the store, false to remove the old ones first.

                                                                                                                                    Defaults to: false

                                                                                                                                  Fires

                                                                                                                                  Ext.data.Store
                                                                                                                                  view source
                                                                                                                                  ( data )private
                                                                                                                                  ...

                                                                                                                                  Parameters

                                                                                                                                  Fires

                                                                                                                                  Ext.data.Store
                                                                                                                                  view source
                                                                                                                                  ( page, [options] )
                                                                                                                                  Loads a given 'page' of data by setting the start and limit values appropriately. ...

                                                                                                                                  Loads a given 'page' of data by setting the start and limit values appropriately. Internally this just causes a normal load operation, passing in calculated 'start' and 'limit' params.

                                                                                                                                  Parameters

                                                                                                                                  • page : Number

                                                                                                                                    The number of the page to load.

                                                                                                                                  • options : Object (optional)

                                                                                                                                    See options for load.

                                                                                                                                  Fires

                                                                                                                                    Ext.data.Store
                                                                                                                                    view source
                                                                                                                                    ( data, [append] ) : Boolean
                                                                                                                                    Loads data via the bound Proxy's reader Use this method if you are attempting to load data and want to utilize the c...

                                                                                                                                    Loads data via the bound Proxy's reader

                                                                                                                                    Use this method if you are attempting to load data and want to utilize the configured data reader.

                                                                                                                                    As of 4.2, this method will no longer fire the load event.

                                                                                                                                    Parameters

                                                                                                                                    • data : Object[]

                                                                                                                                      The full JSON object you'd like to load into the Data store.

                                                                                                                                    • append : Boolean (optional)

                                                                                                                                      true to add the records to the existing records in the store, false to remove the old ones first.

                                                                                                                                      Defaults to: false

                                                                                                                                    Returns

                                                                                                                                    Fires

                                                                                                                                    Ext.data.Store
                                                                                                                                    view source
                                                                                                                                    ( records, options )
                                                                                                                                    Loads an array of model instances into the store, fires the datachanged event. ...

                                                                                                                                    Loads an array of model instances into the store, fires the datachanged event. This should only usually be called internally when loading from the Proxy, when adding records manually use add instead

                                                                                                                                    Parameters

                                                                                                                                    • records : Ext.data.Model[]

                                                                                                                                      The array of records to load

                                                                                                                                    • options : Object
                                                                                                                                      • addRecords : Boolean (optional)

                                                                                                                                        Pass true to add these records to the existing records, false to remove the Store's existing records first.

                                                                                                                                        Defaults to: false

                                                                                                                                      • start : Number (optional)

                                                                                                                                        Only used by buffered Stores. The index within the overall dataset of the first record in the array.

                                                                                                                                    Fires

                                                                                                                                    Ext.data.Store
                                                                                                                                    view source
                                                                                                                                    ( field, [grouped] ) : Object
                                                                                                                                    Gets the maximum value in the store. ...

                                                                                                                                    Gets the maximum value in the store.

                                                                                                                                    When store is filtered, only items within the filter are aggregated.

                                                                                                                                    Parameters

                                                                                                                                    • field : String

                                                                                                                                      The field in each record

                                                                                                                                    • grouped : Boolean (optional)

                                                                                                                                      True to perform the operation for each group in the store. The value returned will be an object literal with the key being the group name and the maximum in the group being the value. The grouped parameter is only honored if the store has a groupField.

                                                                                                                                    Returns

                                                                                                                                    • Object

                                                                                                                                      The maximum value, if no items exist, undefined.

                                                                                                                                    Overrides: Ext.data.LocalStore.max

                                                                                                                                    Ext.data.Store
                                                                                                                                    view source
                                                                                                                                    ( field, [grouped] ) : Object
                                                                                                                                    Gets the minimum value in the store. ...

                                                                                                                                    Gets the minimum value in the store.

                                                                                                                                    When store is filtered, only items within the filter are aggregated.

                                                                                                                                    Parameters

                                                                                                                                    • field : String

                                                                                                                                      The field in each record

                                                                                                                                    • grouped : Boolean (optional)

                                                                                                                                      True to perform the operation for each group in the store. The value returned will be an object literal with the key being the group name and the minimum in the group being the value. The grouped parameter is only honored if the store has a groupField.

                                                                                                                                    Returns

                                                                                                                                    • Object

                                                                                                                                      The minimum value, if no items exist, undefined.

                                                                                                                                    Overrides: Ext.data.LocalStore.min

                                                                                                                                    ( object, eventName, [fn], [scope], [options] )deprecated
                                                                                                                                    Alias for addManagedListener. ...

                                                                                                                                    Alias for addManagedListener.

                                                                                                                                    This method has been deprecated since 2.0.0

                                                                                                                                    This is now done automatically

                                                                                                                                    Parameters

                                                                                                                                    • object : Ext.mixin.Observable/HTMLElement

                                                                                                                                      The item to which to add a listener/listeners.

                                                                                                                                    • eventName : Object/String

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

                                                                                                                                    • fn : Function (optional)

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

                                                                                                                                    • scope : Object (optional)

                                                                                                                                      If the eventName parameter was an event name, this is the scope in which the handler function is executed.

                                                                                                                                    • options : Object (optional)

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

                                                                                                                                    ( object, eventName, [fn], [scope] )deprecated
                                                                                                                                    Alias for removeManagedListener. ...

                                                                                                                                    Alias for removeManagedListener.

                                                                                                                                    This method has been deprecated since 2.0.0

                                                                                                                                    This is now done automatically

                                                                                                                                    Parameters

                                                                                                                                    • object : Ext.mixin.Observable/HTMLElement

                                                                                                                                      The item to which to add a listener/listeners.

                                                                                                                                    • eventName : Object/String

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

                                                                                                                                    • fn : Function (optional)

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

                                                                                                                                    • scope : Object (optional)

                                                                                                                                      If the eventName parameter was an event name, this is the scope in which the handler function is executed.

                                                                                                                                    Ext.data.Store
                                                                                                                                    view source
                                                                                                                                    ( options )
                                                                                                                                    Loads the next 'page' in the current data set ...

                                                                                                                                    Loads the next 'page' in the current data set

                                                                                                                                    Parameters

                                                                                                                                    Fires

                                                                                                                                      ( eventName, fn, [scope], [options], [order] )
                                                                                                                                      Alias for addListener. ...

                                                                                                                                      Alias for addListener.

                                                                                                                                      Parameters

                                                                                                                                      • eventName : String/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

                                                                                                                                        The method the event invokes. Will be called with arguments given to 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.

                                                                                                                                        This object may contain any of the following properties:

                                                                                                                                        • scope : Object (optional)

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

                                                                                                                                        • delay : Number (optional)

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

                                                                                                                                        • single : Boolean (optional)

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

                                                                                                                                        • order : String (optional)

                                                                                                                                          The order of when the listener should be added into the listener queue.

                                                                                                                                          If you set an order of before and the event you are listening to is preventable, you can return false and it will stop the event.

                                                                                                                                          Available options are before, current and after.

                                                                                                                                          Defaults to: current

                                                                                                                                        • buffer : Number (optional)

                                                                                                                                          Causes the handler to be 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.

                                                                                                                                        • element : String (optional)

                                                                                                                                          If this observable is a Component, allows you to add a listener onto a element of the component using the element's reference.

                                                                                                                                          Ext.create('Ext.Component', {
                                                                                                                                              listeners: {
                                                                                                                                                  element: 'element',
                                                                                                                                                  tap: function() {
                                                                                                                                                      alert('element tap!');
                                                                                                                                                  }
                                                                                                                                              }
                                                                                                                                          });
                                                                                                                                          

                                                                                                                                          In Sencha Touch, All components have the element reference, which is the outer most element of the component. Ext.Container also has the innerElement element which contains all children. In most cases element is adequate.

                                                                                                                                        • delegate : String (optional)

                                                                                                                                          For Elements, a simple DOM selector to filter the target or look for a descendant of the target.

                                                                                                                                          Sencha Touch Components can use Ext.ComponentQuery selectors to filter child Components.

                                                                                                                                          // Create a container with a two children; a button and a toolbar
                                                                                                                                          var container = Ext.create('Ext.Container', {
                                                                                                                                              items: [
                                                                                                                                                  {
                                                                                                                                                      xtype: 'toolbar',
                                                                                                                                                      docked: 'top',
                                                                                                                                                      title: 'My Toolbar'
                                                                                                                                                  },
                                                                                                                                                  {
                                                                                                                                                     xtype: 'button',
                                                                                                                                                     text: 'My Button'
                                                                                                                                                  }
                                                                                                                                              ]
                                                                                                                                          });
                                                                                                                                          
                                                                                                                                          container.addListener({
                                                                                                                                              // Ext.Buttons have an xtype of 'button', so we use that are a selector for our delegate
                                                                                                                                              delegate: 'button',
                                                                                                                                          
                                                                                                                                              tap: function() {
                                                                                                                                                  alert('Button tapped!');
                                                                                                                                              }
                                                                                                                                          });
                                                                                                                                          
                                                                                                                                        • capture : Boolean

                                                                                                                                          true to initiate capture which will fire the listeners on the target Element before any descendant Elements. Normal events start with the target element and propagate upward to ancestor elements, whereas captured events propagate from the top of the DOM downward to descendant elements. This option achieves the same result as the useCapture parameter in the standard JavaScript addEventListener method.

                                                                                                                                      • order : String (optional)

                                                                                                                                        The order of when the listener should be added into the listener queue. Possible values are before, current and after.

                                                                                                                                        Defaults to: 'current'

                                                                                                                                      ( eventName, fn, [scope], [options] )
                                                                                                                                      Alias for addAfterListener. ...

                                                                                                                                      Alias for addAfterListener.

                                                                                                                                      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.

                                                                                                                                      Attached as the 'complete' event listener to a proxy's Batch object. ...

                                                                                                                                      Attached as the 'complete' event listener to a proxy's Batch object. Iterates over the batch operations and updates the Store's internal data MixedCollection.

                                                                                                                                      Parameters

                                                                                                                                      Fires

                                                                                                                                      ...

                                                                                                                                      Parameters

                                                                                                                                      Attached as the 'operationcomplete' event listener to a proxy's Batch object. ...

                                                                                                                                      Attached as the 'operationcomplete' event listener to a proxy's Batch object. By default just calls through to onProxyWrite.

                                                                                                                                      Parameters

                                                                                                                                      Fires

                                                                                                                                      ( eventName, fn, [scope], [options] )
                                                                                                                                      Alias for addBeforeListener. ...

                                                                                                                                      Alias for addBeforeListener.

                                                                                                                                      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.

                                                                                                                                      This is attached to the data Collection's beforesort event only if not remoteSort If remoteSort, the event is fired b...

                                                                                                                                      This is attached to the data Collection's beforesort event only if not remoteSort If remoteSort, the event is fired before the reload call in Ext.data.ProxyStore.load.

                                                                                                                                      Parameters

                                                                                                                                      Fires

                                                                                                                                      ...

                                                                                                                                      Parameters

                                                                                                                                      ...

                                                                                                                                      Parameters

                                                                                                                                      Ext.data.Store
                                                                                                                                      view source
                                                                                                                                      ( collection, info )private
                                                                                                                                      ...

                                                                                                                                      Parameters

                                                                                                                                      Fires

                                                                                                                                      Ext.data.Store
                                                                                                                                      view source
                                                                                                                                      ( )private
                                                                                                                                      ...
                                                                                                                                      When the collection informs us that it has filtered, this LocalStore must react. ...

                                                                                                                                      When the collection informs us that it has filtered, this LocalStore must react. AbstractStore#onFilterEndUpdate does the correct thing (fires a refresh) if remote sorting is false

                                                                                                                                      Fires

                                                                                                                                      • datachanged
                                                                                                                                      • filterchange
                                                                                                                                      • refresh
                                                                                                                                      Ext.data.Store
                                                                                                                                      view source
                                                                                                                                      ( collection, items )private
                                                                                                                                      ...

                                                                                                                                      Parameters

                                                                                                                                      Fires

                                                                                                                                        If our source collection informs us that a filtered out item has changed, we must still fire the events... ...

                                                                                                                                        If our source collection informs us that a filtered out item has changed, we must still fire the events...

                                                                                                                                        Ext.data.Store
                                                                                                                                        view source
                                                                                                                                        ( collection, info )private
                                                                                                                                        ...

                                                                                                                                        Parameters

                                                                                                                                        Fires

                                                                                                                                        Ext.data.Store
                                                                                                                                        view source
                                                                                                                                        ( collection, info )private
                                                                                                                                        ...

                                                                                                                                        Parameters

                                                                                                                                        Fires

                                                                                                                                        When the collection informs us that it has sorted, this LocalStore must react. ...

                                                                                                                                        When the collection informs us that it has sorted, this LocalStore must react. AbstractStore#onSorterEndUpdate does the correct thing (fires a refresh) if remote sorting is false

                                                                                                                                        Fires

                                                                                                                                        • beforeload
                                                                                                                                        • datachanged
                                                                                                                                        • refresh
                                                                                                                                        • sort
                                                                                                                                        may be implemented by store subclasses ...

                                                                                                                                        may be implemented by store subclasses

                                                                                                                                        Ext.data.Store
                                                                                                                                        view source
                                                                                                                                        ( )private
                                                                                                                                        private ...

                                                                                                                                        private

                                                                                                                                        Fires

                                                                                                                                          Overrides: Ext.data.ProxyStore.onDestroy

                                                                                                                                          ( records, operation, success )private
                                                                                                                                          Removes any records when a write is returned from the server. ...

                                                                                                                                          Removes any records when a write is returned from the server.

                                                                                                                                          Parameters

                                                                                                                                          Ext.data.Store
                                                                                                                                          view source
                                                                                                                                          ( rec, oldId, newId )private
                                                                                                                                          ...

                                                                                                                                          Parameters

                                                                                                                                          Fires

                                                                                                                                          • idchanged
                                                                                                                                          private ...

                                                                                                                                          private

                                                                                                                                          Parameters

                                                                                                                                          Fires

                                                                                                                                          Ext.data.Store
                                                                                                                                          view source
                                                                                                                                          ( operation )private
                                                                                                                                          Called internally when a Proxy has completed a load request ...

                                                                                                                                          Called internally when a Proxy has completed a load request

                                                                                                                                          Parameters

                                                                                                                                          Fires

                                                                                                                                          Callback for any write Operation over the Proxy. ...

                                                                                                                                          Callback for any write Operation over the Proxy. Updates the Store's MixedCollection to reflect the updates provided by the Proxy

                                                                                                                                          Parameters

                                                                                                                                          Fires

                                                                                                                                          may be implemented by store subclasses ...

                                                                                                                                          may be implemented by store subclasses

                                                                                                                                          Ext.data.Store
                                                                                                                                          view source
                                                                                                                                          ( options )
                                                                                                                                          Loads the previous 'page' in the current data set ...

                                                                                                                                          Loads the previous 'page' in the current data set

                                                                                                                                          Parameters

                                                                                                                                          Fires

                                                                                                                                            Ext.data.Store
                                                                                                                                            view source
                                                                                                                                            ( property, value, [anyMatch], [caseSensitive], [exactMatch] ) : Ext.util.Collection
                                                                                                                                            Query all the cached records in this Store by name/value pair. ...

                                                                                                                                            Query all the cached records in this Store by name/value pair. The parameters will be used to generated a filter function that is given to the queryBy method.

                                                                                                                                            This method complements queryBy by generating the query function automatically.

                                                                                                                                            This method is not affected by filtering, it will always search all records in the store regardless of filtering.

                                                                                                                                            Parameters

                                                                                                                                            • property : String

                                                                                                                                              The property to create the filter function for

                                                                                                                                            • value : String/RegExp

                                                                                                                                              The string/regex to compare the property value to

                                                                                                                                            • anyMatch : Boolean (optional)

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

                                                                                                                                              Defaults to: false

                                                                                                                                            • caseSensitive : Boolean (optional)

                                                                                                                                              true to create a case-sensitive regex.

                                                                                                                                              Defaults to: false

                                                                                                                                            • exactMatch : Boolean (optional)

                                                                                                                                              True to force exact match (^ and $ characters added to the regex). Ignored if anyMatch is true.

                                                                                                                                              Defaults to: false

                                                                                                                                            Returns

                                                                                                                                            Overrides: Ext.data.LocalStore.query

                                                                                                                                            Ext.data.Store
                                                                                                                                            view source
                                                                                                                                            ( fn, [scope] ) : Ext.util.Collection
                                                                                                                                            Query all the cached records in this Store using a filtering function. ...

                                                                                                                                            Query all the cached records in this Store using a filtering function. The specified function will be called with each record in this Store. If the function returns true the record is included in the results.

                                                                                                                                            This method is not affected by filtering, it will always search all records in the store regardless of filtering.

                                                                                                                                            Parameters

                                                                                                                                            • fn : Function

                                                                                                                                              The function to be called. It will be passed the following parameters:

                                                                                                                                              Parameters

                                                                                                                                            • scope : Object (optional)

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

                                                                                                                                            Returns

                                                                                                                                            Overrides: Ext.data.LocalStore.queryBy

                                                                                                                                            Determines if the passed range is available in the page cache. ...

                                                                                                                                            Determines if the passed range is available in the page cache.

                                                                                                                                            Parameters

                                                                                                                                            • start : Number

                                                                                                                                              The start index

                                                                                                                                            • end : Number

                                                                                                                                              The end index in the range

                                                                                                                                            Fires

                                                                                                                                              Ext.data.Store
                                                                                                                                              view source
                                                                                                                                              ( )
                                                                                                                                              Rejects outstanding changes on all modified records and re-insert any records that were removed locally. ...

                                                                                                                                              Rejects outstanding changes on all modified records and re-insert any records that were removed locally. Any phantom records will be removed.

                                                                                                                                              Fires

                                                                                                                                                ( args, fn, scope, options, order )private
                                                                                                                                                ...

                                                                                                                                                Parameters

                                                                                                                                                Fires

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

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

                                                                                                                                                  Parameters

                                                                                                                                                  • object : Object

                                                                                                                                                    The Observable whose events this object is to relay.

                                                                                                                                                  • events : String/Array/Object

                                                                                                                                                    Array of event names to relay.

                                                                                                                                                  Returns

                                                                                                                                                  Fires

                                                                                                                                                    Reloads the store using the last options passed to the load method. ...

                                                                                                                                                    Reloads the store using the last options passed to the load method. You can use the reload method to reload the store using the parameters from the last load() call. For example:

                                                                                                                                                    store.load({
                                                                                                                                                        params : {
                                                                                                                                                            userid : 22216
                                                                                                                                                        }
                                                                                                                                                    });
                                                                                                                                                    
                                                                                                                                                    //...
                                                                                                                                                    
                                                                                                                                                    store.reload();
                                                                                                                                                    

                                                                                                                                                    The initial load execution will pass the userid parameter in the request. The reload execution will also send the same userid parameter in its request as it will reuse the params object from the last load call.

                                                                                                                                                    You can override a param by passing in the config object with the params object:

                                                                                                                                                    store.load({
                                                                                                                                                        params : {
                                                                                                                                                            userid : 22216,
                                                                                                                                                            foo    : 'bar'
                                                                                                                                                        }
                                                                                                                                                    });
                                                                                                                                                    
                                                                                                                                                    //...
                                                                                                                                                    
                                                                                                                                                    store.reload({
                                                                                                                                                        params : {
                                                                                                                                                            userid : 1234
                                                                                                                                                        }
                                                                                                                                                    });
                                                                                                                                                    

                                                                                                                                                    The initial load execution sends the userid and foo parameters but in the reload it only sends the userid paramter because you are overriding the params config not just overriding the one param. To only change a single param but keep other params, you will have to get the last params from the lastOptions property:

                                                                                                                                                    var lastOptions = store.lastOptions,
                                                                                                                                                        lastParams = Ext.clone(lastOptions.params); // make a copy of the last params so we don't affect future reload() calls
                                                                                                                                                    
                                                                                                                                                    lastParams.userid = 1234;
                                                                                                                                                    
                                                                                                                                                    store.reload({
                                                                                                                                                        params : lastParams
                                                                                                                                                    });
                                                                                                                                                    

                                                                                                                                                    This will now send the userid parameter as 1234 and the foo param as 'bar'.

                                                                                                                                                    Parameters

                                                                                                                                                    • options : Object (optional)

                                                                                                                                                      A config object which contains options which may override the options passed to the previous load call. See the load method for valid configs.

                                                                                                                                                    Fires

                                                                                                                                                    Ext.data.Store
                                                                                                                                                    view source
                                                                                                                                                    ( records )
                                                                                                                                                    Removes the specified record(s) from the Store, firing the remove event for the removed records. ...

                                                                                                                                                    Removes the specified record(s) from the Store, firing the remove event for the removed records.

                                                                                                                                                    After all records have been removed a single datachanged is fired.

                                                                                                                                                    Parameters

                                                                                                                                                    Fires

                                                                                                                                                      ( eventName, fn, [scope], [options] )
                                                                                                                                                      Removes a before-event handler. ...

                                                                                                                                                      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.

                                                                                                                                                      Fires

                                                                                                                                                        Ext.data.Store
                                                                                                                                                        view source
                                                                                                                                                        ( [silent] ) : Ext.data.Model[]
                                                                                                                                                        Removes all items from the store. ...

                                                                                                                                                        Removes all items from the store.

                                                                                                                                                        Individual record remove events are not fired by this method.

                                                                                                                                                        Parameters

                                                                                                                                                        • silent : Boolean (optional)

                                                                                                                                                          Pass true to prevent the clear event from being fired.

                                                                                                                                                          Defaults to: false

                                                                                                                                                        Returns

                                                                                                                                                        Fires

                                                                                                                                                        Overrides: Ext.data.ProxyStore.removeAll, Ext.data.Store.removeAll

                                                                                                                                                        Ext.data.Store
                                                                                                                                                        view source
                                                                                                                                                        ( index, [count] )
                                                                                                                                                        Removes the model instance(s) at the given index ...

                                                                                                                                                        Removes the model instance(s) at the given index

                                                                                                                                                        Parameters

                                                                                                                                                        • index : Number

                                                                                                                                                          The record index

                                                                                                                                                        • count : Number (optional)

                                                                                                                                                          The number of records to delete

                                                                                                                                                          Defaults to: 1

                                                                                                                                                        Fires

                                                                                                                                                          ( eventName, fn, [scope], [options] )
                                                                                                                                                          Removes a before-event handler. ...

                                                                                                                                                          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.

                                                                                                                                                          Fires

                                                                                                                                                            ( selector, name, fn, scope, options, order )private
                                                                                                                                                            ...

                                                                                                                                                            Parameters

                                                                                                                                                            Fires

                                                                                                                                                              Removes an individual Filter from the current filter set using the passed Filter/Filter id and by default, applys the...

                                                                                                                                                              Removes an individual Filter from the current filter set using the passed Filter/Filter id and by default, applys the updated filter set to the Store's unfiltered dataset.

                                                                                                                                                              Parameters

                                                                                                                                                              • toRemove : String/Ext.util.Filter

                                                                                                                                                                The id of a Filter to remove from the filter set, or a Filter instance to remove.

                                                                                                                                                              Fires

                                                                                                                                                                ( eventName, fn, [scope], [options], [order] )
                                                                                                                                                                Removes an event handler. ...

                                                                                                                                                                Removes an event handler.

                                                                                                                                                                Parameters

                                                                                                                                                                • eventName : String/String[]/Object

                                                                                                                                                                  The type of event the handler was associated with.

                                                                                                                                                                • fn : Function/String

                                                                                                                                                                  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 addListener or the listener will not be removed.

                                                                                                                                                                • options : Object (optional)

                                                                                                                                                                  Extra options object. See addListener for details.

                                                                                                                                                                • order : String (optional)

                                                                                                                                                                  The order of the listener to remove. Possible values are before, current and after.

                                                                                                                                                                  Defaults to: 'current'

                                                                                                                                                                Fires

                                                                                                                                                                  ( object, eventName, [fn], [scope] )deprecated
                                                                                                                                                                  Adds listeners to any Observable object (or Element) which are automatically removed when this Component is destroyed. ...

                                                                                                                                                                  Adds listeners to any Observable object (or Element) which are automatically removed when this Component is destroyed.

                                                                                                                                                                  This method has been deprecated since 2.0

                                                                                                                                                                  All listeners are now automatically managed where necessary. Simply use removeListener.

                                                                                                                                                                  Parameters

                                                                                                                                                                  • object : Ext.mixin.Observable/HTMLElement

                                                                                                                                                                    The item to which to add a listener/listeners.

                                                                                                                                                                  • eventName : Object/String

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

                                                                                                                                                                  • fn : Function (optional)

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

                                                                                                                                                                  • scope : Object (optional)

                                                                                                                                                                    If the eventName parameter was an event name, this is the scope in which the handler function is executed.

                                                                                                                                                                  ...

                                                                                                                                                                  Parameters

                                                                                                                                                                  This method determines the scope (the this pointer) of named listeners that have not be given a specific scope. ...

                                                                                                                                                                  This method determines the scope (the this pointer) of named listeners that have not be given a specific scope. For example:

                                                                                                                                                                   component.on({
                                                                                                                                                                       click: 'onClick'
                                                                                                                                                                   });
                                                                                                                                                                  

                                                                                                                                                                  The default implementation of this method returns this object. Components and other observable objects that have natural hierarchies can override this method to pick the desired scope using other means.

                                                                                                                                                                  Available since: 5.0.0

                                                                                                                                                                  Parameters

                                                                                                                                                                  • defaultScope : Object (optional)

                                                                                                                                                                    The default scope to return if none is found.

                                                                                                                                                                    Defaults to: this

                                                                                                                                                                  Returns

                                                                                                                                                                  • Object

                                                                                                                                                                    The object on which non-scoped, named listeners should be fired.

                                                                                                                                                                  Resumes automatically syncing the Store with its Proxy. ...

                                                                                                                                                                  Resumes automatically syncing the Store with its Proxy. Only applicable if autoSync is true

                                                                                                                                                                  Parameters

                                                                                                                                                                  • syncNow : Boolean

                                                                                                                                                                    Pass true to synchronize now. Only synchronizes with the Proxy if the suspension count has gone to zero (We are not under a higher level of suspension)

                                                                                                                                                                  Fires

                                                                                                                                                                  Resumes firing of the named event(s). ...

                                                                                                                                                                  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.

                                                                                                                                                                  Fires

                                                                                                                                                                    Resumes firing events (see suspendEvents). ...

                                                                                                                                                                    Resumes firing events (see suspendEvents).

                                                                                                                                                                    Parameters

                                                                                                                                                                    • discardQueuedEvents : Boolean

                                                                                                                                                                      Pass as true to discard any queued events.

                                                                                                                                                                    Saves all pending changes via the configured proxy. ...

                                                                                                                                                                    Saves all pending changes via the configured proxy. Use sync instead.

                                                                                                                                                                    This method has been deprecated since 4.0.0

                                                                                                                                                                    Will be removed in the next major version

                                                                                                                                                                    Ext.data.Store
                                                                                                                                                                    view source
                                                                                                                                                                    ( associatedEntity )private
                                                                                                                                                                    Sets the value of associatedEntity. ...

                                                                                                                                                                    Sets the value of associatedEntity.

                                                                                                                                                                    Parameters

                                                                                                                                                                    Sets the value of autoDestroy. ...

                                                                                                                                                                    Sets the value of autoDestroy.

                                                                                                                                                                    Parameters

                                                                                                                                                                    Sets the value of autoFilter. ...

                                                                                                                                                                    Sets the value of autoFilter.

                                                                                                                                                                    Parameters

                                                                                                                                                                    Sets the value of autoLoad. ...

                                                                                                                                                                    Sets the value of autoLoad.

                                                                                                                                                                    Available since: 2.3.0

                                                                                                                                                                    Parameters

                                                                                                                                                                    Sets the value of autoSort. ...

                                                                                                                                                                    Sets the value of autoSort.

                                                                                                                                                                    Parameters

                                                                                                                                                                    Sets the value of autoSync. ...

                                                                                                                                                                    Sets the value of autoSync.

                                                                                                                                                                    Parameters

                                                                                                                                                                    Sets the value of batchUpdateMode. ...

                                                                                                                                                                    Sets the value of batchUpdateMode.

                                                                                                                                                                    Parameters

                                                                                                                                                                    Sets the value of bubbleEvents. ...

                                                                                                                                                                    Sets the value of bubbleEvents.

                                                                                                                                                                    Parameters

                                                                                                                                                                    Ext.data.Store
                                                                                                                                                                    view source
                                                                                                                                                                    ( clearOnPageLoad )
                                                                                                                                                                    Sets the value of clearOnPageLoad. ...

                                                                                                                                                                    Sets the value of clearOnPageLoad.

                                                                                                                                                                    Parameters

                                                                                                                                                                    Ext.data.Store
                                                                                                                                                                    view source
                                                                                                                                                                    ( clearRemovedOnLoad )
                                                                                                                                                                    Sets the value of clearRemovedOnLoad. ...

                                                                                                                                                                    Sets the value of clearRemovedOnLoad.

                                                                                                                                                                    Parameters

                                                                                                                                                                    ( name, [value] ) : Ext.Basechainable
                                                                                                                                                                    Sets a single/multiple configuration options. ...

                                                                                                                                                                    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

                                                                                                                                                                    Fires

                                                                                                                                                                      Ext.data.Store
                                                                                                                                                                      view source
                                                                                                                                                                      ( data )
                                                                                                                                                                      Sets the value of data. ...

                                                                                                                                                                      Sets the value of data.

                                                                                                                                                                      Parameters

                                                                                                                                                                      Sets the value of fields. ...

                                                                                                                                                                      Sets the value of fields.

                                                                                                                                                                      Available since: 2.3.0

                                                                                                                                                                      Parameters

                                                                                                                                                                      Sets the value of filters. ...

                                                                                                                                                                      Sets the value of filters.

                                                                                                                                                                      Parameters

                                                                                                                                                                      Sets the value of groupDir. ...

                                                                                                                                                                      Sets the value of groupDir.

                                                                                                                                                                      Parameters

                                                                                                                                                                      Sets the value of groupField. ...

                                                                                                                                                                      Sets the value of groupField.

                                                                                                                                                                      Parameters

                                                                                                                                                                      Sets the value of grouper. ...

                                                                                                                                                                      Sets the value of grouper.

                                                                                                                                                                      Parameters

                                                                                                                                                                      ...

                                                                                                                                                                      Parameters

                                                                                                                                                                      Sets the value of listeners. ...

                                                                                                                                                                      Sets the value of listeners.

                                                                                                                                                                      Parameters

                                                                                                                                                                      Sets the value of model. ...

                                                                                                                                                                      Sets the value of model.

                                                                                                                                                                      Parameters

                                                                                                                                                                      Sets the value of pageSize. ...

                                                                                                                                                                      Sets the value of pageSize.

                                                                                                                                                                      Parameters

                                                                                                                                                                      Sets the value of proxy. ...

                                                                                                                                                                      Sets the value of proxy.

                                                                                                                                                                      Available since: 1.1.0

                                                                                                                                                                      Parameters

                                                                                                                                                                      Ext.data.Store
                                                                                                                                                                      view source
                                                                                                                                                                      ( records )private
                                                                                                                                                                      Make a set of records be current in the store. ...

                                                                                                                                                                      Make a set of records be current in the store. This means that unneeded records will be removed and new records will be added.

                                                                                                                                                                      Parameters

                                                                                                                                                                      Fires

                                                                                                                                                                        Sets the value of remoteFilter. ...

                                                                                                                                                                        Sets the value of remoteFilter.

                                                                                                                                                                        Parameters

                                                                                                                                                                        Sets the value of remoteSort. ...

                                                                                                                                                                        Sets the value of remoteSort.

                                                                                                                                                                        Parameters

                                                                                                                                                                        Ext.data.Store
                                                                                                                                                                        view source
                                                                                                                                                                        ( role )private
                                                                                                                                                                        Sets the value of role. ...

                                                                                                                                                                        Sets the value of role.

                                                                                                                                                                        Parameters

                                                                                                                                                                        Ext.data.Store
                                                                                                                                                                        view source
                                                                                                                                                                        ( session )
                                                                                                                                                                        Sets the value of session. ...

                                                                                                                                                                        Sets the value of session.

                                                                                                                                                                        Available since: 5.0.0

                                                                                                                                                                        Parameters

                                                                                                                                                                        Sets the value of sortOnLoad. ...

                                                                                                                                                                        Sets the value of sortOnLoad.

                                                                                                                                                                        Parameters

                                                                                                                                                                        Sets the value of sorters. ...

                                                                                                                                                                        Sets the value of sorters.

                                                                                                                                                                        Parameters

                                                                                                                                                                        Sets the value of statefulFilters. ...

                                                                                                                                                                        Sets the value of statefulFilters.

                                                                                                                                                                        Parameters

                                                                                                                                                                        Sets the value of storeId. ...

                                                                                                                                                                        Sets the value of storeId.

                                                                                                                                                                        Parameters

                                                                                                                                                                        Sets the value of trackRemoved. ...

                                                                                                                                                                        Sets the value of trackRemoved.

                                                                                                                                                                        Parameters

                                                                                                                                                                        Sorts the data in the Store by one or more of its properties. ...

                                                                                                                                                                        Sorts the data in the Store by one or more of its properties. Example usage:

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

                                                                                                                                                                        Internally, Store converts the passed arguments into an array of Ext.util.Sorter instances, and delegates the actual sorting to its internal Ext.util.MixedCollection.

                                                                                                                                                                        When passing a single string argument to sort, Store maintains a ASC/DESC toggler per field, so this code:

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

                                                                                                                                                                        Is equivalent to this code, because Store handles the toggling automatically:

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

                                                                                                                                                                        Parameters

                                                                                                                                                                        • sorters : String/Ext.util.Sorter[] (optional)

                                                                                                                                                                          Either a string name of one of the fields in this Store's configured Model, or an array of sorter configurations.

                                                                                                                                                                        • direction : String (optional)

                                                                                                                                                                          The overall direction to sort the data by.

                                                                                                                                                                          Defaults to: "ASC"

                                                                                                                                                                        Returns

                                                                                                                                                                        Fires

                                                                                                                                                                        • beforeload
                                                                                                                                                                        Ext.data.Store
                                                                                                                                                                        view source
                                                                                                                                                                        ( index, toRemove, toAdd )private
                                                                                                                                                                        [splice description] ...

                                                                                                                                                                        [splice description]

                                                                                                                                                                        Parameters

                                                                                                                                                                        • index : [type]
                                                                                                                                                                        • toRemove : [type]
                                                                                                                                                                        • toAdd : [type]

                                                                                                                                                                        Fires

                                                                                                                                                                          Get the reference to the class from which this object was instantiated. ...

                                                                                                                                                                          Get the reference to the class from which this object was instantiated. Note that unlike 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.data.Store
                                                                                                                                                                          view source
                                                                                                                                                                          ( field, [grouped] ) : Number
                                                                                                                                                                          Sums the value of field for each record in store and returns the result. ...

                                                                                                                                                                          Sums the value of field for each record in store and returns the result.

                                                                                                                                                                          When store is filtered, only sums items within the filter.

                                                                                                                                                                          Parameters

                                                                                                                                                                          • field : String

                                                                                                                                                                            A field in each record

                                                                                                                                                                          • grouped : Boolean (optional)

                                                                                                                                                                            True to perform the operation for each group in the store. The value returned will be an object literal with the key being the group name and the sum for that group being the value. The grouped parameter is only honored if the store has a groupField.

                                                                                                                                                                          Returns

                                                                                                                                                                          Overrides: Ext.data.LocalStore.sum

                                                                                                                                                                          Suspends automatically syncing the Store with its Proxy. ...

                                                                                                                                                                          Suspends automatically syncing the Store with its Proxy. Only applicable if autoSync is true

                                                                                                                                                                          Suspends firing of the named event(s). ...

                                                                                                                                                                          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.

                                                                                                                                                                          Suspends the firing of all events. ...

                                                                                                                                                                          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.

                                                                                                                                                                          Synchronizes the store with its proxy. ...

                                                                                                                                                                          Synchronizes the store with its proxy. This asks the proxy to batch together any new, updated and deleted records in the store, updating the store's internal representation of the records as each operation completes.

                                                                                                                                                                          Parameters

                                                                                                                                                                          • options : Object (optional)

                                                                                                                                                                            Object containing one or more properties supported by the sync method (these get passed along to the underlying proxy's batch method):

                                                                                                                                                                            • batch : Ext.data.Batch/Object (optional)

                                                                                                                                                                              A Ext.data.Batch object (or batch config to apply to the created batch). If unspecified a default batch will be auto-created as needed.

                                                                                                                                                                            • callback : Function (optional)

                                                                                                                                                                              The function to be called upon completion of the sync. The callback is called regardless of success or failure and is passed the following parameters:

                                                                                                                                                                              Parameters

                                                                                                                                                                              • batch : Ext.data.Batch

                                                                                                                                                                                The batch that was processed, containing all operations in their current state after processing

                                                                                                                                                                              • options : Object

                                                                                                                                                                                The options argument that was originally passed into sync

                                                                                                                                                                            • success : Function (optional)

                                                                                                                                                                              The function to be called upon successful completion of the sync. The success function is called only if no exceptions were reported in any operations. If one or more exceptions occurred then the failure function will be called instead. The success function is called with the following parameters:

                                                                                                                                                                              Parameters

                                                                                                                                                                              • batch : Ext.data.Batch

                                                                                                                                                                                The batch that was processed, containing all operations in their current state after processing

                                                                                                                                                                              • options : Object

                                                                                                                                                                                The options argument that was originally passed into sync

                                                                                                                                                                            • failure : Function (optional)

                                                                                                                                                                              The function to be called upon unsuccessful completion of the sync. The failure function is called when one or more operations returns an exception during processing (even if some operations were also successful). In this case you can check the batch's exceptions array to see exactly which operations had exceptions. The failure function is called with the following parameters:

                                                                                                                                                                              Parameters

                                                                                                                                                                              • batch : Ext.data.Batch

                                                                                                                                                                                The Ext.data.Batch that was processed, containing all operations in their current state after processing

                                                                                                                                                                              • options : Object

                                                                                                                                                                                The options argument that was originally passed into sync

                                                                                                                                                                            • params : Object (optional)

                                                                                                                                                                              Additional params to send during the sync Operation(s).

                                                                                                                                                                            • scope : Object (optional)

                                                                                                                                                                              The scope in which to execute any callbacks (i.e. the this object inside the callback, success and/or failure functions). Defaults to the store's proxy.

                                                                                                                                                                          Returns

                                                                                                                                                                          Fires

                                                                                                                                                                          ( toggle, eventName, fn, scope, options, order )private
                                                                                                                                                                          ...

                                                                                                                                                                          Parameters

                                                                                                                                                                          Fires

                                                                                                                                                                            ( eventName, fn, [scope], [options], [order] )
                                                                                                                                                                            Alias for removeListener. ...

                                                                                                                                                                            Alias for removeListener.

                                                                                                                                                                            Parameters

                                                                                                                                                                            • eventName : String/String[]/Object

                                                                                                                                                                              The type of event the handler was associated with.

                                                                                                                                                                            • fn : Function/String

                                                                                                                                                                              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 addListener or the listener will not be removed.

                                                                                                                                                                            • options : Object (optional)

                                                                                                                                                                              Extra options object. See addListener for details.

                                                                                                                                                                            • order : String (optional)

                                                                                                                                                                              The order of the listener to remove. Possible values are before, current and after.

                                                                                                                                                                              Defaults to: 'current'

                                                                                                                                                                            ( eventName, fn, [scope], [options] )
                                                                                                                                                                            Alias for removeAfterListener. ...

                                                                                                                                                                            Alias for removeAfterListener.

                                                                                                                                                                            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.

                                                                                                                                                                            ( eventName, fn, [scope], [options] )
                                                                                                                                                                            Alias for removeBeforeListener. ...

                                                                                                                                                                            Alias for removeBeforeListener.

                                                                                                                                                                            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.

                                                                                                                                                                            ...

                                                                                                                                                                            Parameters

                                                                                                                                                                            ...

                                                                                                                                                                            Parameters

                                                                                                                                                                            Fires

                                                                                                                                                                              ...

                                                                                                                                                                              Parameters

                                                                                                                                                                              Fires

                                                                                                                                                                                ...

                                                                                                                                                                                Parameters

                                                                                                                                                                                Fires

                                                                                                                                                                                  ...

                                                                                                                                                                                  Parameters

                                                                                                                                                                                  Fires

                                                                                                                                                                                    ...

                                                                                                                                                                                    Parameters

                                                                                                                                                                                    Fires

                                                                                                                                                                                      Ext.data.Store
                                                                                                                                                                                      view source
                                                                                                                                                                                      ( remote )private
                                                                                                                                                                                      ...

                                                                                                                                                                                      Parameters

                                                                                                                                                                                      Fires

                                                                                                                                                                                        Overrides: Ext.data.AbstractStore.updateRemoteFilter

                                                                                                                                                                                        Ext.data.Store
                                                                                                                                                                                        view source
                                                                                                                                                                                        ( remote )private
                                                                                                                                                                                        ...

                                                                                                                                                                                        Parameters

                                                                                                                                                                                        Fires

                                                                                                                                                                                          Overrides: Ext.data.AbstractStore.updateRemoteSort

                                                                                                                                                                                          ...

                                                                                                                                                                                          Parameters

                                                                                                                                                                                          Defined By

                                                                                                                                                                                          Static methods

                                                                                                                                                                                          ( config, [mixinClass] )privatestatic
                                                                                                                                                                                          Adds new config properties to this class. ...

                                                                                                                                                                                          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 : Class (optional)

                                                                                                                                                                                            The mixin class if the configs are from a mixin.

                                                                                                                                                                                          ( members )chainableprivatestatic
                                                                                                                                                                                          ...

                                                                                                                                                                                          Parameters

                                                                                                                                                                                          ( name, member )chainableprivatestatic
                                                                                                                                                                                          ...

                                                                                                                                                                                          Parameters

                                                                                                                                                                                          ( members, [isStatic], [privacy] )chainablestatic
                                                                                                                                                                                          Add methods / properties to the prototype of this class. ...

                                                                                                                                                                                          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

                                                                                                                                                                                          ( members ) : Ext.Basechainablestatic
                                                                                                                                                                                          Add / override static properties of this class. ...

                                                                                                                                                                                          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

                                                                                                                                                                                          Returns

                                                                                                                                                                                          ( fromClass, members ) : Ext.Baseprivatestatic
                                                                                                                                                                                          Borrow another class' members to the prototype of this class. ...

                                                                                                                                                                                          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

                                                                                                                                                                                          ( args )protectedstatic
                                                                                                                                                                                          ...

                                                                                                                                                                                          Parameters

                                                                                                                                                                                          ( args )protectedstatic
                                                                                                                                                                                          ...

                                                                                                                                                                                          Parameters

                                                                                                                                                                                          Create a new instance of this Class. ...

                                                                                                                                                                                          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

                                                                                                                                                                                          ( alias, origin )static
                                                                                                                                                                                          Create aliases for existing prototype methods. ...

                                                                                                                                                                                          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

                                                                                                                                                                                          ( config )privatestatic
                                                                                                                                                                                          ...

                                                                                                                                                                                          Parameters

                                                                                                                                                                                          Returns the Ext.Configurator for this class. ...

                                                                                                                                                                                          Returns the Ext.Configurator for this class.

                                                                                                                                                                                          Returns

                                                                                                                                                                                          Get the current class' name in string format. ...

                                                                                                                                                                                          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

                                                                                                                                                                                          ( name, mixinClass )privatestatic
                                                                                                                                                                                          Used internally by the mixins pre-processor ...

                                                                                                                                                                                          Used internally by the mixins pre-processor

                                                                                                                                                                                          Parameters

                                                                                                                                                                                          ( fn, scope )chainableprivatestatic
                                                                                                                                                                                          ...

                                                                                                                                                                                          Parameters

                                                                                                                                                                                          Override members of this class. ...

                                                                                                                                                                                          Override members of this class. Overridden methods can be invoked via 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

                                                                                                                                                                                          Defined By

                                                                                                                                                                                          Events

                                                                                                                                                                                          ( store, records, index, eOpts )
                                                                                                                                                                                          Fired when a Model instance has been added to this Store. ...

                                                                                                                                                                                          Fired when a Model instance has been added to this Store.

                                                                                                                                                                                          Available since: 1.1.0

                                                                                                                                                                                          Parameters

                                                                                                                                                                                          ( store, operation, eOpts )
                                                                                                                                                                                          Fires before a request is made for a new data object. ...

                                                                                                                                                                                          Fires before a request is made for a new data object. If the beforeload handler returns false the load action will be canceled.

                                                                                                                                                                                          Available since: 1.1.0

                                                                                                                                                                                          Parameters

                                                                                                                                                                                          Ext.data.Store
                                                                                                                                                                                          view source
                                                                                                                                                                                          ( this, operation, eOpts )
                                                                                                                                                                                          Fires before a prefetch occurs. ...

                                                                                                                                                                                          Fires before a prefetch occurs. Return false to cancel.

                                                                                                                                                                                          Parameters

                                                                                                                                                                                          Fires before a store is sorted. ...

                                                                                                                                                                                          Fires before a store is sorted.

                                                                                                                                                                                          For remotely sorted stores, this will be just before the load operation triggered by changing the store's sorters.

                                                                                                                                                                                          For locally sorted stores, this will be just before the data items in the store's backing collection are sorted.

                                                                                                                                                                                          Parameters

                                                                                                                                                                                          Fired before a call to sync is executed. ...

                                                                                                                                                                                          Fired before a call to sync is executed. Return false from any listener to cancel the sync

                                                                                                                                                                                          Parameters

                                                                                                                                                                                          Fires when the beginUpdate method is called. ...

                                                                                                                                                                                          Fires when the beginUpdate method is called. Automatic synchronization as configured by the autoSync flag is deferred until the endUpdate method is called, so multiple mutations can be coalesced into one synchronization operation.

                                                                                                                                                                                          Parameters

                                                                                                                                                                                          Fired after the removeAll method is called. ...

                                                                                                                                                                                          Fired after the removeAll method is called.

                                                                                                                                                                                          Available since: 1.1.0

                                                                                                                                                                                          Parameters

                                                                                                                                                                                          Fires whenever records are added to or removed from the Store. ...

                                                                                                                                                                                          Fires whenever records are added to or removed from the Store.

                                                                                                                                                                                          To hook into modifications of records in this Store use the update event.

                                                                                                                                                                                          Available since: 1.1.0

                                                                                                                                                                                          Parameters

                                                                                                                                                                                          Fires when the endUpdate method is called. ...

                                                                                                                                                                                          Fires when the endUpdate method is called. Automatic synchronization as configured by the autoSync flag is deferred until the endUpdate method is called, so multiple mutations can be coalesced into one synchronization operation.

                                                                                                                                                                                          Parameters

                                                                                                                                                                                          Ext.data.Store
                                                                                                                                                                                          view source
                                                                                                                                                                                          ( store, filters, eOpts )
                                                                                                                                                                                          Fired whenever the filter set changes. ...

                                                                                                                                                                                          Fired whenever the filter set changes.

                                                                                                                                                                                          Parameters

                                                                                                                                                                                          Ext.data.Store
                                                                                                                                                                                          view source
                                                                                                                                                                                          ( store, grouper, eOpts )
                                                                                                                                                                                          Fired whenever the grouping in the grid changes. ...

                                                                                                                                                                                          Fired whenever the grouping in the grid changes.

                                                                                                                                                                                          Parameters

                                                                                                                                                                                          ( this, records, successful, eOpts )
                                                                                                                                                                                          Fires whenever the store reads data from a remote data source. ...

                                                                                                                                                                                          Fires whenever the store reads data from a remote data source.

                                                                                                                                                                                          Available since: 1.1.0

                                                                                                                                                                                          Parameters

                                                                                                                                                                                          Fires when this store's underlying reader (available via the proxy) provides new metadata. ...

                                                                                                                                                                                          Fires when this store's underlying reader (available via the proxy) provides new metadata. Metadata usually consists of new field definitions, but can include any configuration data required by an application, and can be processed as needed in the event handler. This event is currently only fired for JsonReaders.

                                                                                                                                                                                          Available since: 1.1.0

                                                                                                                                                                                          Parameters

                                                                                                                                                                                          Ext.data.Store
                                                                                                                                                                                          view source
                                                                                                                                                                                          ( this, records, successful, operation, eOpts )
                                                                                                                                                                                          Fires whenever records have been prefetched. ...

                                                                                                                                                                                          Fires whenever records have been prefetched.

                                                                                                                                                                                          Parameters

                                                                                                                                                                                          Fires when the data cache has changed in a bulk manner (e.g., it has been sorted, filtered, etc.) and a widget that i...

                                                                                                                                                                                          Fires when the data cache has changed in a bulk manner (e.g., it has been sorted, filtered, etc.) and a widget that is using this Store as a Record cache should refresh its view.

                                                                                                                                                                                          Parameters

                                                                                                                                                                                          ( store, records, index, isMove, eOpts )
                                                                                                                                                                                          Fired when one or more records have been removed from this Store. ...

                                                                                                                                                                                          Fired when one or more records have been removed from this Store.

                                                                                                                                                                                          The signature for this event has changed in 5.0:

                                                                                                                                                                                          Available since: 5.0.0

                                                                                                                                                                                          Parameters

                                                                                                                                                                                          • store : Ext.data.Store

                                                                                                                                                                                            The Store object

                                                                                                                                                                                          • records : Ext.data.Model[]

                                                                                                                                                                                            The records that were removed. In previous releases this was a single record, not an array.

                                                                                                                                                                                          • index : Number

                                                                                                                                                                                            The index at which the records were removed.

                                                                                                                                                                                          • isMove : Boolean

                                                                                                                                                                                            true if the child node is being removed so it can be moved to another position in this Store.

                                                                                                                                                                                          • eOpts : Object

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

                                                                                                                                                                                          Fires after a store is sorted. ...

                                                                                                                                                                                          Fires after a store is sorted.

                                                                                                                                                                                          For remotely sorted stores, this will be upon the success of a load operation triggered by changing the store's sorters.

                                                                                                                                                                                          For locally sorted stores, this will be just after the data items in the store's backing collection are sorted.

                                                                                                                                                                                          Parameters

                                                                                                                                                                                          ( this, record, operation, modifiedFieldNames, details, eOpts )
                                                                                                                                                                                          Fires when a Model instance has been updated. ...

                                                                                                                                                                                          Fires when a Model instance has been updated.

                                                                                                                                                                                          Available since: 1.1.0

                                                                                                                                                                                          Parameters

                                                                                                                                                                                          ( store, operation, eOpts )
                                                                                                                                                                                          Fires whenever a successful write has been made via the configured Proxy ...

                                                                                                                                                                                          Fires whenever a successful write has been made via the configured Proxy

                                                                                                                                                                                          Available since: 3.4.0

                                                                                                                                                                                          Parameters