The documentation for the ExtReact product diverges somewhat from the
documentation of other Sencha products. The sections below describe
documentation for all products except where indicated as unique to
ExtReact.
Many classes have shortcut names used when creating (instantiating) a class with a
configuration object. The shortcut name is referred to as an alias (or xtype if the
class extends Ext.Component). The alias/xtype is listed next to the class name of
applicable classes for quick reference.
ExtReact component classes list the configurable name prominently at the top of the API class doc followed by the fully-qualified class name.
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.
ExtReact component classes display
configuration options as props
ExtReact component classes do not list
properties as a dedicated member type, but rather as
read only props
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.
All ExtReact props are bindable
unless decorated as immutable
Immutable ExtReact props may not be use as a configurable prop when instantiating a component
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
Or in the case of an ExtReact component class this
indicates a member of type prop
- Indicates a class member of type property
- Indicates a class member of type
method
- Indicates a class member of type event
- Indicates a class member of type
theme variable
- Indicates a class member of type
theme mixin
- Indicates that the class, member, or guide is new in the currently viewed version
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.
ExtReact component classes do not hoist the getter /
setter methods into the prop. All methods will be described in the
Methods section
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 flyweight Ext.dom.Element that can be dynamically attached to a DOM node. In general this class should not be instantiated directly. Use Ext#fly to create and retrieve Fly instances.
The value true causes config values to be stored on instances using a
property name prefixed with an underscore ("_") character. A value of false
stores config values as properties using their exact name (no prefix).
Defaults to:
true
Available since: 5.0.0
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
A prototype-chained object storing transform method names and priorities stored on the class prototype. On first instantiation, this object is converted into an array that is sorted by priority and stored on the constructor.
Defaults to:
{}
Matches options property names within a listeners specification object - property names which are never used as event names.
Defaults to:
{
scope: 1,
delay: 1,
buffer: 1,
onFrame: 1,
single: 1,
args: 1,
destroyable: 1,
priority: 1,
order: 1
}
We don't want the base destructor to clear the prototype because our destroyObservable handler must be called the very last. It will take care of the prototype after completing Observable destruction sequence.
Defaults to:
true
true indicates an id was auto-generated rather than provided by configuration.
Defaults to:
false
Available since: 6.7.0
Setting this property to false will prevent nulling object references
on a Class instance after destruction. Setting this to "async" will delay
the clearing for approx 50ms.
Defaults to:
true
Available since: 6.2.0
Setting this property to true will result in setting the object's
prototype to null after the destruction sequence is fully completed.
After that, most attempts at calling methods on the object instance
will result in "method not defined" exception. This can be very helpful
with tracking down otherwise hard to find bugs like runaway Ajax requests,
timed functions not cleared on destruction, etc.
Note that this option can only work in browsers that support Object.setPrototypeOf
method, and is only available in debugging mode.
Defaults to:
false
Available since: 6.2.0
A reference to the Component that owns this element. This is null if there
is no direct owner.
This property is set to true after the destroy method is called.
Defaults to:
false
Initial suspended call count. Incremented when suspendEvents is called, decremented when resumeEvents is called.
Defaults to:
0
This object holds a key for any event that has a listener. The listener may be set directly on the instance, or on its class or a super class (via observe) or on the Ext.app.EventBus. The values of this object are truthy (a non-zero number) and falsy (0 or undefined). They do not represent an exact count of listeners. The value for an event is truthy if the event must be fired and is falsy if there is no need to fire the event.
The intended use of this property is to avoid the expense of fireEvent calls when there are no listeners. This can be particularly helpful when one would otherwise have to call fireEvent hundreds or thousands of times. It is used like this:
if (this.hasListeners.foo) {
this.fireEvent('foo', this, arg1);
}
This property is set to true during the call to initConfig.
Defaults to:
false
Available since: 5.0.0
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.
Defaults to:
true
true in this class to identify an object as an instantiated Observable, or subclass
thereof.
Defaults to:
true
Get the reference to the current class from which this object was instantiated. Unlike
Ext.Base#statics, this.self is scope-dependent and it's meant to be used
for dynamic inheritance. See Ext.Base#statics for a detailed comparison
Ext.define('My.Cat', {
statics: {
speciesName: 'Cat' // My.Cat.speciesName = 'Cat'
},
constructor: function() {
alert(this.self.speciesName); // dependent on 'this'
},
clone: function() {
return new this.self();
}
});
Ext.define('My.SnowLeopard', {
extend: 'My.Cat',
statics: {
speciesName: 'Snow Leopard' // My.SnowLeopard.speciesName = 'Snow Leopard'
}
});
var cat = new My.Cat(); // alerts 'Cat'
var snowLeopard = new My.SnowLeopard(); // alerts 'Snow Leopard'
var clone = snowLeopard.clone();
alert(Ext.getClassName(clone)); // alerts 'My.SnowLeopard'
Defaults to:
Base
Visibility mode constant for use with Ext.dom.Element#setVisibilityMode.
Use CSS clip property to reduce element's dimensions to 0px by 0px, effectively
making it hidden while not being truly invisible. This is useful when an element
needs to be published to the Assistive Technologies such as screen readers.
Defaults to:
4
Visibility mode constant for use with Ext.dom.Element#setVisibilityMode. Use the CSS 'display' property to hide the element.
Defaults to:
2
This property indicates a minimum threshold of vertical resize movement for virtual keyboard detection.
On some mobile browsers the framework needs to keep track of whether window resize events were triggered by the opening or closing of a virtual keyboard so that it can prevent unnecessary re-layout of the viewport. It does this by detecting resize events in the horizontal direction that occur immediately after an editable element is focused or blurred.
Defaults to:
100
Visibility mode constant for use with Ext.dom.Element#setVisibilityMode. Use CSS absolute positioning and top/left offsets to hide the element.
Defaults to:
3
Visibility mode constant for use with Ext.dom.Element#setVisibilityMode.
Use CSS opacity property to reduce element's opacity to 0
Defaults to:
5
True to globally disable the delegated event system. The results of setting this to false are unpredictable since the Gesture publisher relies on delegated events in order to work correctly. Disabling delegated events may cause Gestures to function incorrectly or to stop working completely. Use at your own risk!
Defaults to:
true
The list of valid nodeTypes that are allowed to be wrapped
Defaults to:
{
1: 1,
// ELEMENT_NODE
9: 1
}
Visibility mode constant for use with Ext.dom.Element#setVisibilityMode. Use the CSS 'visibility' property to hide the element.
Note that in this mode, isVisible may return true for an element even though it actually has a parent element that is hidden. For this reason, and in most cases, using the OFFSETS mode is a better choice.
Defaults to:
1
Adds declarative listeners as nested arrays of listener objects.
listeners : Array
true if any listeners were added
Returns the publisher for a given event
eventName : String
noTranslate : Boolean (optional)
true if the event is a non translated event
Adds the given CSS class(es) to this Element.
names : String/String[]
The CSS classes to add separated by space, or an array of classes
prefix : String (optional)
Prefix to prepend to each class. The separator - will be
appended to the prefix.
suffix : String (optional)
Suffix to append to each class. The separator - will be
prepended to the suffix.
this
Sets up event handlers to add and remove a css class when the mouse is down and then up on this element (a click effect)
className : String
The class to add
testFn : Function (optional)
A test function to execute before adding the class. The passed parameter will be the Element instance. If this functions returns false, the class will not be added.
scope : Object (optional)
The scope to execute the testFn in.
this
Sets up event handlers to add and remove a css class when this element has the focus
className : String
The class to add
testFn : Function (optional)
A test function to execute before adding the class. The passed parameter will be the Element instance. If this functions returns false, the class will not be added.
scope : Object (optional)
The scope to execute the testFn in.
this
Sets up event handlers to add and remove a css class when the mouse is over this element
className : String
The class to add
testFn : Function (optional)
A test function to execute before adding the class. The passed parameter will be the Element instance. If this functions returns false, the class will not be added.
scope : Object (optional)
The scope to execute the testFn in.
this
This method applies a versioned, deprecation declaration to this class. This
is typically called by the deprecated config.
deprecations : Object
The on method is shorthand for addListener.
Appends an event handler to this object. For example:
myGridPanel.on("itemclick", this.onItemClick, this);
The method also allows for a single argument to be passed which is a config object containing properties which specify multiple events. For example:
myGridPanel.on({
cellclick: this.onCellClick,
select: this.onSelect,
viewready: this.onViewReady,
scope: this // Important. Ensure "this" is correct during handler execution
});
One can also specify options for each event handler separately:
myGridPanel.on({
cellclick: {fn: this.onCellClick, scope: this, single: true},
viewready: {fn: panel.onViewReady, scope: panel}
});
Names of methods in a specified scope may also be used:
myGridPanel.on({
cellclick: {fn: 'onCellClick', scope: this, single: true},
viewready: {fn: 'onViewReady', scope: panel}
});
eventName : String/Object
The name of the event to listen for. May also be an object who's property names are event names.
fn : Function/String (optional)
The method the event invokes or the name of
the method within the specified scope. Will be called with arguments
given to Ext.util.Observable#fireEvent plus the options parameter described
below.
scope : Object (optional)
The scope (this reference) in which the handler function is
executed. If omitted, defaults to the object which fired the event.
options : Object (optional)
An object containing handler configuration.
Note: The options object will also be passed as the last argument to every event handler.
This object may contain any of the following properties:
scope : Object
The scope (this reference) in which the handler function is executed. If omitted,
defaults to the object which fired the event.
delay : Number
The number of milliseconds to delay the invocation of the handler after the event fires.
single : Boolean
True to add a handler to handle just the next firing of the event, and then remove itself.
buffer : Number
Causes the handler to be scheduled to run in an Ext.util.DelayedTask delayed by the specified number of milliseconds. If the event fires again within that time, the original handler is not invoked, but the new handler is scheduled in its place.
onFrame : Number
Causes the handler to be scheduled to run at the next animation frame event. If the event fires again before that time, the handler is not rescheduled - the handler will only be called once when the next animation frame is fired, with the last set of arguments passed.
target : Ext.util.Observable
Only call the handler if the event was fired on the target Observable, not if the event was bubbled up from a child Observable.
element : String
This option is only valid for listeners bound to <ExtComponent/>. The name of a Component property which references an Ext.dom.Element to add a listener to.
This option is useful during Component construction to add DOM event listeners to elements of <ExtComponent/> which will exist only after the Component is rendered.
For example, to add a click listener to a Panel's body:
var panel = new Ext.panel.Panel({
title: 'The title',
listeners: {
click: this.handlePanelClick,
element: 'body'
}
});
In order to remove listeners attached using the element, you'll need to reference the element itself as seen below.
panel.body.un(...)
delegate : String (optional)
A simple selector to filter the event target or look for a descendant of the target.
The "delegate" option is only available on Ext.dom.Element instances (or when attaching a listener to a Ext.dom.Element via a Component using the element option).
See the delegate example below.
capture : Boolean (optional)
When set to true, the listener is fired in the capture phase of the event propagation
sequence, instead of the default bubble phase.
The capture option is only available on Ext.dom.Element instances (or
when attaching a listener to a Ext.dom.Element via a Component using the
element option).
stopPropagation : Boolean (optional)
This option is only valid for listeners bound to Ext.dom.Element.
true to call stopPropagation on the event
object before firing the handler.
preventDefault : Boolean (optional)
This option is only valid for listeners bound to Ext.dom.Element.
true to call preventDefault on the event
object before firing the handler.
stopEvent : Boolean (optional)
This option is only valid for listeners bound to Ext.dom.Element.
true to call stopEvent on the event object
before firing the handler.
args : Array (optional)
Optional set of arguments to pass to the handler function before the actual
fired event arguments. For example, if args is set to ['foo', 42],
the event handler function will be called with an arguments list like this:
handler('foo', 42, <actual event arguments>...);
destroyable : Boolean (optional)
When specified as true, the function returns a destroyable object. An object
which implements the destroy method which removes all listeners added in this call.
This syntax can be a helpful shortcut to using un; particularly when
removing multiple listeners. NOTE - not compatible when using the element
option. See un for the proper syntax for removing listeners added using the
element config.
Defaults to:
false
priority : Number (optional)
An optional numeric priority that determines the order in which event handlers are run. Event handlers with no priority will be run as if they had a priority of 0. Handlers with a higher priority will be prioritized to run sooner than those with a lower priority. Negative numbers can be used to set a priority lower than the default. Internally, the framework uses a range of 1000 or greater, and -1000 or lesser for handlers that are intended to run before or after all others, so it is recommended to stay within the range of -999 to 999 when setting the priority of event handlers in application-level code. A priority must be an integer to be valid. Fractional values are reserved for internal framework use.
order : String (optional)
A legacy option that is provided for backward compatibility.
It is recommended to use the priority option instead. Available options are:
'before': equal to a priority of 100'current': equal to a priority of 0 or default priority'after': equal to a priority of -100Defaults to:
'current'
order : String (optional)
A shortcut for the order event option. Provided for backward compatibility.
Please use the priority event option instead.
Defaults to: 'current'
Only when the destroyable option is specified.
A Destroyable object. An object which implements the destroy method which removes
all listeners added in this call. For example:
this.btnListeners = = myButton.on({
destroyable: true
mouseover: function() { console.log('mouseover'); },
mouseout: function() { console.log('mouseout'); },
click: function() { console.log('click'); }
});
And when those listeners need to be removed:
Ext.destroy(this.btnListeners);
or
this.btnListeners.destroy();
The addManagedListener method is used when some object (call it "A") is listening to an event on another observable object ("B") and you want to remove that listener from "B" when "A" is destroyed. This is not an issue when "B" is destroyed because all of its listeners will be removed at that time.
Example:
Ext.define('Foo', {
extend: 'Ext.Component',
initComponent: function () {
this.addManagedListener(MyApp.SomeSharedMenu, 'show', this.doSomething);
this.callParent();
}
});
As you can see, when an instance of Foo is destroyed, it ensures that the 'show'
listener on the menu (MyApp.SomeGlobalSharedMenu) is also removed.
As of version 5.1 it is no longer necessary to use this method in most cases because
listeners are automatically managed if the scope object provided to
addListener is an Observable instance.
However, if the observable instance and scope are not the same object you
still need to use mon or addManagedListener if you want the listener to be
managed.
item : Ext.util.Observable/Ext.dom.Element
The item to which to add a listener/listeners.
ename : Object/String
The event name, or an object containing event name properties.
fn : Function/String (optional)
If the ename parameter was an event
name, this is the handler function or the name of a method on the specified
scope.
scope : Object (optional)
If the ename parameter was an event name, this is
the scope (this reference) in which the handler function is executed.
options : Object (optional)
If the ename parameter was an event name, this is
the addListener options.
Only when the destroyable option is specified.
A Destroyable object. An object which implements the destroy method which removes
all listeners added in this call. For example:
this.btnListeners = myButton.mon({
destroyable: true
mouseover: function() { console.log('mouseover'); },
mouseout: function() { console.log('mouseout'); },
click: function() { console.log('click'); }
});
And when those listeners need to be removed:
Ext.destroy(this.btnListeners);
or
this.btnListeners.destroy();
Aligns the element with another element relative to the specified anchor points. If the other element is the document it aligns it to the viewport. The position parameter is optional, and can be specified in any one of the following formats:
t/r/b/l) followed by a percentage along that side. This describes a
point to align with a similar point in the target. So 't0-b0' would be
the same as 'tl-bl', 'l0-r50' would place the top left corner of this item
halfway down the right edge of the target item. This allows more flexibility
and also describes which two edges are considered adjacent when positioning a tip pointer.Following are all of the supported predefined anchor positions:
Value Description
----- -----------------------------
tl The top left corner
t The center of the top edge
tr The top right corner
l The center of the left edge
c The center
r The center of the right edge
bl The bottom left corner
b The center of the bottom edge
br The bottom right corner
You can put a '?' at the end of the alignment string to constrain the positioned element to the Ext.Viewport. The element will attempt to align as specified, but the position will be adjusted to constrain to the viewport if necessary. Note that the element being aligned might be swapped to align to a different position than that specified in order to enforce the viewport constraints.
Example Usage:
// align el to other-el using the default positioning
// ("tl-bl", non-constrained)
el.alignTo("other-el");
// align the top left corner of el with the top right corner of other-el
// (constrained to viewport)
el.alignTo("other-el", "tl-tr?");
// align the bottom right corner of el with the center left edge of other-el
el.alignTo("other-el", "br-l?");
// align the center of el with the bottom left corner of other-el and
// adjust the x position by -6 pixels (and the y position by 0)
el.alignTo("other-el", "c-bl", [-6, 0]);
// align the 25% point on the bottom edge of this el
// with the 75% point on the top edge of other-el.
el.alignTo("other-el", 'b25-t75');
element : Ext.util.Positionable/HTMLElement/String
The Positionable, HTMLElement, or id of the element to align to.
position : String (optional)
The position to align to
Defaults to: "tl-bl?"
offsets : Number[] (optional)
Offset the positioning by [x, y] Element animation config object
this
Appends the passed element(s) to this element
el : String/HTMLElement/Ext.dom.Element/Object
The id or element to insert or a DomHelper config
returnDom : Boolean (optional)
True to return the raw DOM element instead of Ext.dom.Element
Defaults to: false
The inserted Ext.dom.Element (or HTMLElement if returnDom is true).
Appends this element to the passed element.
el : String/HTMLElement/Ext.dom.Element
The new parent element. The id of the node, a DOM Node or an existing Element.
This element.
More flexible version of setStyle for setting style properties.
Styles in object form should be a valid DOM element style property. Valid style property names (along with the supported CSS version for each)
// <div id="my-el">Phineas Flynn</div>
var el = Ext.get('my-el');
el.applyStyles('color: white;');
el.applyStyles({
fontWeight: 'bold',
backgroundColor: 'gray',
padding: '10px'
});
el.applyStyles(function () {
if (name.initialConfig.html === 'Phineas Flynn') {
return 'font-style: italic;';
// OR return { fontStyle: 'italic' };
}
});
styles : String/Object/Function
A style specification string, e.g.
"width:100px", or object in the form {width:"100px"}, or a function which returns
such a specification.
this
Tries to blur the element. Any exceptions are caught and ignored.
this
When an element is moved around in the DOM, or is hidden using display:none, it loses
layout, and therefore all scroll positions of all descendant elements are lost.
This function caches them, and returns a function, which when run will restore the cached positions. In the following example, the Panel is moved from one Container to another which will cause it to lose all scroll positions:
var restoreScroll = myPanel.el.cacheScrollValues();
myOtherContainer.add(myPanel);
restoreScroll();
A function which will restore all descendant elements of this Element
to their scroll positions recorded when this function was executed. Be aware that the
returned function is a closure which has captured the scope of cacheScrollValues, so
take care to dereference it as soon as not needed - if is it is a var it will drop out
of scope, and the reference will be freed.
Calculates x,y coordinates specified by the anchor position on the element, adding extraX and extraY values.
anchor : String (optional)
The specified anchor position. See alignTo for details on supported anchor positions.
Defaults to: 'tl'
extraX : Number (optional)
value to be added to the x coordinate
extraY : Number (optional)
value to be added to the y coordinate
size : Object (optional)
An object containing the size to use for calculating anchor position {width: (target width), height: (target height)} (defaults to the element's current size)
[x, y] An array containing the element's x and y coordinates
Calculates the new [x,y] position to move this Positionable into a constrain region.
By default, this Positionable is constrained to be within the container it was added to, or the element it was rendered to.
Priority is given to constraining the top and left within the constraint.
An alternative constraint may be passed.
constrainTo : String/HTMLElement/Ext.dom.Element/Ext.util.Region (optional)
The Element or Ext.util.Region into which this Component is to be constrained. Defaults to the element into which this Positionable was rendered, or this Component's Ext.Component#constrainTo.
proposedPosition : Number[] (optional)
A proposed [X, Y] position to test for validity
and to coerce into constraints instead of using this Positionable's current position.
local : Boolean (optional)
The proposedPosition is local (relative to floatParent if a floating Component)
proposedSize : Number[] (optional)
A proposed [width, height] size to use when calculating
constraints instead of using this Positionable's current size.
If the element needs to be translated, the new [X, Y] position
within constraints if possible, giving priority to keeping the top and left edge
in the constrain region. Otherwise, false.
Call the original method that was previously overridden with Ext.Base#override
Ext.define('My.Cat', {
constructor: function() {
alert("I'm a cat!");
}
});
My.Cat.override({
constructor: function() {
alert("I'm going to be a cat!");
this.callOverridden();
alert("Meeeeoooowwww");
}
});
var kitty = new My.Cat(); // alerts "I'm going to be a cat!"
// alerts "I'm a cat!"
// alerts "Meeeeoooowwww"
args : Array/Arguments
The arguments, either an array or the arguments object
from the current method, for example: this.callOverridden(arguments)
Returns the result of calling the overridden method
Deprecated since version 4.1.0
Use method-callParent instead.
Call the "parent" method of the current method. That is the method previously overridden by derivation or by an override (see Ext#define).
Ext.define('My.Base', {
constructor: function(x) {
this.x = x;
},
statics: {
method: function(x) {
return x;
}
}
});
Ext.define('My.Derived', {
extend: 'My.Base',
constructor: function() {
this.callParent([21]);
}
});
var obj = new My.Derived();
alert(obj.x); // alerts 21
This can be used with an override as follows:
Ext.define('My.DerivedOverride', {
override: 'My.Derived',
constructor: function(x) {
this.callParent([x*2]); // calls original My.Derived constructor
}
});
var obj = new My.Derived();
alert(obj.x); // now alerts 42
This also works with static and private methods.
Ext.define('My.Derived2', {
extend: 'My.Base',
// privates: {
statics: {
method: function(x) {
return this.callParent([x*2]); // calls My.Base.method
}
}
});
alert(My.Base.method(10)); // alerts 10
alert(My.Derived2.method(10)); // alerts 20
Lastly, it also works with overridden static methods.
Ext.define('My.Derived2Override', {
override: 'My.Derived2',
// privates: {
statics: {
method: function(x) {
return this.callParent([x*2]); // calls My.Derived2.method
}
}
});
alert(My.Derived2.method(10); // now alerts 40
To override a method and replace it and also call the superclass method, use method-callSuper. This is often done to patch a method to fix a bug.
args : Array/Arguments
The arguments, either an array or the arguments object
from the current method, for example: this.callParent(arguments)
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 is often done to "patch" a method that contains a bug but for whatever reason cannot be fixed directly.
Consider:
Ext.define('Ext.some.Class', {
method: function() {
console.log('Good');
}
});
Ext.define('Ext.some.DerivedClass', {
extend: 'Ext.some.Class',
method: function() {
console.log('Bad');
// ... logic but with a bug ...
this.callParent();
}
});
To patch the bug in Ext.some.DerivedClass.method, the typical solution is to create an
override:
Ext.define('App.patches.DerivedClass', {
override: 'Ext.some.DerivedClass',
method: function() {
console.log('Fixed');
// ... logic but with bug fixed ...
this.callSuper();
}
});
The patch method cannot use method-callParent to call the superclass
method since that would call the overridden method containing the bug. In
other words, the above patch would only produce "Fixed" then "Good" in the
console log, whereas, using callParent would produce "Fixed" then "Bad"
then "Good".
args : Array/Arguments
The arguments, either an array or the arguments object
from the current method, for example: this.callSuper(arguments)
Returns the result of calling the superclass method
Centers the Element in either the viewport, or another Element.
centerIn : String/HTMLElement/Ext.dom.Element
element in which to center the element.
This element
Selects a single direct child based on the passed CSS selector (the selector should not contain an id).
selector : String
The CSS selector.
returnDom : Boolean (optional)
true to return the DOM node instead of
Ext.dom.Element.
Defaults to: false
The child Ext.dom.Element (or DOM node
if returnDom is true)
Clips this Component/Element to fit within the passed element's or component's view area
clippingEl : Ext.Component/Ext.dom.Element/Ext.util.Region
The Component or element or Region which should clip this element even if this element is outside the bounds of that region.
sides : Number
The sides to clip 1=top, 2=right, 4=bottom, 8=left.
This is to support components being clipped to their logical owner, such as a grid row editor when the row being edited scrolls out of sight. The editor should be clipped at the edge of the scrolling element.
Clone this element.
deep : Boolean (optional)
true if the children of the node should also be cloned.
Defaults to: false
returnDom : Boolean (optional)
true to return the DOM node instead of
Ext.dom.Element.
Defaults to: false
The newly cloned Ext.dom.Element (or DOM node
if returnDom is true).
Removes the element from the cache and removes listeners. Used for cleaning up orphaned elements after they have been removed from the dom. Similar to destroy except it assumes the element has already been removed from the dom.
Creates new Element directly by passing an id or the HTMLElement. This constructor should not be called directly. Always use Ext.get() or Ext#fly() instead.
In older versions of Ext JS and Sencha Touch this constructor checked to see if there was already an instance of this element in the cache and if so, returned the same instance. As of version 5 this behavior has been removed in order to avoid a redundant cache lookup since the most common path is for the Element constructor to be called from Ext.get(), which has already checked for a cache entry.
Correct way of creating a new Ext.dom.Element (or retrieving it from the cache):
var el = Ext.get('foo'); // by id
var el = Ext.get(document.getElementById('foo')); // by DOM reference
Incorrect way of creating a new Ext.dom.Element
var el = new Ext.dom.Element('foo');
For quick and easy access to Ext.dom.Element methods use a flyweight:
Ext.fly('foo').addCls('foo-hovered');
This simply attaches the DOM node with id='foo' to the global flyweight Element instance to avoid allocating an extra Ext.dom.Element instance. If, however, the Element instance has already been cached by a previous call to Ext.get(), then Ext.fly() will return the cached Element instance. For more info see Ext#fly.
dom : String/HTMLElement
Returns true if this element is an ancestor of the passed element, or is
the element.
element : String/HTMLElement/Ext.dom.Element
The dom element, Ext.dom.Element, or id (string) of the dom element to check.
True if this element is an ancestor of el or the el itself, else false
This function converts a legacy alignment string such as 't-b' into a pair of edge, offset objects which describe the alignment points of the two regions.
So tl-br becomes {myEdge:'t', offset:0}, {otherEdge:'b', offset:100}
This not only allows more flexibility in the alignment possibilities, but it also resolves any ambiguity as to chich two edges are desired to be adjacent if an anchor pointer is required.
posSpec : Object
Creates the passed DomHelper config and appends it to this element or optionally inserts it before the passed child element.
config : Object
DomHelper element config object. If no tag is specified (e.g., {tag:'input'}) then a div will be automatically generated with the specified attributes.
insertBefore : HTMLElement (optional)
a child element of this element
returnDom : Boolean (optional)
true to return the dom node instead of creating an Element
Defaults to: false
The new child element (or HTMLElement if returnDom is true)
Creates an event handling function which re-fires the event from this object as the passed event name.
newName : String
The name under which to re-fire the passed parameters.
beginEnd : Array (optional)
The caller can specify on which indices to slice.
Destroys this element by removing it from the cache, removing its DOM reference, and removing all of its event listeners.
Destroys member properties by name.
If a property name is the name of a config, the getter is not invoked, so if the config has not been initialized, nothing will be done.
The property will be destroyed, and the corrected name (if the property is a config
and config names are prefixed) will set to null in this object's dictionary.
args : String...
One or more names of the properties to destroy and remove from the object.
Continue to fire event.
eventName : String
args : Array
bubbles : Boolean
A scrollIntoView implementation for scrollIntoView/rtlScrollIntoView to call after current scrollX has been determined.
container : Object
hscroll : Object
animate : Object
highlight : Object
getScrollX : Object
scrollTo : Object
Selects a single child at any depth below this element based on the passed CSS selector (the selector should not contain an id).
Use getById if you need to get a reference to a child element via id.
selector : String
The CSS selector
returnDom : Boolean (optional)
true to return the DOM node instead of
Ext.dom.Element
Defaults to: false
The child Ext.dom.Element (or DOM node
if returnDom is true)
Enables events fired by this Observable to bubble up an owner hierarchy by calling
this.getBubbleTarget() if present. There is no implementation in the Observable
base class.
This is commonly used by Ext.Components to bubble events to owner Containers. See Ext.Component#getBubbleTarget. The default implementation in Ext.Component returns the Component's immediate owner. But if a known target is required, this can be overridden to access the required target more quickly.
Example:
Ext.define('Ext.overrides.form.field.Base', {
override: 'Ext.form.field.Base',
// Add functionality to Field's initComponent to enable
// the change event to bubble
initComponent: function () {
this.callParent();
this.enableBubble('change');
}
});
var myForm = Ext.create('Ext.form.Panel', {
title: 'User Details',
items: [{
...
}],
listeners: {
change: function() {
// Title goes red if form has been modified.
myForm.header.setStyle('color', 'red');
}
}
});
eventNames : String/String[]
The event name to bubble, or an Array of event names.
Enables a shadow element that will always display behind this element
options : Object (optional)
Configuration options for the shadow
mode : String (optional)
The shadow display mode. Supports the following options:
- `'sides'`: Shadow displays on both sides and bottom only
- `'frame'`: Shadow displays equally on all four sides
- `'drop'`: Traditional bottom-right drop shadow
- `'bottom'`: Shadow is offset to the bottom
Defaults to:
'sides'
animate : Boolean (optional)
true to animate the shadow while
the element is animating. By default the shadow will be hidden during animation.
Defaults to:
false
Enables an iframe shim for this element to keep windowed objects from showing through. The position, size, and visibility of the shim will be automatically synchronized as the position, size, and visibility of this Element are changed.
options : Object (optional)
Configuration options for the shim
The new Shim
Looks at this node and then at parent nodes for a match of the passed simple selector.
simpleSelector : String
The simple selector to test. See Ext.dom.Query for information about simple selectors.
limit : Number/String/HTMLElement/Ext.dom.Element (optional)
The max depth to search as a number or an element which causes the upward traversal to stop and is not considered for inclusion as the result. (defaults to 50 || document.documentElement)
returnEl : Boolean (optional)
True to return a Ext.dom.Element object instead of DOM node
Defaults to: false
The matching DOM node (or Ext.dom.Element if returnEl is true). Or null if no match was found.
Looks at parent nodes for a match of the passed simple selector.
simpleSelector : String
The simple selector to test. See Ext.dom.Query for information about simple selectors.
limit : Number/String/HTMLElement/Ext.dom.Element (optional)
The max depth to search as a number or an element which causes the upward traversal to stop and is not considered for inclusion as the result. (defaults to 50 || document.documentElement)
returnEl : Boolean (optional)
True to return a Ext.dom.Element object instead of DOM node
Defaults to: false
The matching DOM node (or Ext.dom.Element if returnEl is true). Or null if no match was found.
Fires the specified event with the passed parameters and executes a function (action).
By default, the action function will be executed after any "before" event handlers
(as specified using the order option of
addListener), but before any other
handlers are fired. This gives the "before" handlers an opportunity to
cancel the event by returning false, and prevent the action function from
being called.
The action can also be configured to run after normal handlers, but before any "after"
handlers (as specified using the order event option) by passing 'after'
as the order parameter. This configuration gives any event handlers except
for "after" handlers the opportunity to cancel the event and prevent the action
function from being called.
eventName : String
The name of the event to fire.
args : Array
Arguments to pass to handlers and to the action function.
fn : Function
The action function.
scope : Object (optional)
The scope (this reference) in which the handler function is
executed. If omitted, defaults to the object which fired the event.
options : Object (optional)
Event options for the action function. Accepts any
of the options of addListener
order : String (optional)
The order to call the action function relative
too the event handlers ('before' or 'after'). Note that this option is
simply used to sort the action function relative to the event handlers by "priority".
An order of 'before' is equivalent to a priority of 99.5, while an order of
'after' is equivalent to a priority of -99.5. See the priority option
of addListener for more details.
Defaults to: 'before'
Deprecated since version 5.5
Use fireEventedAction instead.
Fires the specified event with the passed parameters (minus the event name, plus
the options object passed to addListener).
An event may be set to bubble up an Observable parent hierarchy (See Ext.Component#getBubbleTarget) by calling enableBubble.
eventName : String
The name of the event to fire.
args : Object...
Variable number of parameters are passed to handlers.
returns false if any of the handlers return false otherwise it returns true.
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.
eventName : String
The name of the event to fire.
args : Object[]
An array of parameters which are passed to handlers.
returns false if any of the handlers return false otherwise it returns true.
Fires the specified event with the passed parameters and executes a function (action). Evented Actions will automatically dispatch a 'before' event passing. This event will be given a special controller that allows for pausing/resuming of the event flow.
By pausing the controller the updater and events will not run until resumed. Pausing, however, will not stop the processing of any other before events.
eventName : String
The name of the event to fire.
args : Array
Arguments to pass to handlers and to the action function.
fn : Function/String
The action function.
scope : Object (optional)
The scope (this reference) in which the handler function is
executed. If omitted, defaults to the object which fired the event.
fnArgs : Array/Boolean (optional)
Optional arguments for the action fn. If not
given, the normal args will be used to call fn. If false is passed, the
args are used but if the first argument is this instance it will be removed
from the args passed to the action function.
Gets the first child, skipping text nodes
selector : String (optional)
Find the next sibling that matches the passed simple selector. See Ext.dom.Query for information about simple selectors.
returnDom : Boolean (optional)
true to return a raw DOM node instead of
an Ext.dom.Element
Defaults to: false
The first child or null
Try to focus the element either immediately or after a timeout
if defer argument is specified.
defer : Number (optional)
Milliseconds to defer the focus
this
Gets the x,y coordinates to align this element with another element. See alignTo for more info on the supported position values.
alignToEl : Ext.util.Positionable/HTMLElement/String
The Positionable, HTMLElement, or id of the element to align to.
position : String (optional)
The position to align to
Defaults to: "tl-bl?"
offsets : Number[] (optional)
Offset the positioning by [x, y]
[x, y]
Gets the x,y coordinates of an element specified by the anchor position on the element.
el : Ext.dom.Element
The element
anchor : String (optional)
The specified anchor position. See alignTo for details on supported anchor positions.
Defaults to: 'tl'
local : Boolean (optional)
True to get the local (element top/left-relative) anchor position instead of page coordinates
size : Object (optional)
An object containing the size to use for calculating anchor position {width: (target width), height: (target height)} (defaults to the element's current size)
[x, y] An array containing the element's x and y coordinates
Gets the x,y coordinates specified by the anchor position on the element.
anchor : String (optional)
The specified anchor position. See alignTo for details on supported anchor positions.
Defaults to: 'tl'
local : Boolean (optional)
True to get the local (element top/left-relative) anchor position instead of page coordinates
size : Object (optional)
An object containing the size to use for calculating anchor position {width: (target width), height: (target height)} (defaults to the element's current size)
[x, y] An array containing the element's x and y coordinates
Returns the value of an attribute from the element's underlying DOM node.
name : String
The attribute name.
namespace : String (optional)
The namespace in which to look for the attribute.
The attribute value.
Returns an object containing a map of all attributes of this element's DOM node.
Key/value pairs of attribute names and their values.
Returns the size of the element's borders and padding.
an object with the following numeric properties
Gets the width of the border(s) for the specified side(s)
side : String
Can be t, l, r, b or any combination of those to add
multiple values. For example, passing 'lr' would get the border left
width + the border right width.
The width of the sides passed added together
Gets the bottom Y coordinate of the element (element Y position + element height)
local : Boolean
True to get the local css position instead of page coordinate
Return an object defining the area of this Element which can be passed to setBox to set another Element's size/location to match this element.
contentBox : Boolean (optional)
If true a box for the content of the element is returned.
local : Boolean (optional)
If true the element's left and top relative to its
offsetParent are returned instead of page x/y.
An object in the format
Gets the bubbling parent for an Observable
The bubble parent. null is returned if no bubble target exists
Returns a child element of this element given its id.
id : String
The id of the desired child element.
asDom : Boolean (optional)
True to return the DOM element, false to return a wrapped Element object.
Defaults to: false
The child element (or HTMLElement if asDom is true). Or null if no match was found.
Returns an object holding as properties this element's CSS classes. The object
can be modified to effect arbitrary class manipulations that won't immediately
go to the DOM. When completed, the DOM node can be updated by calling
setClassMap. The values of the properties should either
be set to truthy values (such as 1 or true) or removed via delete.
var classes = el.getClassMap();
// Add the 'foo' class:
classes.foo = 1;
// Remove the 'bar' class:
delete classes.bar;
// Update the DOM in one step:
el.setClassMap(classes);
Available since: 6.5.0
Returns a region object that defines the client area of this element.
That is, the area within any scrollbars.
A Region containing "top, left, bottom, right" properties.
Returns a specified config property value. If the name parameter is not passed, all current configuration options will be returned as key value pairs.
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
ifInitialized : Boolean (optional)
true to only return the initialized property
value, not the raw config value, and not to trigger initialization. Returns
undefined if the property has not yet been initialized.
Defaults to: false
The config property value.
Returns the content region of this element for purposes of constraining or clipping floating children. That is the region within the borders and scrollbars, but not within the padding.
A Region containing "top, left, bottom, right" properties.
Returns the [X, Y] vector by which this Positionable's element must be translated to make
a best attempt to constrain within the passed constraint. Returns false if the element
does not need to be moved.
Priority is given to constraining the top and left within the constraint.
The constraint may either be an existing element into which the element is to be constrained, or a Ext.util.Region into which this element is to be constrained.
By default, any extra shadow around the element is not included in the constrain
calculations - the edges of the element are used as the element bounds. To constrain
the shadow within the constrain region, set the constrainShadow property on this element
to true.
constrainTo : Ext.util.Positionable/HTMLElement/String/Ext.util.Region (optional)
The Positionable, HTMLElement, element id, or Region into which the element is to be constrained.
proposedPosition : Number[] (optional)
A proposed [X, Y] position to test for validity
and to produce a vector for instead of using the element's current position
proposedSize : Number[] (optional)
A proposed [width, height] size to constrain
instead of using the element's current size
If the element needs to be translated, an [X, Y]
vector by which this element must be translated. Otherwise, false.
Returns this element's data object. This object holds options that may be
needed by an Ext.fly() call when there is no (cached) Ext.dom.Element
instance tracked.
This method will only return null if this instance has no associated DOM
node. If the DOM node does not have a data object, one will be created. To
avoid this creation, use peekData() instead.
Returns the innerHTML of an Element or an empty string if the element's
dom no longer exists.
Deprecated since version 5.0.0
Please use getHtml instead.
Returns the offset height of the element.
contentHeight : Boolean (optional)
true to get the height minus borders and padding.
preciseHeight : Boolean (optional)
true to get the precise height
The element's height.
Returns the innerHTML of an Element or an empty string if the element's
dom no longer exists.
Retrieves the id. This method Will auto-generate an id if one has not already
been configured.
id
Returns the initial configuration passed to the constructor when instantiating this class.
Given this example Ext.button.Button definition and instance:
Ext.define('MyApp.view.Button', {
extend: 'Ext.button.Button',
xtype: 'mybutton',
scale: 'large',
enableToggle: true
});
var btn = Ext.create({
xtype: 'mybutton',
renderTo: Ext.getBody(),
text: 'Test Button'
});
Calling btn.getInitialConfig() would return an object including the config
options passed to the create method:
xtype: 'mybutton',
renderTo: // The document body itself
text: 'Test Button'
Calling btn.getInitialConfig('text')returns 'Test Button'.
name : String (optional)
Name of the config option to return.
The full config object or a single config value
when name parameter specified.
Gets the left X coordinate
local : Boolean
True to get the local css position instead of page coordinate
Returns the x coordinate of this element reletive to its offsetParent.
The local x coordinate
Returns the x and y coordinates of this element relative to its offsetParent.
The local XY position of the element
Returns the y coordinate of this element reletive to its offsetParent.
The local y coordinate
Returns an object with properties top, left, right and bottom representing the margins of this element unless sides is passed, then it returns the calculated width of the sides (see getPadding).
sides : String (optional)
Any combination of 'l', 'r', 't', 'b' to get the sum of those sides.
Returns the offsets of this element from the passed element. The element must both be part of the DOM tree and not have display:none to have page coordinates.
offsetsTo : Ext.util.Positionable/HTMLElement/String
The Positionable, HTMLElement, or element id to get get the offsets from.
The XY page offsets (e.g. [100, -200])
Gets the width of the padding(s) for the specified side(s).
side : String
Can be t, l, r, b or any combination of those to add
multiple values. For example, passing 'lr' would get the padding left +
the padding right.
The padding of the sides passed added together.
Returns an object defining the area of this Element which can be passed to Ext.util.Positionable#setBox to set another Element's size/location to match this element.
getRegion : Boolean (optional)
If true an Ext.util.Region will be returned
box An object in the following format:
{
left: <Element's X position>,
top: <Element's Y position>,
width: <Element's width>,
height: <Element's height>,
bottom: <Element's lower bound>,
right: <Element's rightmost bound>
}
The returned object may also be addressed as an Array where index 0 contains the X position and index 1 contains the Y position. So the result may also be used for setXY
Deprecated since version 5.0.0
use Ext.util.Positionable#getBox to get a box
object, and Ext.util.Positionable#getRegion to get a
Ext.util.Region.
Returns a region object that defines the area of this element.
contentBox : Boolean (optional)
If true a box for the content of the element is returned.
local : Boolean (optional)
If true the element's left and top relative to its
offsetParent are returned instead of page x/y.
A Region containing "top, left, bottom, right" properties.
Gets the right X coordinate of the element (element X position + element width)
local : Boolean
True to get the local css position instead of page coordinates
Returns the current scroll position of the element.
An object containing the scroll position in the format
{left: (scrollLeft), top: (scrollTop)}
Gets the x and y coordinates needed for scrolling an element into view within a given container. These coordinates translate into the scrollLeft and scrollTop positions that will need to be set on an ancestor of the element in order to make this element visible within its container.
container : String/HTMLElement/Ext.dom.Element/Ext.util.Region
The container
scrollX : Number
The container's current scroll position on the x axis
scrollY : Number
The container's current scroll position on the y axis
align : Object (optional)
The alignment for the scroll.
x : 'start' / 'center' / 'end' (optional)
The alignment of the x scroll. If not specified, the minimum will be done to make the element visible. The behavior is undefined if the request cannot be honored. If the alignment is suffixed with a ?, the alignment will only take place if the item is not already in the visible area.
y : 'start' / 'center' / 'end' (optional)
The alignment of the x scroll. If not specified, the minimum will be done to make the element visible. The behavior is undefined if the request cannot be honored. If the alignment is suffixed with a ?, the alignment will only take place if the item is not already in the visible area.
An object with "x" and "y" properties
Returns the size of the element.
contentSize : Boolean (optional)
true to get the width/size minus borders and padding.
An object containing the element's size:
Returns a named style property based on computed/currentStyle (primary) and inline-style if primary is not available.
property : String/String[]
The style property (or multiple property names in an array) whose value is returned.
inline : Boolean (optional)
if true only inline styles will be returned.
Defaults to: false
The current value of the style property for this element (or a hash of named style values if multiple property arguments are requested).
Returns the selection range of an input element as an array of three values:
[ start, end, direction ]
These have the same meaning as the parameters to selectText.
Available since: 6.5.0
Returns the width in pixels of the passed text, or the width of the text in this Element.
text : String
The text to measure. Defaults to the innerHTML of the element.
min : Number (optional)
The minumum value to return.
max : Number (optional)
The maximum value to return.
The text width in pixels.
Gets the top Y coordinate
local : Boolean
True to get the local css position instead of page coordinates
Returns this element's touch action. (see setTouchAction)
The returned object is shared and should not be mutated.
Returns the value of the value attribute.
asNumber : Boolean
true to parse the value as a number.
Returns the content region of this element. That is the region within the borders and padding.
A Region containing "top, left, bottom, right" member data.
Returns the dimensions of the element available to lay content out in. For most elements this is the clientHeight/clientWidth. If the element is the document/document.body the window's innerHeight/innerWidth is returned
If the element (or any ancestor element) has CSS style display: none, the
dimensions will be zero.
Object describing width and height.
Returns the offset width of the element.
contentWidth : Boolean (optional)
true to get the width minus borders and padding.
preciseWidth : Boolean (optional)
true to get the precise width
The element's width.
Checks if the specified CSS class exists on this element's DOM node.
name : String
The CSS class to check for.
true if the class exists, else false.
Checks to see if this object has any listeners for a specified event, or whether the event bubbles. The answer indicates whether the event needs firing or not.
eventName : String
The name of the event to check for
true if the event is being listened for or bubbles, else false
Hide this element - Uses display mode to determine whether to use "display", "visibility", or "offsets". See setVisible.
this
Sets up event handlers to call the passed functions when the mouse is moved into and out of the Element.
overFn : Function
The function to call when the mouse enters the Element.
outFn : Function
The function to call when the mouse leaves the Element.
scope : Object (optional)
The scope (this reference) in which the functions are executed.
Defaults to the Element's DOM element.
options : Object (optional)
Options for the listener. See the options parameter.
this
Returns the index of the given element in the childNodes of this element. If
not present, -1 is returned.
Available since: 6.5.0
childEl : String/HTMLElement/Ext.dom.Element
The potential child element.
The index of childEl in childNodes or -1 if not found.
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'
instanceConfig : Object
this
Inserts this element after the passed element in the DOM.
el : String/HTMLElement/Ext.dom.Element
The element to insert after.
The id of the node, a DOM Node or an existing Element.
This element.
Inserts this element before the passed element in the DOM.
el : String/HTMLElement/Ext.dom.Element
The element before which this element will be inserted. The id of the node, a DOM Node or an existing Element.
This element.
Inserts (or creates) an element as the first child of this element
el : String/HTMLElement/Ext.dom.Element/Object
The id or element to insert or a DomHelper config to create and insert
returnDom : Boolean (optional)
True to return the raw DOM element instead of Ext.dom.Element
Defaults to: false
The new child element (or HTMLElement if returnDom is true).
Inserts an html fragment into this element
where : String
Where to insert the html in relation to this element - beforeBegin, afterBegin, beforeEnd, afterEnd. See Ext.dom.Helper#insertHtml for details.
html : String
The HTML fragment
returnEl : Boolean (optional)
True to return an Ext.dom.Element
Defaults to: false
The inserted node (or nearest related if more than 1 inserted)
Inserts (or creates) the passed element (or DomHelper config) as a sibling of this element
el : String/HTMLElement/Ext.dom.Element/Object/Array
The id, element to insert or a DomHelper config to create and insert or an array of any of those.
where : String (optional)
'before' or 'after'
Defaults to: 'before'
returnDom : Boolean (optional)
True to return the raw DOM element instead of Ext.dom.Element
Defaults to: false
The inserted Ext.dom.Element (or HTMLElement if returnDom is true). If an array is passed, the last inserted element is returned.
Returns true if this element matches the passed simple selector
(e.g. 'div.some-class' or 'span:first-child').
selector : String/Function
The simple selector to test or a function
which is passed candidate nodes, and should return true for nodes which match.
true if this element matches the selector, else false.
Returns true if this element is an ancestor of the passed element
el : String/HTMLElement/Ext.dom.Element
The element or id of the element to search for in this elements descendants.
Checks whether this element can be focused programmatically or by clicking. To check if an element is in the document tab flow, use isTabbable.
skipVisibility : Object
True if the element is focusable
Returns true if this Element is an input field, or is editable in any way.
true if this Element is an input field, or is editable in any way.
Checks if the current value of a style is equal to a given value.
style : String
property whose value is returned.
val : String
to check against.
true for when the current value equals the given value.
Checks if all events, or a specific event, is suspended.
event : String (optional)
The name of the specific event to check
true if events are suspended
Checks whether this element participates in the sequential focus navigation, and can be reached by using Tab key.
includeHidden : Boolean (optional)
pass true if hidden, or unattached elements
should be returned.
Defaults to: false
True if the element is tabbable.
Returns true if the value of the given property is visually transparent.
This may be due to a 'transparent' style value or an rgba value with 0
in the alpha component.
prop : String
The style property whose value is to be tested.
true if the style property is visually transparent.
Deprecated since version 5.0.0
This method is deprecated.
Checks whether the element is currently visible using both visibility and display properties.
deep : Boolean (optional)
True to walk the dom and see if parent elements are hidden.
If false, the function only checks the visibility of the element itself and it may return
true even though a parent is not visible.
Defaults to: false
mode : Number (optional)
Bit flag indicating which CSS properties to test:
1 - check display only2 - check visibility only3 - check both visibility and displayDefaults to: 3
true if the element is currently visible, else false
Gets the last child, skipping text nodes
selector : String (optional)
Find the previous sibling that matches the passed simple selector. See Ext.dom.Query for information about simple selectors.
returnDom : Boolean (optional)
true to return a raw DOM node instead of an
Ext.dom.Element
Defaults to: false
The last child Ext.dom.Element (or HTMLElement if returnDom is true). Or null if no match is found.
Adds a "destroyable" object to an internal list of objects that will be destroyed
when this instance is destroyed (via destroy).
name : String
value : Object
The value passed.
Measures and returns the size of this element. When dimension is null (or
not specified), this will be an object with width and height properties.
If dimension is 'w' the value returned will be this element's width. If
dimension is 'h' the returned value will be this element's height.
Unlike getWidth and getHeight this method only returns "precise" (sub-pixel)
sizes based on the getBoundingClientRect API.
Available since: 6.5.0
dimension : 'w'/'h' (optional)
Specifies which dimension is desired. If omitted
then an object with width and height properties is returned.
This element's width, height or both as a readonly
object. This object may be the direct result of getBoundingClientRect and
hence immutable on some browsers.
Measures and returns this element's content. When dimension is null (or
not specified), this will be an object with width and height properties.
If dimension is 'w' the value returned will be this element's width. If
dimension is 'h' the returned value will be this element's height.
Unlike getWidth and getHeight this method only returns "precise" (sub-pixel)
sizes based on the getBoundingClientRect API.
Available since: 6.5.0
dimension : 'w'/'h' (optional)
Specifies which dimension is desired. If omitted
then an object with width and height properties is returned.
This element's width, height or both as a readonly
object. This object may be the direct result of getBoundingClientRect and
hence immutable on some browsers.
Shorthand for addManagedListener. The addManagedListener method is used when some object (call it "A") is listening to an event on another observable object ("B") and you want to remove that listener from "B" when "A" is destroyed. This is not an issue when "B" is destroyed because all of its listeners will be removed at that time.
Example:
Ext.define('Foo', {
extend: 'Ext.Component',
initComponent: function () {
this.addManagedListener(MyApp.SomeSharedMenu, 'show', this.doSomething);
this.callParent();
}
});
As you can see, when an instance of Foo is destroyed, it ensures that the 'show'
listener on the menu (MyApp.SomeGlobalSharedMenu) is also removed.
As of version 5.1 it is no longer necessary to use this method in most cases because
listeners are automatically managed if the scope object provided to
addListener is an Observable instance.
However, if the observable instance and scope are not the same object you
still need to use mon or addManagedListener if you want the listener to be
managed.
item : Ext.util.Observable/Ext.dom.Element
The item to which to add a listener/listeners.
ename : Object/String
The event name, or an object containing event name properties.
fn : Function/String (optional)
If the ename parameter was an event
name, this is the handler function or the name of a method on the specified
scope.
scope : Object (optional)
If the ename parameter was an event name, this is
the scope (this reference) in which the handler function is executed.
options : Object (optional)
If the ename parameter was an event name, this is
the addListener options.
Only when the destroyable option is specified.
A Destroyable object. An object which implements the destroy method which removes
all listeners added in this call. For example:
this.btnListeners = myButton.mon({
destroyable: true
mouseover: function() { console.log('mouseover'); },
mouseout: function() { console.log('mouseout'); },
click: function() { console.log('click'); }
});
And when those listeners need to be removed:
Ext.destroy(this.btnListeners);
or
this.btnListeners.destroy();
Monitors this Element for the mouse leaving. Calls the function after the specified delay only if the mouse was not moved back into the Element within the delay. If the mouse was moved back in, the function is not called.
delay : Number
The delay in milliseconds to wait for possible mouse re-entry before calling the handler function.
handler : Function
The function to call if the mouse remains outside of this Element for the specified time.
scope : Object (optional)
The scope (this reference) in which the handler function
executes. Defaults to this Element.
The listeners object which was added to this element so that monitoring can be stopped. Example usage:
// Hide the menu if the mouse moves out for 250ms or more
this.mouseLeaveMonitor = this.menuEl.monitorMouseLeave(250, this.hideMenu, this);
...
// Remove mouseleave monitor on menu destroy
this.mouseLeaveMonitor.destroy();
Move the element relative to its current position.
direction : String
Possible values are:
"l" (or "left")"r" (or "right")"t" (or "top", or "up")"b" (or "bottom", or "down")distance : Number
How far to move the element in pixels
Shorthand for removeManagedListener. Removes listeners that were added by the mon method.
item : Ext.util.Observable/Ext.dom.Element
The item from which to remove a listener/listeners.
ename : Object/String
The event name, or an object containing event name properties.
fn : Function (optional)
If the ename parameter was an event name, this is
the handler function.
scope : Object (optional)
If the ename parameter was an event name, this is
the scope (this reference) in which the handler function is executed.
Gets the next sibling, skipping text nodes
selector : String (optional)
Find the next sibling that matches the passed simple selector. See Ext.dom.Query for information about simple selectors.
returnDom : Boolean (optional)
true to return a raw dom node instead of an
Ext.dom.Element
Defaults to: false
The next sibling Ext.dom.Element (or HTMLElement if asDom is true). Or null if no match is found.
The on method is shorthand for addListener.
Appends an event handler to this object. For example:
myGridPanel.on("itemclick", this.onItemClick, this);
The method also allows for a single argument to be passed which is a config object containing properties which specify multiple events. For example:
myGridPanel.on({
cellclick: this.onCellClick,
select: this.onSelect,
viewready: this.onViewReady,
scope: this // Important. Ensure "this" is correct during handler execution
});
One can also specify options for each event handler separately:
myGridPanel.on({
cellclick: {fn: this.onCellClick, scope: this, single: true},
viewready: {fn: panel.onViewReady, scope: panel}
});
Names of methods in a specified scope may also be used:
myGridPanel.on({
cellclick: {fn: 'onCellClick', scope: this, single: true},
viewready: {fn: 'onViewReady', scope: panel}
});
eventName : String/Object
The name of the event to listen for. May also be an object who's property names are event names.
fn : Function/String (optional)
The method the event invokes or the name of
the method within the specified scope. Will be called with arguments
given to Ext.util.Observable#fireEvent plus the options parameter described
below.
scope : Object (optional)
The scope (this reference) in which the handler function is
executed. If omitted, defaults to the object which fired the event.
options : Object (optional)
An object containing handler configuration.
Note: The options object will also be passed as the last argument to every event handler.
This object may contain any of the following properties:
scope : Object
The scope (this reference) in which the handler function is executed. If omitted,
defaults to the object which fired the event.
delay : Number
The number of milliseconds to delay the invocation of the handler after the event fires.
single : Boolean
True to add a handler to handle just the next firing of the event, and then remove itself.
buffer : Number
Causes the handler to be scheduled to run in an Ext.util.DelayedTask delayed by the specified number of milliseconds. If the event fires again within that time, the original handler is not invoked, but the new handler is scheduled in its place.
onFrame : Number
Causes the handler to be scheduled to run at the next animation frame event. If the event fires again before that time, the handler is not rescheduled - the handler will only be called once when the next animation frame is fired, with the last set of arguments passed.
target : Ext.util.Observable
Only call the handler if the event was fired on the target Observable, not if the event was bubbled up from a child Observable.
element : String
This option is only valid for listeners bound to <ExtComponent/>. The name of a Component property which references an Ext.dom.Element to add a listener to.
This option is useful during Component construction to add DOM event listeners to elements of <ExtComponent/> which will exist only after the Component is rendered.
For example, to add a click listener to a Panel's body:
var panel = new Ext.panel.Panel({
title: 'The title',
listeners: {
click: this.handlePanelClick,
element: 'body'
}
});
In order to remove listeners attached using the element, you'll need to reference the element itself as seen below.
panel.body.un(...)
delegate : String (optional)
A simple selector to filter the event target or look for a descendant of the target.
The "delegate" option is only available on Ext.dom.Element instances (or when attaching a listener to a Ext.dom.Element via a Component using the element option).
See the delegate example below.
capture : Boolean (optional)
When set to true, the listener is fired in the capture phase of the event propagation
sequence, instead of the default bubble phase.
The capture option is only available on Ext.dom.Element instances (or
when attaching a listener to a Ext.dom.Element via a Component using the
element option).
stopPropagation : Boolean (optional)
This option is only valid for listeners bound to Ext.dom.Element.
true to call stopPropagation on the event
object before firing the handler.
preventDefault : Boolean (optional)
This option is only valid for listeners bound to Ext.dom.Element.
true to call preventDefault on the event
object before firing the handler.
stopEvent : Boolean (optional)
This option is only valid for listeners bound to Ext.dom.Element.
true to call stopEvent on the event object
before firing the handler.
args : Array (optional)
Optional set of arguments to pass to the handler function before the actual
fired event arguments. For example, if args is set to ['foo', 42],
the event handler function will be called with an arguments list like this:
handler('foo', 42, <actual event arguments>...);
destroyable : Boolean (optional)
When specified as true, the function returns a destroyable object. An object
which implements the destroy method which removes all listeners added in this call.
This syntax can be a helpful shortcut to using un; particularly when
removing multiple listeners. NOTE - not compatible when using the element
option. See un for the proper syntax for removing listeners added using the
element config.
Defaults to:
false
priority : Number (optional)
An optional numeric priority that determines the order in which event handlers are run. Event handlers with no priority will be run as if they had a priority of 0. Handlers with a higher priority will be prioritized to run sooner than those with a lower priority. Negative numbers can be used to set a priority lower than the default. Internally, the framework uses a range of 1000 or greater, and -1000 or lesser for handlers that are intended to run before or after all others, so it is recommended to stay within the range of -999 to 999 when setting the priority of event handlers in application-level code. A priority must be an integer to be valid. Fractional values are reserved for internal framework use.
order : String (optional)
A legacy option that is provided for backward compatibility.
It is recommended to use the priority option instead. Available options are:
'before': equal to a priority of 100'current': equal to a priority of 0 or default priority'after': equal to a priority of -100Defaults to:
'current'
order : String (optional)
A shortcut for the order event option. Provided for backward compatibility.
Please use the priority event option instead.
Defaults to: 'current'
Only when the destroyable option is specified.
A Destroyable object. An object which implements the destroy method which removes
all listeners added in this call. For example:
this.btnListeners = = myButton.on({
destroyable: true
mouseover: function() { console.log('mouseover'); },
mouseout: function() { console.log('mouseout'); },
click: function() { console.log('click'); }
});
And when those listeners need to be removed:
Ext.destroy(this.btnListeners);
or
this.btnListeners.destroy();
Appends an after-event handler.
Same as addListener with order set
to 'after'.
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.
Appends a before-event handler. Returning false from the handler will stop the event.
Same as addListener with order set
to 'before'.
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.
Gets the parent node for this element, optionally chaining up trying to match a selector
selector : String (optional)
Find a parent node that matches the passed simple selector. See Ext.dom.Query for information about simple selectors.
returnDom : Boolean (optional)
True to return a raw dom node instead of an Ext.dom.Element
Defaults to: false
The parent node (Ext.dom.Element or HTMLElement if returnDom is true). Or null if no match is found.
Initializes positioning on this element. If a desired position is not passed, it will make the the element positioned relative IF it is not already positioned.
pos : String (optional)
Positioning to use "relative", "absolute" or "fixed"
zIndex : Number (optional)
The zIndex to apply
x : Number (optional)
Set the page X position
y : Number (optional)
Set the page Y position
Gets the previous sibling, skipping text nodes
selector : String (optional)
Find the previous sibling that matches the passed simple selector. See Ext.dom.Query for information about simple selectors.
returnDom : Boolean (optional)
true to return a raw DOM node instead of an
Ext.dom.Element
Defaults to: false
The previous sibling (Ext.dom.Element or HTMLElement if returnDom is true). Or null if no match is found.
Removes all listeners for this object including the managed listeners
Deprecated since version 5.0.0
Please use clearListeners instead.
Selects child nodes based on the passed CSS selector. Delegates to document.querySelectorAll. More information can be found at http://www.w3.org/TR/css3-selectors/
All selectors, attribute filters and pseudos below can be combined infinitely
in any order. For example div.foo:nth-child(odd)[@foo=bar].bar:first would be
a perfectly valid selector.
The use of @ and quotes are optional. For example, div[@foo='bar'] is also a valid attribute selector.
selector : String
The CSS selector.
asDom : Boolean (optional)
false to return an array of Ext.dom.Element
Defaults to: true
An Array of elements ( HTMLElement or Ext.dom.Element if asDom is false) that match the selector. If there are no matches, an empty Array is returned.
Adds one or more CSS classes to this element and removes the same class(es) from all siblings.
className : String/String[]
The CSS class to add, or an array of classes.
this
Relays selected events from the specified Observable as if the events were fired
by this.
For example if you are extending Grid, you might decide to forward some events from store. So you can do this inside your initComponent:
this.relayEvents(this.getStore(), ['load']);
The grid instance will then have an observable 'load' event which will be passed the parameters of the store's load event and any function fired with the grid's load event would have access to the grid using the this keyword (unless the event is handled by a controller's control/listen event listener in which case 'this' will be the controller rather than the grid).
origin : Object
The Observable whose events this object is to relay.
events : String[]/Object
Array of event names to relay or an Object with key/value pairs translating to ActualEventName/NewEventName respectively. For example: this.relayEvents(this, {add:'push', remove:'pop'});
Would now redispatch the add event of this as a push event and the remove event as a pop event.
prefix : String (optional)
A common prefix to prepend to the event names. For example:
this.relayEvents(this.getStore(), ['load', 'clear'], 'store');
Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'.
A Destroyable object. An object which implements the destroy method
which, when destroyed, removes all relayers. For example:
this.storeRelayers = this.relayEvents(this.getStore(), ['load', 'clear'], 'store');
Can be undone by calling
Ext.destroy(this.storeRelayers);
or this.store.relayers.destroy();
Destroys this element by removing it from the cache, removing its DOM reference, and removing all of its event listeners.
Deprecated since version 5.0.0
Please use destroy instead.
Removes all listeners for this object including the managed listeners
Deprecated since version 5.0.0
Please use clearListeners instead.
Removes the given CSS class(es) from this Element.
names : String/String[]
The CSS classes to remove separated by space, or an array of classes
prefix : String (optional)
Prefix to prepend to each class. The separator - will be
appended to the prefix.
suffix : String (optional)
Suffix to append to each class. The separator - will be
prepended to the suffix.
return {Ext.dom.Element} this
Removes an event handler.
eventName : String
The type of event the handler was associated with.
fn : Function
The handler to remove. This must be a reference to the function passed into the addListener call.
scope : Object (optional)
The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable#addListener or the listener will not be removed.
Removes listeners that were added by the mon method.
item : Ext.util.Observable/Ext.dom.Element
The item from which to remove a listener/listeners.
ename : Object/String
The event name, or an object containing event name properties.
fn : Function (optional)
If the ename parameter was an event name, this is
the handler function.
scope : Object (optional)
If the ename parameter was an event name, this is
the scope (this reference) in which the handler function is executed.
Remove a single managed listener item
isClear : Boolean
True if this is being called during a clear
managedListener : Object
The managed listener item
item : Object
ename : String
fn : Function
scope : Object
See removeManagedListener for other args
Forces the browser to repaint this element.
cls : Object
state : Object
this
Replaces the passed element with this element
el : String/HTMLElement/Ext.dom.Element
The element to replace. The id of the node, a DOM Node or an existing Element.
destroy : Boolean (optional)
false to prevent destruction of the replaced
element
Defaults to: true
This element
Replaces one or more CSS classes on this element with other classes. If the old name does not exist, the new name will simply be added.
remove : String/String[] (optional)
The CSS class(es) to be removed.
add : String/String[] (optional)
The CSS class(es) to be added.
prefix : String (optional)
The string to prepend to each class name.
suffix : String (optional)
The string to append to each class name.
this
Replaces this element with the passed element
el : String/HTMLElement/Ext.dom.Element/Object
The new element (id of the node, a DOM Node or an existing Element) or a DomHelper config of an element to create
This element
Gets the default scope for firing late bound events (string names with no scope attached) at runtime.
defaultScope : Object (optional)
The default scope to return if none is found.
Defaults to: this
The default event scope
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.
eventName : String...
Multiple event names to resume.
Resumes firing events (see suspendEvents).
If events were suspended using the queueSuspended parameter, then all events fired
during event suspension will be sent to any listeners now.
discardQueue : Boolean (optional)
true to prevent any previously queued events from firing
while we were suspended. See suspendEvents.
Converts local coordinates into page-level coordinates
xy : Number[]
The local x and y coordinates
The translated coordinates
Creates a ripple effect over this element. The element should be positioned
(either relative or absolute) prior to calling this method.
event : String/Event/Ext.event.Event (optional)
The event to use for ripple positioning.
options : Object/String (optional)
Ripple options object or color to use for ripple
color : String (optional)
The color to use for the ripple effect or
'default' to use the stylesheet default color
Global_CSS#$ripple-background-color. When no color is given, the
element's color style is used.
release : Boolean (optional)
Optional determines if the ripple should happen on release. Defaults to down/start.
delegate : String (optional)
Optional selector for which child to add the ripple into
measureSelector : String (optional)
Optional selector for which child to use to measure for ripple size.
position : Number[] (optional)
The [x,y] position in which to start the ripple.
centered : Boolean (optional)
Set to true to override all position
information and forces the ripple to be centered inside its parent.
bound : Boolean / String (optional)
Determines if the ripple is bound to the parent container (default). If false ripple will expand outside of container.
diameterLimit : Boolean / Number (optional)
Maximum size, in pixels, that a ripple
can be.
A value of false or 0 will cause the ripple to fill its container. A value of true
will cause the ripple to use the default maximum size.
fit : Boolean / String (optional)
For bound ripples only. Determines if
ripple should search up the dom for an element that will fit the ripple
without clipping. Setting to false will force the unbound ripple into the specified
container. Defaults to true.
Defaults to:
true
destroyTime : Number (optional)
The time (in milliseconds) to wait until the ripple is destroyed.
Scrolls this element the specified direction. Does bounds checking to make sure the scroll is within this element's scrollable range.
direction : String
Possible values are:
"l" (or "left")"r" (or "right")"t" (or "top", or "up")"b" (or "bottom", or "down")distance : Number
How far to scroll the element in pixels
animate : Boolean/Object (optional)
true for the default animation or a standard Element animation config object
Returns true if a scroll was triggered or false if the element was scrolled as far as it could go.
Scrolls this element by the passed delta values, optionally animating.
All of the following are equivalent:
el.scrollBy(10, 10, true);
el.scrollBy([10, 10], true);
el.scrollBy({ x: 10, y: 10 }, true);
deltaX : Number/Number[]/Object
Either the x delta, an Array specifying x and y deltas or an object with "x" and "y" properties.
deltaY : Number/Boolean/Object
Either the y delta, or an animate flag or config object.
animate : Boolean/Object
Animate flag/config object if the delta values were passed separately.
this
Scrolls this element into view within the passed container.
Ext.create('Ext.data.Store', {
storeId:'simpsonsStore',
fields:['name', 'email', 'phone'],
data:{'items':[
{ 'name': 'Lisa', "email":"[email protected]", "phone":"555-111-1224" },
{ 'name': 'Bart', "email":"[email protected]", "phone":"555-222-1234" },
{ 'name': 'Homer', "email":"[email protected]", "phone":"555-222-1244" },
{ 'name': 'Marge', "email":"[email protected]", "phone":"555-222-1254" },
{ 'name': 'Milhouse', "email":"[email protected]",
"phone":"555-222-1244" },
{ 'name': 'Willy', "email":"[email protected]", "phone":"555-222-1254" },
{ 'name': 'Skinner', "email":"[email protected]",
"phone":"555-222-1244" },
{ 'name': 'Hank (last row)', "email":"[email protected]",
"phone":"555-222-1254" }
]},
proxy: {
type: 'memory',
reader: {
type: 'json',
rootProperty: 'items'
}
}
});
var grid = Ext.create('Ext.grid.Panel', {
title: 'Simpsons',
store: Ext.data.StoreManager.lookup('simpsonsStore'),
columns: [
{ text: 'Name', dataIndex: 'name', width: 125 },
{ text: 'Email', dataIndex: 'email', flex: 1 },
{ text: 'Phone', dataIndex: 'phone' }
],
height: 190,
width: 400,
renderTo: Ext.getBody(),
tbar: [{
text: 'Scroll row 7 into view',
handler: function () {
var view = grid.getView();
Ext.get(view.getRow(7)).scrollIntoView(view.getEl(), null, true);
}
}]
});
container : String/HTMLElement/Ext.dom.Element (optional)
The container element to scroll. Should be a string (id), dom node, or Ext.Element.
Defaults to: document.body
hscroll : Boolean (optional)
False to disable horizontal scroll.
Defaults to: true
animate : Boolean/Object (optional)
true for the default animation or a standard Element animation config object
this
Scrolls this element the specified scroll point. It does NOT do bounds checking so if you scroll to a weird value it will try to do it. For auto bounds checking, use #scroll.
side : String
Either "left" for scrollLeft values or "top" for scrollTop values.
value : Number
The new scroll value
animate : Boolean/Object (optional)
true for the default animation or a standard Element animation config object
this
Selects descendant elements of this element based on the passed CSS selector to enable Ext.dom.Element methods to be applied to many related elements in one statement through the returned Ext.dom.CompositeElementLite object.
selector : String/HTMLElement[]
The CSS selector or an array of elements
composite : Boolean
Return a CompositeElement as opposed to a CompositeElementLite. Defaults to false.
Selects a single descendant element of this element using a CSS selector (see method-query).
selector : String
The selector query
asDom : Boolean (optional)
false to return an Ext.dom.Element
Defaults to: true
The DOM element (or Ext.dom.Element if asDom is false) which matched the selector.
Selects the specified contents of the input element (all by default).
Available since: 6.5.0
start : Number (optional)
The starting index to select.
Defaults to: 0
end : Number (optional)
The end index to select (defaults to all remaining text).
direction : "f"/"b"/"forward"/"backward" (optional)
Pass "f" for forward, "b" for backwards.
Defaults to: "f"
this
Enable text selection for this element (normalized across browsers)
this
Sets the passed attributes as attributes of this element (a style attribute
can be a string, object or function).
Example component (though any Ext.dom.Element would suffice):
var cmp = Ext.create({
xtype: 'component',
html: 'test',
renderTo: Ext.getBody()
});
Once the component is rendered, you can fetch a reference to its outer
element to use set:
cmp.el.set({
foo: 'bar'
});
This sets an attribute on the element of foo="bar":
<div class="x-component x-component-default x-border-box"
id="component-1009" foo="bar">test</div>
To remove the attribute pass a value of undefined:
cmp.el.set({
foo: undefined
});
Note:
undefined when the
expandos param is set to false.style results in the request being handed off to
method-applyStyles.cls results in the element's dom's
className property
being set directly. For additional flexibility when setting / removing
classes see:
attributes : Object
The object with the attributes.
useSet : Boolean (optional)
false to override the default setAttribute
to use expandos.
Defaults to: true
this
Sets the element's CSS bottom style.
bottom : Number/String
Number of pixels or CSS string value to set as the bottom CSS property value
this
Sets the element's box.
box : Object
The box to fill {x, y, width, height}
this
Sets the CSS classes of this element to the keys of the given object. The
classMap object is typically returned by getClassMap. The values of
the properties in the classMap should be truthy (such as 1 or true).
classMap : Object
The object whose keys will be the CSS classes.
keep : Boolean (optional)
Pass true to indicate the the classMap
object can be kept (instead of copied).
Defaults to: false
Sets the specified CSS class on this element's DOM node.
className : String/String[]
The CSS class to set on this element.
Sets a single/multiple configuration options.
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.
this
Sets the CSS display property. Uses originalDisplay if the specified value is a boolean true.
value : Boolean/String
Boolean value to display the element using its default display, or a string to set the display directly.
this
Sets the innerHTML of this element.
html : String
The new HTML.
this
Deprecated since version 5.0.0
Please use setHtml instead.
Set the height of this Element.
height : Number/String
The new height.
this
Sets the innerHTML of this element.
html : String
The new HTML.
this
Sets the element's left position directly using CSS style (instead of setX).
left : Number/String
Number of pixels or CSS string value to set as the left CSS property value
this
An alias for addListener. In versions prior to 5.1, listeners had a generated setter which could be called to add listeners. In 5.1 the listeners config is not processed using the config system and has no generated setter, so this method is provided for backward compatibility. The preferred way of adding listeners is to use the on method.
listeners : Object
The listeners
Sets the local x coordinate of this element using CSS style. When used on an absolute positioned element this method is symmetrical with getLocalX, but may not be symmetrical when used on a relatively positioned element.
x : Number
The x coordinate. A value of null sets the left style to 'auto'.
this
Sets the local x and y coordinates of this element using CSS style. When used on an absolute positioned element this method is symmetrical with getLocalXY, but may not be symmetrical when used on a relatively positioned element.
x : Number/Array
The x coordinate or an array containing [x, y]. A value of
null sets the left style to 'auto'
y : Number (optional)
The y coordinate, required if x is not an array. A value of
null sets the top style to 'auto'
this
Sets the local y coordinate of this element using CSS style. When used on an absolute positioned element this method is symmetrical with getLocalY, but may not be symmetrical when used on a relatively positioned element.
y : Number
The y coordinate. A value of null sets the top style to 'auto'.
this
Set the maximum height of this Element.
height : Number/String
The new maximum height.
this
Set the maximum width of this Element.
width : Number/String
The new maximum width.
this
Set the minimum height of this Element.
height : Number/String
The new minimum height.
this
Set the minimum width of this Element.
width : Number/String
The new minimum width.
this
Set the opacity of the element
opacity : Number
The new opacity. 0 = transparent, .5 = 50% visibile, 1 = fully visible, etc
this
Sets the element's CSS right style.
right : Number/String
Number of pixels or CSS string value to set as the right CSS property value
this
Sets the left scroll position
left : Number
The left scroll position
this
Sets the top scroll position
top : Number
The top scroll position
this
Set the size of this Element.
width : Number/String
The new width. This may be one of:
{width: widthValue, height: heightValue}.height : Number/String
The new height. This may be one of:
this
Wrapper for setting style properties, also takes single object parameter of multiple styles.
Styles should be a valid DOM element style property. Valid style property names (along with the supported CSS version for each)
// <div id="my-el">Phineas Flynn</div>
var el = Ext.get('my-el');
// two-param syntax
el.setStyle('color', 'white');
// single-param syntax
el.setStyle({
fontWeight: 'bold',
backgroundColor: 'gray',
padding: '10px'
});
prop : String/Object
The style property to be set, or an object of multiple styles.
value : String (optional)
The value to apply to the given property, or null if an object was passed.
this
Sets the element's top position directly using CSS style (instead of setY).
top : Number/String
Number of pixels or CSS string value to set as the top CSS property value
this
Sets the CSS touch-action property on this element and emulates its behavior on browsers where touch-action is not supported.
touchAction : Object
An object with touch-action names as the keys, and boolean values to enable or disable specific touch actions. Accepted keys are:
panXpanYpinchZoomdoubleTapZoomAll touch actions are enabled (true) by default, so it is usually only necessary
to specify which touch actions to disable. For example, the following disables
only vertical scrolling and double-tap-zoom on an element
element.setTouchAction({
panY: false,
doubleTapZoom: false
});
this
Use this to change the visibility mode between VISIBILITY, DISPLAY, OFFSETS, CLIP, or OPACITY.
mode : Ext.dom.Element.VISIBILITY/Ext.dom.Element.DISPLAY/Ext.dom.Element.OFFSETS/Ext.dom.Element.CLIP/Ext.dom.Element.OPACITY
The method by which the element will be hidden (you can also use the setVisible or toggle method to toggle element visibility).
this
Sets the visibility of the element based on the current visibility mode. Use setVisibilityMode to switch between the following visibility modes:
visible : Boolean
Whether the element is visible.
this
Set the width of this Element.
width : Number/String
The new width.
this
Sets this Element's page-level x coordinate
x : Number
this
Sets this Element's page-level x and y coordinates
xy : Number[]
this
Sets this Element's page-level y coordinate
y : Number
this
Sets the z-index of this Element and synchronizes the z-index of shadow and/or shim if present.
zindex : Number
The new z-index to set
this
Show this element - Uses display mode to determine whether to use "display", "visibility", "offsets", or "clip". See setVisible.
this
Get the reference to the class from which this object was instantiated. Note that unlike
Ext.Base#self, this.statics() is scope-independent and it always returns
the class from which it was called, regardless of what this points to during run-time
Ext.define('My.Cat', {
statics: {
totalCreated: 0,
speciesName: 'Cat' // My.Cat.speciesName = 'Cat'
},
constructor: function() {
var statics = this.statics();
// always equals to 'Cat' no matter what 'this' refers to
// equivalent to: My.Cat.speciesName
alert(statics.speciesName);
alert(this.self.speciesName); // dependent on 'this'
statics.totalCreated++;
},
clone: function() {
var cloned = new this.self(); // dependent on 'this'
// equivalent to: My.Cat.speciesName
cloned.groupName = this.statics().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
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.
eventName : String...
Multiple event names to suspend.
Suspends the firing of all events. (see resumeEvents)
queueSuspended : Boolean
true to queue up suspended events to be fired
after the resumeEvents call instead of discarding all suspended events.
Stops the specified event(s) from bubbling and optionally prevents the default action
var store = Ext.create('Ext.data.Store', {
fields: ['name', 'email'],
data: [{
'name': 'Finn',
"email": "[email protected]"
}]
});
Ext.create('Ext.grid.Panel', {
title: 'Land of Ooo',
store: store,
columns: [{
text: 'Name',
dataIndex: 'name'
}, {
text: 'Email <img style="vertical-align:middle;" src="{some-image-src}" />',
dataIndex: 'email',
flex: 1,
listeners: {
render: function(col) {
// Swallow the click event when the click occurs on the
// help icon - preventing the sorting of data by that
// column and instead performing an action specific to
// the help icon
var img = col.getEl().down('img');
img.swallowEvent(['click', 'mousedown'], true);
col.on('click', function() {
// logic to show a help dialog
console.log('image click handler');
}, col);
}
}
}],
height: 200,
width: 400,
renderTo: document.body
});
eventName : String/String[]
an event / array of events to stop from bubbling
preventDefault : Boolean (optional)
true to prevent the default action too
Object with a destroy method to unswallow events
destroy : Function
method to clean up any listeners that are swallowing events
firstClass : String
secondClass : String
flag : Boolean
prefix : String
Toggles the element's visibility, depending on visibility mode.
this
Toggles the specified CSS class on this element (removes it if it already exists, otherwise adds it).
className : String
The CSS class to toggle.
state : Boolean (optional)
If specified as true, causes the class to be added.
If specified as false, causes the class to be removed.
this
Translates the passed page coordinates into left/top css values for the element
x : Number/Array
The page x or an array containing [x, y]
y : Number (optional)
The page y, required if x is not an array
An object with left and top properties. e.g. {left: (value), top: (value)}
Translates the passed page coordinates into x and y css values for the element
x : Number/Array
The page x or an array containing [x, y]
y : Number (optional)
The page y, required if x is not an array
An object with x and y properties. e.g. {x: (value), y: (value)}
Shorthand for removeListener. Removes an event handler.
eventName : String
The type of event the handler was associated with.
fn : Function
The handler to remove. This must be a reference to the function passed into the addListener call.
scope : Object (optional)
The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable#addListener or the listener will not be removed.
Removes a before-event handler.
Same as removeListener with order set to 'after'.
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.
Removes a before-event handler.
Same as removeListener with order set to 'before'.
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.
Destroys a given set of linked objects. This is only needed if
the linked object is being destroyed before this instance.
names : String[]
The names of the linked objects to destroy.
this
Disables text selection for this element (normalized across browsers)
this
Walks up the dom looking for a parent node that matches the passed simple selector (e.g. 'div.some-class' or 'span:first-child'). This is a shortcut for findParentNode() that always returns an Ext.dom.Element.
simpleSelector : String
The simple selector to test. See Ext.dom.Query for information about simple selectors.
limit : Number/String/HTMLElement/Ext.dom.Element (optional)
The max depth to search as a number or an element that causes the upward traversal to stop and is not considered for inclusion as the result. (defaults to 50 || document.documentElement)
returnDom : Boolean (optional)
True to return the DOM node instead of Ext.dom.Element
Defaults to: false
The matching DOM node (or HTMLElement if returnDom is true). Or null if no match was found.
Sets the innerHTML of this element.
html : String
The new HTML.
this
Deprecated since version 5.0.0
Please use setHtml instead.
Visits nodes in this elements tree which conform to the passed filter bitmask and calls the specified callback on each one.
options : Object
Properties used to affect the traverse.
callback : Function
A method to call on every node visited. Return
false to terminate the traverse.
node : HTMLElement
The node being visited.
scope : Object (optional)
The scope (this reference) in which to execute the
callback.
selector : String
A DOM query selector string to filter the nodes visited..
reverse : Boolean
true to traverse the tree in reverse from lastChild to
first.
excludeRoot : Ext.dom.Element / HTMLElement (optional)
An element inside which to exclude visits.
include : Number (optional)
A bitwise mask of DOM node types to include. Defaults to visiting all element nodes.
The return value from the last call to the callback.
Watches config properties.
instance.watchConfig({
title: 'onTitleChange',
scope: me
});
Available since: 6.7.0
name : Object
fn : Object
scope : Object
Creates and wraps this element with another element
config : Object (optional)
DomHelper element config object for the wrapper element or null for an empty div
returnDom : Boolean (optional)
True to return the raw DOM element instead of Ext.dom.Element
Defaults to: false
selector : String (optional)
A CSS selector to select a descendant node within the created element to use as the wrapping element.
The newly created wrapper element
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.
config : Object
mixinClass : Ext.Class (optional)
The mixin class if the configs are from a mixin.
name : Object
member : Object
privacy : Object
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();
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
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() { ... };
});
members : Object
this
Test if size has a unit, otherwise appends the passed unit string, or the default for this Element.
size : Object
The size to set.
units : String
The units to append to a numeric size value.
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 '$$$$$$$'
fromClass : Ext.Base
The class to borrow members from
members : Array/String
The names of the members to borrow
this
Create method to add support for a DomHelper config. Creates and appends elements/children using document.createElement/appendChild. This method is used by the modern toolkit for a significant performance gain in webkit browsers as opposed to using DomQuery which generates HTML markup and sets it as innerHTML.
However, the createElement/appendChild method of creating elements is significantly slower in all versions of IE at the time of this writing (6 - 11), so classic toolkit should not use this method, but should instead use DomHelper methods, or Element methods that use DomHelper under the hood (e.g. createChild). see https:*fiddle.sencha.com/#fiddle/tj
attributes : Object
domNode : Object
namespace : Object
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()
alias : String/Object
The new method name, or an object to set multiple aliases. See flexSetter
origin : String/Object
The original method name
Gets the globally shared flyweight Element, with the passed node as the active element. Do not store a reference to this element - the dom node can be overwritten by other code. Ext#fly is alias for Ext.dom.Element#fly.
Use this to make one-time references to DOM elements which are not going to be accessed again either by application code, or by Ext's classes. If accessing an element which will be processed regularly, then Ext.get will be more appropriate to take advantage of the caching provided by the Ext.dom.Element class.
If this method is called with and id or element that has already been cached by a previous call to Ext.get() it will return the cached Element instead of the flyweight instance.
dom : String/HTMLElement
The DOM node or id.
named : Object
The shared Element object (or null if no matching
element was found).
Returns the top Element that is located at the passed coordinates taking into account the scroll position of the document.
Available since: 6.2.0
x : Number
The x coordinate
y : Number
The y coordinate
asDom : Boolean (optional)
true to return a DOM element.
Defaults to: false
The found element.
Returns the top Element that is located at the passed coordinates in the current viewport.
x : Number
The x coordinate
y : Number
The y coordinate
asDom : Boolean (optional)
true to return a DOM element.
Defaults to: false
The found element.
Retrieves Ext.dom.Element objects. Ext#get is alias for Ext.dom.Element#get.
This method does not retrieve <ExtComponent/>s. This method retrieves Ext.dom.Element objects which encapsulate DOM elements. To retrieve a Component by its ID, use Ext.ComponentManager#get.
When passing an id, it should not include the # character that is used for a css
selector.
// For an element with id 'foo'
Ext.get('foo'); // Correct
Ext.get('#foo'); // Incorrect
Uses simple caching to consistently return the same object. Automatically fixes if an object was recreated with the same id via AJAX or DOM.
el : String/HTMLElement/Ext.dom.Element
The id of the node, a DOM Node
or an existing Element.
The Element object (or null if no matching element
was found).
Returns the active element in the DOM. If the browser supports activeElement on the document, this is returned. If not, the focus is tracked and the active element is maintained internally.
asElement : Boolean
Return Ext.Element instance instead of DOM node.
The active (focused) element in the document.
Returns the common ancestor of the two passed elements.
nodeA : Ext.dom.Element/HTMLElement
nodeB : Ext.dom.Element/HTMLElement
returnDom : Boolean
Pass true to return a DOM element. Otherwise an
Ext.dom.Element will be returned.
The common ancestor.
Returns the Ext.Configurator for this class.
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'
className
Retrieves the current orientation of the window. This is calculated by determining if the height is greater than the width.
Orientation of window: 'portrait' or 'landscape'
Retrieves the viewport height of the window.
viewportHeight
Returns the current zoom level of the viewport as a ratio of page pixels to screen pixels.
On touch-screen devices there may be an additional level of zooming that occurs when the user performs a pinch or double-tap to zoom gesture. This is separate from and in addition to the devicePixelRatio. We can detect it by comparing the width of the documentElement to window.innerWidth
forceRead : Object
Retrieves the viewport size of the window.
object containing width and height properties
Checks if the passed size has a css unit attached.
Available since: 6.2.1
size : String
The size.
true if the size has a css unit.
Checks if the passed css unit is a relative unit. This includes:
auto%emremautovhvwvminvmaxchAvailable since: 6.2.0
size : String
The css unit and value.
true if the value is relative.
Used internally by the mixins pre-processor
name : Object
mixinClass : Object
Normalizes CSS property keys from dash delimited to camel case JavaScript Syntax. For example:
prop : String
The property to normalize
The normalized string
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).
members : Object
The properties to add to this class. This should be specified as an object literal containing one or more properties.
this class
Parses a number or string representing margin sizes into an object. Supports CSS-style margin declarations (e.g. 10, "10", "10 10", "10 10 10" and "10 10 10 10" are all valid options and would return the same result)
box : Number/String
The encoded margins
An object with margin sizes for top, right, bottom and left containing the unit
Converts a CSS string into an object with a property for each style.
The sample code below would return an object with 2 properties, one for background-color and one for color.
var css = 'background-color: red; color: blue;';
console.log(Ext.dom.Element.parseStyles(css));
styles : String
A CSS string
styles
Selects child nodes of a given root based on the passed CSS selector.
selector : String
The CSS selector.
asDom : Boolean (optional)
false to return an array of Ext.dom.Element
Defaults to: true
root : HTMLElement/String (optional)
The root element of the query or id of the root
An Array of elements that match the selector. If there are no matches, an empty Array is returned.
Selects elements based on the passed CSS selector to enable Ext.dom.Element methods to be applied to many related elements in one statement through the returned Ext.dom.CompositeElementLite object.
selector : String/HTMLElement[]
The CSS selector or an array of elements
composite : Boolean (optional)
Return a CompositeElement as opposed to a CompositeElementLite. Defaults to false.
Defaults to: false
root : HTMLElement/String (optional)
The root element of the query or id of the root
Serializes a DOM form into a url encoded string
form : Object
The form
The url encoded form
Parses a number or string representing margin sizes into an object. Supports CSS-style margin declarations (e.g. 10, "10", "10 10", "10 10 10" and "10 10 10 10" are all valid options and would return the same result)
box : Number/String/Object
The encoded margins, or an object with top, right,
units : String
The type of units to add
An string with unitized (px if units is not specified) metrics for top, right, bottom and left
Fires when an object/image is stopped from loading before completely loaded.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when an element loses focus either via the pointing device or by tabbing navigation.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when a control loses the input focus and its value has been modified since gaining focus.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when a mouse click is detected within the element.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when a mouse double click is detected within the element.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Where supported. Fires when an element is activated, for instance, through a mouse click or a keypress.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Where supported. Fires when an attribute has been modified.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Where supported. Fires when the character data has been modified.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Where supported. Similar to HTML focus event, but can be applied to any focusable element.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Where supported. Similar to HTML blur event, but can be applied to any focusable element.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Where supported. Fires when a node has been added as a child of another node.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Where supported. Fires when a node is being inserted into a document.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Where supported. Fires when a descendant node of the element is removed.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Where supported. Fires when a node is being removed from a document.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Where supported. Fires when the subtree is modified.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when there is a double tap.
event : Ext.event.Event
The Ext.event.Event event encapsulating the DOM event.
node : HTMLElement
The target of the event.
options : Object
The options object passed to Ext.mixin.Observable.addListener.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when an object/image/frame cannot be loaded properly.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when an element receives focus either via the pointing device or by tab navigation.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when focus is moved within an element.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
target : Ext.dom.Element
The Ext.dom.Element element which recieved focus.
The Ext.dom.Element element which lost focus.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when a keydown is detected within the element.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when a keypress is detected within the element.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when a keyup is detected within the element.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when the user agent finishes loading all content within the element. Only supported by window, frames, objects and images.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when you touch and hold still for more than 1 second.
event : Ext.event.Event
The Ext.event.Event event encapsulating the DOM event.
node : HTMLElement
The target of the event.
options : Object
The options object passed to Ext.mixin.Observable.addListener.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when a mousedown is detected within the element.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when the mouse enters the element.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when the mouse leaves the element.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when a mousemove is detected with the element.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when a mouseout is detected with the element.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when a mouseover is detected within the element.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when a mouseup is detected within the element.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires whenever this Element actually becomes visible (painted) on the screen. This is useful when you need to perform 'read' operations on the DOM element, i.e: calculating natural sizes and positioning.
Note: This event is not available to be used with event delegation. Instead painted
only fires if you explicitly add at least one listener to it, for performance reasons.
this : Ext.dom.Element
The component instance.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires continuously when there is pinching (the touch must move for this to be fired).
event : Ext.event.Event
The Ext.event.Event event encapsulating the DOM event.
node : HTMLElement
The target of the event.
options : Object
The options object passed to Ext.mixin.Observable.addListener.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when a pinch has ended.
event : Ext.event.Event
The Ext.event.Event event encapsulating the DOM event.
node : HTMLElement
The target of the event.
options : Object
The options object passed to Ext.mixin.Observable.addListener.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fired once when a pinch has started.
event : Ext.event.Event
The Ext.event.Event event encapsulating the DOM event.
node : HTMLElement
The target of the event.
options : Object
The options object passed to Ext.mixin.Observable.addListener.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when a form is reset.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Important note: For the best performance on mobile devices, use this only when you absolutely need to monitor a Element's size.
Note: This event is not available to be used with event delegation. Instead resize
only fires if you explicitly add at least one listener to it, for performance reasons.
this : Ext.dom.Element
The component instance.
info : Object
The element's new size parameters.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires continuously when there is rotation (the touch must move for this to be fired).
When listening to this, ensure you know about the Ext.event.Event#angle and
Ext.event.Event#rotation properties in the event object.
event : Ext.event.Event
The Ext.event.Event event encapsulating the DOM event.
node : HTMLElement
The target of the event.
options : Object
The options object passed to Ext.mixin.Observable.addListener.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when a rotation event has ended.
event : Ext.event.Event
The Ext.event.Event event encapsulating the DOM event.
node : HTMLElement
The target of the event.
options : Object
The options object passed to Ext.mixin.Observable.addListener.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fired once when a rotation has started.
event : Ext.event.Event
The Ext.event.Event event encapsulating the DOM event.
node : HTMLElement
The target of the event.
options : Object
The options object passed to Ext.mixin.Observable.addListener.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when a document view is scrolled.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when a user selects some text in a text field, including input and textarea.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when there is a single tap.
event : Ext.event.Event
The Ext.event.Event event encapsulating the DOM event.
node : HTMLElement
The target of the event.
options : Object
The options object passed to Ext.mixin.Observable.addListener.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when a form is submitted.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when there is a swipe
When listening to this, ensure you know about the Ext.event.Event#direction property
in the event object.
event : Ext.event.Event
The Ext.event.Event event encapsulating the DOM event.
node : HTMLElement
The target of the event.
options : Object
The options object passed to Ext.mixin.Observable.addListener.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when you touch and hold still for more than 1 second.
event : Ext.event.Event
The Ext.event.Event event encapsulating the DOM event.
node : HTMLElement
The target of the event.
options : Object
The options object passed to Ext.mixin.Observable.addListener.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when the user agent removes all content from a window or frame. For elements, it fires when the target element or any of its content has been removed.
e : Ext.event.Event
The Ext.event.Event encapsulating the DOM event.
t : HTMLElement
The target of the event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
ExtAngular | Terms of Use