Many classes have shortcut names used when creating (instantiating) a class with a
configuration object. The shortcut name is referred to as an alias (or xtype if the
class extends Ext.Component). The alias/xtype is listed next to the class name of
applicable classes for quick reference.
Framework classes or their members may be specified as private or protected. Else,
the class / member is public. Public, protected, and private are access
descriptors used to convey how and when the class or class member should be used.
Public classes and class members are available for use by any other class or application code and may be relied upon as a stable and persistent within major product versions. Public classes and members may safely be extended via a subclass.
Protected class members are stable public members intended to be used by the
owning class or its subclasses. Protected members may safely be extended via a subclass.
Private classes and class members are used internally by the framework and are not intended to be used by application developers. Private classes and members may change or be omitted from the framework at any time without notice and should not be relied upon in application logic.
static label next to the
method name. *See Static below.Below is an example class member that we can disect to show the syntax of a class member (the lookupComponent method as viewed from the Ext.button.Button class in this case).
Let's look at each part of the member row:
lookupComponent in this example)( item ) in this example)Ext.Component in this case). This may be omitted for methods that do not
return anything other than undefined or may display as multiple possible values
separated by a forward slash / signifying that what is returned may depend on the
results of the method call (i.e. a method may return a Component if a get method calls is
successful or false if unsuccessful which would be displayed as
Ext.Component/Boolean).PROTECTED in
this example - see the Flags section below)Ext.container.Container in this example). The source
class will be displayed as a blue link if the member originates from the current class
and gray if it is inherited from an ancestor or mixed-in class.view source in the example)item : Object in the example).undefined a "Returns" section
will note the type of class or object returned and a description (Ext.Component in the
example)Available since 3.4.0 - not pictured in
the example) just after the member descriptionDefaults to: false)The API documentation uses a number of flags to further commnicate the class member's function and intent. The label may be represented by a text label, an abbreviation, or an icon.
classInstance.method1().method2().etc();false is returned from
an event handler- Indicates a framework class
- A singleton framework class. *See the singleton flag for more information
- A component-type framework class (any class within the Ext JS framework that extends Ext.Component)
- Indicates that the class, member, or guide is new in the currently viewed version
- Indicates a class member of type config
- Indicates a class member of type property
- Indicates a class member of type
method
- Indicates a class member of type event
- Indicates a class member of type
theme variable
- Indicates a class member of type
theme mixin
- Indicates that the class, member, or guide is new in the currently viewed version
Just below the class name on an API doc page is a row of buttons corresponding to the types of members owned by the current class. Each button shows a count of members by type (this count is updated as filters are applied). Clicking the button will navigate you to that member section. Hovering over the member-type button will reveal a popup menu of all members of that type for quick navigation.
Getting and setter methods that correlate to a class config option will show up in the methods section as well as in the configs section of both the API doc and the member-type menus just beneath the config they work with. The getter and setter method documentation will be found in the config row for easy reference.
Your page history is kept in localstorage and displayed (using the available real estate) just below the top title bar. By default, the only search results shown are the pages matching the product / version you're currently viewing. You can expand what is displayed by clicking on the button on the right-hand side of the history bar and choosing the "All" radio option. This will show all recent pages in the history bar for all products / versions.
Within the history config menu you will also see a listing of your recent page visits. The results are filtered by the "Current Product / Version" and "All" radio options. Clicking on the button will clear the history bar as well as the history kept in local storage.
If "All" is selected in the history config menu the checkbox option for "Show product details in the history bar" will be enabled. When checked, the product/version for each historic page will show alongside the page name in the history bar. Hovering the cursor over the page names in the history bar will also show the product/version as a tooltip.
Both API docs and guides can be searched for using the search field at the top of the page.
On API doc pages there is also a filter input field that filters the member rows using the filter string. In addition to filtering by string you can filter the class members by access level, inheritance, and read only. This is done using the checkboxes at the top of the page.
The checkbox at the bottom of the API class navigation tree filters the class list to include or exclude private classes.
Clicking on an empty search field will show your last 10 searches for quick navigation.
Each API doc page (with the exception of Javascript primitives pages) has a menu view of metadata relating to that class. This metadata view will have one or more of the following:
Ext.button.Button class has an alternate class name of Ext.Button). Alternate class
names are commonly maintained for backward compatibility.Runnable examples (Fiddles) are expanded on a page by default. You can collapse and expand example code blocks individually using the arrow on the top-left of the code block. You can also toggle the collapse state of all examples using the toggle button on the top-right of the page. The toggle-all state will be remembered between page loads.
Class members are collapsed on a page by default. You can expand and collapse members using the arrow icon on the left of the member row or globally using the expand / collapse all toggle button top-right.
Viewing the docs on narrower screens or browsers will result in a view optimized for a smaller form factor. The primary differences between the desktop and "mobile" view are:
The class source can be viewed by clicking on the class name at the top of an API doc page. The source for class members can be viewed by clicking on the "view source" link on the right-hand side of the member row.
A collection of useful static methods to deal with function callbacks.
Create an alias to the provided method property with name methodName of object.
Note that the execution scope will still be bound to the provided object itself.
object : Object/Function
methodName : String
aliasFn
Create a new function from the provided fn, change this to the provided scope,
optionally overrides arguments for the call. Defaults to the arguments passed by
the caller.
Ext.bind is alias for Ext.Function.bind
NOTE: This method is similar to the native bind() method. The major difference
is in the way the parameters are passed. This method expects an array of parameters,
and if supplied, it does not automatically pass forward parameters from the bound
function:
function foo (a, b, c) {
console.log(a, b, c);
}
var nativeFn = foo.bind(this, 1, 2);
var extFn = Ext.Function.bind(foo, this, [1, 2]);
nativeFn(3); // 1, 2, 3
extFn(3); // 1, 2, undefined
This method is unavailable natively on IE8 and IE/Quirks but Ext JS provides a
"polyfill" to emulate the important features of the standard bind method. In
particular, the polyfill only provides binding of "this" and optional arguments.
fn : Function
The function to delegate.
scope : Object (optional)
The scope (this reference) in which the function
is executed.
If omitted, defaults to the global environment object (usually the browser window).
args : Array (optional)
Overrides arguments for the call. (Defaults to the arguments passed by the caller).
appendArgs : Boolean/Number (optional)
if true the args are appended to the
arguments passed to the returned wrapper (by default these arguments are ignored).
If a number then the args are inserted at the specified position.
The bound wrapper function.
Captures the given parameters for a later call to Ext.callback. This binding is
most useful for resolving scopes for example to an Ext.app.ViewController.
The arguments match that of Ext.callback except for the args which, if provided
to this method, are prepended to any arguments supplied by the eventual caller of
the returned function.
Available since: 5.0.0
callback : Object
scope : Object
args : Object
delay : Object
caller : Object
A function that, when called, uses Ext.callback to call the
captured callback.
Create a "clone" of the provided method. The returned method will call the given method passing along all arguments and the "this" pointer and return its result.
method : Function
cloneFn
Creates a wrapped function that, when invoked, defers execution until the next animation frame
fn : Function
The function to call.
scope : Object (optional)
The scope (this reference) in which the function is executed.
Defaults to the window object.
args : Array (optional)
The argument list to pass to the function.
queueStrategy : Number (optional)
A bit flag that indicates how multiple calls to the returned function within the same animation frame should be handled.
Defaults to: 3
Wraps the passed function in a barrier function which will call the passed function after the passed number of invocations.
count : Number
The number of invocations which will result in the calling of the passed function.
fn : Function
The function to call after the required number of invocations.
scope : Object
The scope (this reference) in which the function will be called.
Creates a delegate function, optionally with a bound scope which, when called, buffers the execution of the passed function for the configured number of milliseconds. If called again within that period, the impending invocation will be canceled, and the timeout period will begin again.
fn : Function
The function to invoke on a buffered timer.
buffer : Number
The number of milliseconds by which to buffer the invocation of the function.
scope : Object (optional)
The scope (this reference) in which.
the passed function is executed. If omitted, defaults to the scope specified
by the caller.
args : Array (optional)
Override arguments for the call. Defaults to the arguments passed by the caller.
A function which invokes the passed function after buffering for the specified time.
Creates a delegate (callback) which, when called, executes after a specific delay.
fn : Function
The function which will be called on a delay when the returned function is called. Optionally, a replacement (or additional) argument list may be specified.
delay : Number
The number of milliseconds to defer execution by whenever called.
scope : Object (optional)
The scope (this reference) used by the function
at execution time.
args : Array (optional)
Override arguments for the call. (Defaults to the arguments passed by the caller)
appendArgs : Boolean/Number (optional)
if True args are appended to call args instead of overriding, if a number the args are inserted at the specified position.
A function which, when called, executes the original function after the specified delay.
Creates an interceptor function. The passed function is called before the original one. If it returns false, the original one is not called. The resulting function returns the results of the original function. The passed function is called with the parameters of the original function. Example usage:
var sayHi = function(name){
alert('Hi, ' + name);
};
sayHi('Fred'); // alerts "Hi, Fred"
// create a new function that validates input without
// directly modifying the original function:
var sayHiToFriend = Ext.Function.createInterceptor(sayHi, function(name){
return name === 'Brian';
});
sayHiToFriend('Fred'); // no alert
sayHiToFriend('Brian'); // alerts "Hi, Brian"
origFn : Function
The original function.
newFn : Function
The function to call before the original.
scope : Object (optional)
The scope (this reference) in which the passed function
is executed. If omitted, defaults to the scope in which the original function
is called or the browser window.
returnValue : Object (optional)
The value to return if the passed function return
false.
Defaults to: null
The new function.
Create a combined function call sequence of the original function + the passed function. The resulting function returns the results of the original function. The passed function is called with the parameters of the original function. Example usage:
var sayHi = function(name){
alert('Hi, ' + name);
};
sayHi('Fred'); // alerts "Hi, Fred"
var sayGoodbye = Ext.Function.createSequence(sayHi, function(name){
alert('Bye, ' + name);
});
sayGoodbye('Fred'); // both alerts show
originalFn : Function
The original function.
newFn : Function
The function to sequence.
scope : Object (optional)
The scope (this reference) in which the passed function
is executed. If omitted, defaults to the scope in which the original function is called
or the default global environment object (usually the browser window).
The new function.
Creates a throttled version of the passed function which, when called repeatedly and rapidly, invokes the passed function only after a certain interval has elapsed since the previous invocation.
This is useful for wrapping functions which may be called repeatedly, such as a handler of a mouse move event when the processing is expensive.
fn : Function
The function to execute at a regular time interval.
interval : Number
The interval in milliseconds on which the passed function is executed.
scope : Object (optional)
The scope (this reference) in which
the passed function is executed. If omitted, defaults to the scope specified
by the caller.
A function which invokes the passed function at the specified interval.
Calls function fn after the number of milliseconds specified, optionally with
a specific scope (this pointer).
Example usage:
var sayHi = function(name) {
alert('Hi, ' + name);
}
// executes immediately:
sayHi('Fred');
// executes after 2 seconds:
Ext.defer(sayHi, 2000, this, ['Fred']);
The following syntax is useful for scheduling anonymous functions:
Ext.defer(function() {
alert('Anonymous');
}, 100);
NOTE: The Ext.Function.defer() method is an alias for Ext.defer().
fn : Function
The function to defer.
millis : Number
The number of milliseconds for the setTimeout call
(if less than or equal to 0 the function is executed immediately).
scope : Object (optional)
The scope (this reference) in which the function
is executed. If omitted, defaults to the browser window.
args : Array (optional)
Overrides arguments for the call. Defaults to the arguments passed by the caller.
appendArgs : Boolean/Number (optional)
If true args are appended to call args
instead of overriding, or, if a number, then the args are inserted at the specified
position.
Defaults to: false
The timeout id that can be used with Ext.undefer.
A very commonly used method throughout the framework. It acts as a wrapper around
another method which originally accepts 2 arguments for name and value.
The wrapped function then allows "flexible" value setting of either:
name and value as 2 argumentsFor example:
var setValue = Ext.Function.flexSetter(function(name, value) {
this[name] = value;
});
// Afterwards
// Setting a single name - value
setValue('name1', 'value1');
// Settings multiple name - value pairs
setValue({
name1: 'value1',
name2: 'value2',
name3: 'value3'
});
setter : Function
The single value setter method.
Adds behavior to an existing method that is executed after the original behavior of the function. For example:
var soup = {
contents: [],
add: function(ingredient) {
this.contents.push(ingredient);
}
};
Ext.Function.interceptAfter(soup, "add", function(ingredient){
// Always add a bit of extra salt
this.contents.push("salt");
});
soup.add("water");
soup.add("onions");
soup.contents; // will contain: water, salt, onions, salt
object : Object
The target object
methodName : String
Name of the method to override
fn : Function
Function with the new behavior. It will be called with the same arguments as the original method. The return value of this function will be the return value of the new method.
scope : Object (optional)
The scope to execute the interceptor function. Defaults to the object.
The new function just created.
Adds behavior to an existing method that is executed before the original behavior of the function. For example:
var soup = {
contents: [],
add: function(ingredient) {
this.contents.push(ingredient);
}
};
Ext.Function.interceptBefore(soup, "add", function(ingredient){
if (!this.contents.length && ingredient !== "water") {
// Always add water to start with
this.contents.push("water");
}
});
soup.add("onions");
soup.add("salt");
soup.contents; // will contain: water, onions, salt
object : Object
The target object
methodName : String
Name of the method to override
fn : Function
Function with the new behavior. It will be called with the same arguments as the original method. The return value of this function will be the return value of the new method.
scope : Object (optional)
The scope to execute the interceptor function. Defaults to the object.
The new function just created.
Calls the function fn repeatedly at a given interval, optionally with a
specific scope (this pointer).
var sayHi = function(name) {
console.log('Hi, ' + name);
}
// executes every 2 seconds:
var timerId = Ext.interval(sayHi, 2000, this, ['Fred']);
The timer is stopped by:
Ext.uninterval(timerId);
NOTE: The Ext.Function.interval() method is an alias for Ext.interval().
fn : Function
The function to defer.
millis : Number
The number of milliseconds for the setInterval call
scope : Object (optional)
The scope (this reference) in which the function
is executed. If omitted, defaults to the browser window.
args : Array (optional)
Overrides arguments for the call. Defaults to the arguments passed by the caller.
appendArgs : Boolean/Number (optional)
If true args are appended to call args
instead of overriding, or, if a number, then the args are inserted at the specified
position.
Defaults to: false
The interval id that can be used with Ext.uninterval.
Returns a wrapper function that caches the return value for previously processed function argument(s).
For example:
function factorial (value) {
var ret = value;
while (--value > 1) {
ret *= value;
}
return ret;
}
Each call to factorial will loop and multiply to produce the answer. Using
this function we can wrap the above and cache its answers:
factorial = Ext.Function.memoize(factorial);
The returned function operates in the same manner as before, but results are stored in a cache to avoid calling the wrapped function when given the same arguments.
var x = factorial(20); // first time; call real factorial()
var y = factorial(20); // second time; return value from first call
To support multi-argument methods, you will need to provide a hashFn.
function permutation (n, k) {
return factorial(n) / factorial(n - k);
}
permutation = Ext.Function.memoize(permutation, null, function(n, k) {
n + '-' + k;
});
In this case, the memoize of factorial is sufficient optimization, but the
example is simply to illustrate how to generate a unique key for an expensive,
multi-argument method.
IMPORTANT: This cache is unbounded so be cautious of memory leaks if the
memoized function is kept indefinitely or is given an unbounded set of
possible arguments.
Available since: 6.0.0
fn : Function
Function to wrap.
scope : Object
Optional scope in which to execute the wrapped function.
hashFn : Function
Optional function used to compute a hash key for storing the result, based on the arguments to the original function.
The caching wrapper function.
Create a new function from the provided fn, the arguments of which are pre-set
to args. New arguments passed to the newly created callback when it's invoked
are appended after the pre-set ones.
This is especially useful when creating callbacks.
For example:
var originalFunction = function(){
alert(Ext.Array.from(arguments).join(' '));
};
var callback = Ext.Function.pass(originalFunction, ['Hello', 'World']);
callback(); // alerts 'Hello World'
callback('by Me'); // alerts 'Hello World by Me'
Ext.pass is alias for Ext.Function.pass
fn : Function
The original function.
args : Array
The arguments to pass to new callback.
scope : Object (optional)
The scope (this reference) in which the function
is executed.
The new callback function.
Schedules the passed function to be called on the next animation frame.
fn : Function
The function to call.
scope : Object (optional)
The scope (this reference) in which the function is executed.
Defaults to the window object.
args : Mixed[] (optional)
The argument list to pass to the function.
Timer id for the new animation frame to use when canceling it.
Ext JS | Terms of Use