Docs Help

Terms, Icons, and Labels

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

Access Levels

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

Member Types

Member Syntax

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

lookupComponent ( item ) : Ext.Component
protected

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

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

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

Parameters

item :  Object

The config object being added.

Returns
Ext.Component

The component to be added.

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

Member Flags

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

Class Icons

- Indicates a framework class

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

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

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

Member Icons

- Indicates a class member of type config

- Indicates a class member of type property

- Indicates a class member of type method

- Indicates a class member of type event

- Indicates a class member of type theme variable

- Indicates a class member of type theme mixin

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

Class Member Quick-Nav Menu

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

Getter and Setter Methods

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

History Bar

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

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

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

Search and Filters

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

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

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

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

API Doc Class Metadata

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

Expanding and Collapsing Examples and Class Members

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

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

Desktop -vs- Mobile View

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

Viewing the Class Source

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

Ext JS 6.2.1 - Classic Toolkit


top

Summary

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.

No members found using the current filters

configs

properties

Instance Properties

$className
private pri

Defaults to:

'Ext.Base'

$configPrefixed : Boolean
private pri

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

Defaults to:

true

Available since: 5.0.0

$configStrict : Boolean
private pri

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

Defaults to:

true

Available since: 5.0.0

$eventOptions
private pri

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

Defaults to:

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

$vetoClearingPrototypeOnDestroy
private pri

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

Defaults to:

true

clearPropertiesOnDestroy : Boolean / "async"
protected pro

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

Defaults to:

true

Available since: 6.2.0

clearPrototypeOnDestroy : Boolean
private pri

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

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

Defaults to:

false

Available since: 6.2.0

component : Ext.Component

A reference to the Component that owns this element. This is null if there is no direct owner.

destroyed : Boolean
protected pro

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

Defaults to:

false

dom : HTMLElement

The DOM element

Defaults to:

dom

eventsSuspended
private pri

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

Defaults to:

0

hasListeners : Object
readonly ro

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

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

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

id : String

The DOM element ID

Defaults to:

id

isConfiguring : Boolean
readonly ro protected pro

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

Defaults to:

false

Available since: 5.0.0

isFirstInstance : Boolean
readonly ro protected pro

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

Defaults to:

false

Available since: 5.0.0

isFly : Boolean

This is true to identify Element flyweights

Defaults to:

true

isInstance : Boolean
readonly ro protected pro

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

Defaults to:

true

isObservable : Boolean

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

Defaults to:

true

self : Ext.Class
protected pro

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

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

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

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


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

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

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

Defaults to:

Base

Static Properties

$onExtended
static sta private pri

Defaults to:

[]

CLIP : Number
static sta

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

DISPLAY : Number
static sta

Visibility mode constant for use with Ext.dom.Element#setVisibilityMode. Use the CSS 'display' property to hide the element.

Defaults to:

2

editableSelector
static sta private pri

Defaults to:

'input,textarea,[contenteditable="true"]'

minKeyboardHeight
static sta private pri

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

OFFSETS : Number
static sta

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

useDelegatedEvents : Boolean
static sta private pri

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

validNodeTypes : Object
static sta private pri

The list of valid nodeTypes that are allowed to be wrapped

Defaults to:

{
    1: 1,
    // ELEMENT_NODE
    9: 1
}

VISIBILITY : Number
static sta

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

methods

Instance Methods

_addDeclaredListeners ( listeners ) : Boolean
private pri

Adds declarative listeners as nested arrays of listener objects.

Parameters

listeners :  Array

Returns

:Boolean

true if any listeners were added

_getPublisher ( eventName, [noTranslate] ) : Ext.event.publisher.Publisher
private pri

Returns the publisher for a given event

Parameters

eventName :  String

noTranslate :  Boolean (optional)

true if the event is a non translated event

Returns

:Ext.event.publisher.Publisher

addAnimation ( config ) : Ext.fx.Anim

Starts a custom animation on this Element.

The following properties may be specified in from, to, and keyframe objects:

  • x - The page X position in pixels.
  • y - The page Y position in pixels
  • left - The element's CSS left value. Units must be supplied.
  • top - The element's CSS top value. Units must be supplied.
  • width - The element's CSS width value. Units must be supplied.
  • height - The element's CSS height value. Units must be supplied.
  • scrollLeft - The element's scrollLeft value.
  • scrollTop - The element's scrollTop value.
  • opacity - The element's opacity value (between 0 and 1).

Be aware that animating an Element which is being used by an Ext Component without in some way informing the Component about the changed element state will result in incorrect Component behaviour. This is because the Component will be using the old state of the element. To avoid this problem, it is now possible to directly animate certain properties of Components.

Parameters

config :  Object

Configuration for Ext.fx.Anim. Note that the to config is required.

Returns

:Ext.fx.Anim

The new animation.

addCls ( names, [prefix], [suffix] ) : Ext.dom.Element
chainable ch

Adds the given CSS class(es) to this Element.

Parameters

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.

Returns

:Ext.dom.Element

this

addClsOnClick ( className, [testFn], [scope] ) : Ext.dom.Element
chainable ch

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)

Parameters

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.

Returns

:Ext.dom.Element

this

addClsOnFocus ( className, [testFn], [scope] ) : Ext.dom.Element
chainable ch

Sets up event handlers to add and remove a css class when this element has the focus

Parameters

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.

Returns

:Ext.dom.Element

this

addClsOnOver ( className, [testFn], [scope] ) : Ext.dom.Element
chainable ch

Sets up event handlers to add and remove a css class when the mouse is over this element

Parameters

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.

Returns

:Ext.dom.Element

this

addDeprecations ( deprecations )
private pri

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

Parameters

deprecations :  Object

addKeyListener ( key, fn, [scope] ) : Ext.util.KeyMap

Convenience method for constructing a KeyMap

Parameters

key :  String/Number/Number[]/Object

Either a string with the keys to listen for, the numeric key code, array of key codes or an object with the following options:

key :  Number / Array

shift :  Boolean

ctrl :  Boolean

alt :  Boolean

fn :  Function

The function to call

scope :  Object (optional)

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

Returns

:Ext.util.KeyMap

The KeyMap created

addKeyMap ( config ) : Ext.util.KeyMap

Creates a KeyMap for this element

Parameters

config :  Object

The KeyMap config. See Ext.util.KeyMap for more details

Returns

:Ext.util.KeyMap

The KeyMap created

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

The on method is shorthand for addListener.

Appends an event handler to this object. For example:

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

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

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

One can also specify options for each event handler separately:

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

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

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

Parameters

eventName :  String/Object

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

fn :  Function/String (optional)

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

scope :  Object (optional)

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

options :  Object (optional)

An object containing handler configuration.

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

This object may contain any of the following properties:

scope :  Object

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

delay :  Number

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

single :  Boolean

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

buffer :  Number

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

onFrame :  Number

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

target :  Ext.util.Observable

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

element :  String

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

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

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

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

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

 panel.body.un(...)
                        

delegate :  String (optional)

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

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

See the delegate example below.

capture :  Boolean (optional)

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

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

stopPropagation :  Boolean (optional)

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

preventDefault :  Boolean (optional)

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

stopEvent :  Boolean (optional)

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

args :  Array (optional)

Optional set of arguments to pass to the handler function before the actual fired event arguments. For example, if args is set to ['foo', 42], the event handler function will be called with an arguments list like this:

 handler('foo', 42, <actual event arguments>...);
                        

destroyable :  Boolean (optional)

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

Defaults to:

false

priority :  Number (optional)

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

order :  String (optional)

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

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

Defaults to:

'current'

order :  String (optional)

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

Combining Options

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

A delayed, one-time listener.

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

Attaching multiple handlers in 1 call

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

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

Delegate

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

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

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

Defaults to: 'current'

Returns

:Object

Only when the destroyable option is specified.

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

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

And when those listeners need to be removed:

Ext.destroy(this.btnListeners);

or

this.btnListeners.destroy();

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

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

Example:

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

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

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

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

Parameters

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

The item to which to add a listener/listeners.

ename :  Object/String

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

fn :  Function/String (optional)

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

scope :  Object (optional)

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

options :  Object (optional)

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

Returns

:Object

Only when the destroyable option is specified.

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

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

And when those listeners need to be removed:

Ext.destroy(this.btnListeners);

or

this.btnListeners.destroy();

adjustDirect2DDimension ( dimension ) : Number
private pri

Returns the fractional portion of this element's measurement in the given dimension. (IE9+ only)

Parameters

dimension :  Object

Returns

:Number

adjustForConstraints ( xy, parent )
private pri

Parameters

xy :  Object

parent :  Object

alignTo ( element, [position], [offsets] ) : Ext.util.Positionable

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:

  • Blank: Defaults to aligning the element's top-left corner to the target's bottom-left corner ("tl-bl").
  • Two anchors: If two values from the table below are passed separated by a dash, the first value is used as the element's anchor point, and the second value is used as the target's anchor point.
  • Two edge/offset descriptors: An edge/offset descriptor is an edge initial (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.

In addition to the anchor points, the position parameter also supports the "?" character. If "?" is passed at the end of the position string, 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. Following are all of the supported 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

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

Parameters

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

Returns

:Ext.util.Positionable

this

anchorAnimX ( anchor )
private pri

Parameters

anchor :  Object

anchorTo ( anchorToEl, [alignment], [offsets], [animate], [monitorScroll], [callback] ) : Ext.util.Positionable
chainable ch

Anchors an element to another element and realigns it when the window is resized.

Parameters

anchorToEl :  Ext.util.Positionable/HTMLElement/String

The Positionable, HTMLElement, or id of the element to align to.

alignment :  String (optional)

The position to align to

Defaults to: "tl-bl?"

offsets :  Number[] (optional)

Offset the positioning by [x, y]

animate :  Boolean/Object (optional)

true for the default animation or a standard Element animation config object

monitorScroll :  Boolean/Number (optional)

True to monitor body scroll and reposition. If this parameter is a number, it is used as the buffer delay in milliseconds.

Defaults to: 50

callback :  Function (optional)

The function to call after the animation finishes

Returns

:Ext.util.Positionable

this

anim ( config )
private pri

process the passed fx configuration.

Parameters

config :  Object

animate ( config ) : Ext.dom.Element
chainable ch

Calls addAnimation and returns this Element (for call chaining). For details, see addAnimation.

Parameters

config :  Object

Configuration for Ext.fx.Anim. Note that the to config is required.

Returns

:Ext.dom.Element

this

appendChild ( el, [returnDom] ) : Ext.dom.Element/HTMLElement

Appends the passed element(s) to this element

Parameters

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

Returns

:Ext.dom.Element/HTMLElement

The inserted Ext.dom.Element (or HTMLElement if returnDom is true).

appendTo ( el ) : Ext.dom.Element
chainable ch

Appends this element to the passed element.

Parameters

el :  String/HTMLElement/Ext.dom.Element

The new parent element. The id of the node, a DOM Node or an existing Element.

Returns

:Ext.dom.Element

This element.

applyStyles ( styles ) : Ext.dom.Element
chainable ch

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

Parameters

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.

Returns

:Ext.dom.Element

this

blur Ext.dom.Element
chainable ch

Tries to blur the element. Any exceptions are caught and ignored.

Returns

:Ext.dom.Element

this

boxWrap ( [class] ) : Ext.dom.Element

Wraps the specified element with a special 9 element markup/CSS block that renders by default as a gray container with a gradient background, rounded corners and a 4-way shadow.

This special markup is used throughout Ext when box wrapping elements (Ext.button.Button, Ext.panel.Panel when frame=true, Ext.window.Window). The markup is of this form:

<div class="{0}-tl"><div class="{0}-tr"><div class="{0}-tc"></div></div></div>
<div class="{0}-ml"><div class="{0}-mr"><div class="{0}-mc"></div></div></div>
<div class="{0}-bl"><div class="{0}-br"><div class="{0}-bc"></div></div></div>

Example usage:

// Basic box wrap
Ext.get("foo").boxWrap();

// You can also add a custom class and use CSS inheritance rules to customize the box look.
// 'x-box-blue' is a built-in alternative -- look at the related CSS definitions as an example
// for how to create a custom box wrap style.
Ext.get("foo").boxWrap().addCls("x-box-blue");

Parameters

class :  String (optional)

A base CSS class to apply to the containing wrapper element. Note that there are a number of CSS rules that are dependent on this name to make the overall effect work, so if you supply an alternate base class, make sure you also supply all of the necessary rules.

Defaults to: 'x-box'

Returns

:Ext.dom.Element

The outermost wrapping element of the created box structure.

cacheScrollValues Function

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

Returns

:Function

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.

calculateAnchorXY ( [anchor], [extraX], [extraY], [size] ) : Number[]
private pri

Calculates x,y coordinates specified by the anchor position on the element, adding extraX and extraY values.

Parameters

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)

Returns

:Number[]

[x, y] An array containing the element's x and y coordinates

calculateConstrainedPosition ( [constrainTo], [proposedPosition], [local], [proposedSize] ) : Number[]
private pri

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.

Parameters

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 {@link 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.

Returns

:Number[]

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.

callOverridden ( args ) : Object
deprecated dep protected pro

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

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

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

        this.callOverridden();

        alert("Meeeeoooowwww");
    }
});

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

Parameters

args :  Array/Arguments

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

Returns

:Object

Returns the result of calling the overridden method

Deprecated since version 4.1.0
Use method-callParent instead.

callParent ( args ) : Object
protected pro

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

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

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

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

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

 var obj = new My.Derived();

 alert(obj.x);  // alerts 21

This can be used with an override as follows:

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

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

 var obj = new My.Derived();

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

This also works with static and private methods.

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

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

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

Lastly, it also works with overridden static methods.

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

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

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

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

Parameters

args :  Array/Arguments

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

Returns

:Object

Returns the result of calling the parent method

callSuper ( args ) : Object
protected pro

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

Consider:

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

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

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

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

         this.callParent();
     }
 });

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

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

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

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

         this.callSuper();
     }
 });

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

Parameters

args :  Array/Arguments

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

Returns

:Object

Returns the result of calling the superclass method

center ( centerIn ) : Ext.dom.Element
chainable ch

Centers the Element in either the viewport, or another Element.

Parameters

centerIn :  String/HTMLElement/Ext.dom.Element

element in which to center the element.

Returns

:Ext.dom.Element

This element

child ( selector, [returnDom] ) : HTMLElement/Ext.dom.Element

Selects a single direct child based on the passed CSS selector (the selector should not contain an id).

Parameters

selector :  String

The CSS selector.

returnDom :  Boolean (optional)

true to return the DOM node instead of Ext.dom.Element.

Defaults to: false

Returns

:HTMLElement/Ext.dom.Element

The child Ext.dom.Element (or DOM node if returnDom is true)

clean ( [forceReclean] ) :
chainable ch

Removes Empty, or whitespace filled text nodes. Combines adjacent text nodes.

Parameters

forceReclean :  Boolean (optional)

By default the element keeps track if it has been cleaned already so you can call this over and over. However, if you update the element and need to force a re-clean, you can pass true.

Defaults to: false

Returns

:

clearClip
private pri

Clears any clipping applied to this component by method-clipTo.

clearListeners

Removes all listeners for this object including the managed listeners

clearManagedListeners

Removes all managed listeners for this object.

clearOpacity Ext.dom.Element

Clears any opacity settings from this element. Required in some cases for IE.

Returns

:Ext.dom.Element

this

clearPositioning ( [value] ) : Ext.dom.Element

Clears positioning back to the default when the document was loaded.

Parameters

value :  String (optional)

The value to use for the left, right, top, bottom. You could use 'auto'.

Defaults to: ''

Returns

:Ext.dom.Element

this

clip Ext.dom.Element
chainable ch

Store the current overflow setting and clip overflow on the element - use unclip to remove

Returns

:Ext.dom.Element

this

clipTo ( clippingEl, sides )
private pri

Clips this Component/Element to fit within the passed element's or component's view area

Parameters

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 ( [deep], [returnDom] ) : HTMLElement/Ext.dom.Element

Clone this element.

Parameters

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

Returns

:HTMLElement/Ext.dom.Element

The newly cloned Ext.dom.Element (or DOM node if returnDom is true).

collect
private pri

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.

constrainBox ( box )
private pri

Parameters

box :  Object

constructor ( element )
private pri

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.

Parameters

element :  String/HTMLElement

contains ( element ) : Boolean

Returns true if this element is an ancestor of the passed element, or is the element.

Parameters

element :  String/HTMLElement/Ext.dom.Element

The dom element, Ext.dom.Element, or id (string) of the dom element to check.

Returns

:Boolean

True if this element is an ancestor of el or the el itself, else false

convertPositionSpec ( posSpec )
private pri

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.

Parameters

posSpec :  Object

createChild ( config, [insertBefore], [returnDom] ) : Ext.dom.Element/HTMLElement

Creates the passed DomHelper config and appends it to this element or optionally inserts it before the passed child element.

Parameters

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

Returns

:Ext.dom.Element/HTMLElement

The new child element (or HTMLElement if returnDom is true)

createProxy ( config, [renderTo], [matchBox] ) : Ext.dom.Element

Creates a proxy element of this element

Parameters

config :  String/Object

The class name of the proxy element or a DomHelper config object

renderTo :  String/HTMLElement (optional)

The element or element id to render the proxy to. Defaults to: document.body.

matchBox :  Boolean (optional)

True to align and size the proxy to this element now.

Defaults to: false

Returns

:Ext.dom.Element

The new proxy element

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

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

Parameters

newName :  String

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

beginEnd :  Array (optional)

The caller can specify on which indices to slice.

Returns

:Function

cssTranslate
deprecated dep removed rem

Translates an element using CSS 3 in 2D.

Deprecated
cssTranslate

This method has been REMOVED since 5.0.0

destroy

Destroys this element by removing it from the cache, removing its DOM reference, and removing all of its event listeners.

disableShadow
private pri

Disables the shadow element created by enableShadow.

disableShim
private pri

Disables the shim element created by enableShim.

doFireEvent ( eventName, args, bubbles )
private pri

Continue to fire event.

Parameters

eventName :  String

args :  Array

bubbles :  Boolean

doReplaceWith ( element )
private pri

Parameters

element :  Object

doScrollIntoView ( container, hscroll, animate, highlight, getScrollX, scrollTo ) :
chainable ch private pri

A scrollIntoView implementation for scrollIntoView/rtlScrollIntoView to call after current scrollX has been determined.

Parameters

container :  Object

hscroll :  Object

animate :  Object

highlight :  Object

getScrollX :  Object

scrollTo :  Object

Returns

:

down ( selector, [returnDom] ) : HTMLElement/Ext.dom.Element

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.

Parameters

selector :  String

The CSS selector

returnDom :  Boolean (optional)

true to return the DOM node instead of Ext.dom.Element

Defaults to: false

Returns

:HTMLElement/Ext.dom.Element

The child Ext.dom.Element (or DOM node if returnDom is true)

empty

Empties this element. Removes all child nodes.

enableBubble ( eventNames )

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

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

Example:

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

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

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

Parameters

eventNames :  String/String[]

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

enableDisplayMode ( [display] ) : Ext.dom.Element
chainable ch

Convenience method for setVisibilityMode(Element.DISPLAY).

Parameters

display :  String (optional)

What to set display to when visible

Returns

:Ext.dom.Element

this

enableShadow ( [options] )
private pri

Enables a shadow element that will always display behind this element

Parameters

options :  Object (optional)

Configuration options for the shadow

offset :  Number (optional)

Number of pixels to offset the shadow

Defaults to:

4

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

enableShim ( [options] ) : Ext.dom.Shim
private pri

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.

Parameters

options :  Object (optional)

Configuration options for the shim

Returns

:Ext.dom.Shim

The new Shim

fadeIn ( [options] ) : Ext.dom.Element
chainable ch

Fade an element in (from transparent to opaque). The ending opacity can be specified using the opacity config option. Usage:

// default: fade in from opacity 0 to 100%
el.fadeIn();

// custom: fade in from opacity 0 to 75% over 2 seconds
el.fadeIn({ opacity: .75, duration: 2000});

// common config options shown with default values
el.fadeIn({
    opacity: 1, //can be any value between 0 and 1 (e.g. .5)
    easing: 'easeOut',
    duration: 500
});

Parameters

options :  Object (optional)

Object literal with any of the Ext.fx.Anim config options

Returns

:Ext.dom.Element

The Element

fadeOut ( [options] ) : Ext.dom.Element
chainable ch

Fade an element out (from opaque to transparent). The ending opacity can be specified using the opacity config option. Note that IE may require useDisplay:true in order to redisplay correctly. Usage:

// default: fade out from the element's current opacity to 0
el.fadeOut();

// custom: fade out from the element's current opacity to 25% over 2 seconds
el.fadeOut({ opacity: .25, duration: 2000});

// common config options shown with default values
el.fadeOut({
    opacity: 0, //can be any value between 0 and 1 (e.g. .5)
    easing: 'easeOut',
    duration: 500,
    remove: false,
    useDisplay: false
});

Parameters

options :  Object (optional)

Object literal with any of the Ext.fx.Anim config options

Returns

:Ext.dom.Element

The Element

findParent ( selector, [limit], [returnEl] ) : HTMLElement/Ext.dom.Element

Looks at this node and then at parent nodes for a match of the passed simple selector.

Parameters

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

Returns

:HTMLElement/Ext.dom.Element

The matching DOM node (or Ext.dom.Element if returnEl is true). Or null if no match was found.

findParentNode ( selector, [limit], [returnEl] ) : HTMLElement/Ext.dom.Element

Looks at parent nodes for a match of the passed simple selector.

Parameters

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

Returns

:HTMLElement/Ext.dom.Element

The matching DOM node (or Ext.dom.Element if returnEl is true). Or null if no match was found.

findTabbableElements ( options )
private pri

Parameters

options :  Object

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

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

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

Parameters

eventName :  String

The name of the event to fire.

args :  Array

Arguments to pass to handlers and to the action function.

fn :  Function

The action function.

scope :  Object (optional)

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

options :  Object (optional)

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

order :  String (optional)

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

Defaults to: 'before'

Deprecated since version 5.5
Use fireEventedAction instead.

fireEvent ( eventName, args ) : Boolean

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

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

Parameters

eventName :  String

The name of the event to fire.

args :  Object...

Variable number of parameters are passed to handlers.

Returns

:Boolean

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

fireEventArgs ( eventName, args ) : Boolean

Fires the specified event with the passed parameter list.

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

Parameters

eventName :  String

The name of the event to fire.

args :  Object[]

An array of parameters which are passed to handlers.

Returns

:Boolean

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

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

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

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

Parameters

eventName :  String

The name of the event to fire.

args :  Array

Arguments to pass to handlers and to the action function.

fn :  Function/String

The action function.

scope :  Object (optional)

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

fnArgs :  Array/Boolean (optional)

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

Returns

:Boolean

first ( [selector], [returnDom] ) : Ext.dom.Element/HTMLElement

Gets the first child, skipping text nodes

Parameters

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

Returns

:Ext.dom.Element/HTMLElement

The first child or null

focus ( [defer] ) : Ext.dom.Element
chainable ch

Try to focus the element either immediately or after a timeout if defer argument is specified.

Parameters

defer :  Number (optional)

Milliseconds to defer the focus

Returns

:Ext.dom.Element

this

focusable Boolean
deprecated dep

Checks whether this element can be focused.

Returns

:Boolean

True if the element is focusable

Deprecated since version 5.0.0
use isFocusable instead

frame ( [color], [count], [options] ) : Ext.dom.Element
chainable ch

Shows a ripple of exploding, attenuating borders to draw attention to an Element. Usage:

// default: a single light blue ripple
el.frame();

// custom: 3 red ripples lasting 3 seconds total
el.frame("#ff0000", 3, { duration: 3000 });

// common config options shown with default values
el.frame("#C3DAF9", 1, {
    duration: 1000 // duration of each individual ripple.
    // Note: Easing is not configurable and will be ignored if included
});

Parameters

color :  String (optional)

The hex color value for the border.

Defaults to: '#C3DAF9'

count :  Number (optional)

The number of ripples to display.

Defaults to: 1

options :  Object (optional)

Object literal with any of the Ext.fx.Anim config options

Returns

:Ext.dom.Element

The Element

getActiveAnimation Ext.fx.Anim/Boolean

Returns the current animation if this object has any effects actively running or queued, else returns false.

Returns

:Ext.fx.Anim/Boolean

Anim if element has active effects, else false

getAlignToXY ( alignToEl, [position], [offsets] ) : Number[]

Gets the x,y coordinates to align this element with another element. See alignTo for more info on the supported position values.

Parameters

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]

Returns

:Number[]

[x, y]

getAnchorToXY ( el, [anchor], [local], [size] ) : Number[]
private pri

Gets the x,y coordinates of an element specified by the anchor position on the element.

Parameters

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)

Returns

:Number[]

[x, y] An array containing the element's x and y coordinates

getAnchorXY ( [anchor], [local], [size] ) : Number[]

Gets the x,y coordinates specified by the anchor position on the element.

Parameters

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)

Returns

:Number[]

[x, y] An array containing the element's x and y coordinates

getAnimationProps
private pri

Get animation properties

getAttribute ( name, [namespace] ) : String

Returns the value of an attribute from the element's underlying DOM node.

Parameters

name :  String

The attribute name.

namespace :  String (optional)

The namespace in which to look for the attribute.

Returns

:String

The attribute value.

getAttributeNS ( namespace, name ) : String
deprecated dep

Returns the value of a namespaced attribute from the element's underlying DOM node.

Parameters

namespace :  String

The namespace in which to look for the attribute

name :  String

The attribute name

Returns

:String

The attribute value

Deprecated since version 5.0.0
Please use Ext.dom.Element#getAttribute instead.

getAttributes Object

Returns an object containing a map of all attributes of this element's DOM node.

Returns

:Object

Key/value pairs of attribute names and their values.

getBorderPadding Object
private pri

Returns the size of the element's borders and padding.

Returns

:Object

an object with the following numeric properties

  • beforeX
  • afterX
  • beforeY
  • afterY

getBorderWidth ( side ) : Number

Gets the width of the border(s) for the specified side(s)

Parameters

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.

Returns

:Number

The width of the sides passed added together

getBottom ( local ) : Number

Gets the bottom Y coordinate of the element (element Y position + element height)

Parameters

local :  Boolean

True to get the local css position instead of page coordinate

Returns

:Number

getBox ( [contentBox], [local] ) : Object

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.

Parameters

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.

Returns

:Object

An object in the format

x :  Number

The element's X position.

y :  Number

The element's Y position.

width :  Number

The element's width.

height :  Number

The element's height.

bottom :  Number

The element's lower bound.

right :  Number

The 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. The result may also be used for setXY

getBubbleParent Ext.util.Observable
private pri

Gets the bubbling parent for an Observable

Returns

:Ext.util.Observable

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

getById ( id, [asDom] ) : Ext.dom.Element/HTMLElement

Returns a child element of this element given its id.

Parameters

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

Returns

:Ext.dom.Element/HTMLElement

The child element (or HTMLElement if asDom is true). Or null if no match was found.

getCenterXY Number[]
deprecated dep

Calculates the x, y to center this element on the screen

Returns

:Number[]

The x, y values [x, y]

Deprecated since version 5.0.0
Use Ext.dom.Element#getAlignToXY instead. el.getAlignToXY(document, 'c-c');

getClientRegion Ext.util.Region

Returns a region object that defines the client area of this element.

That is, the area within any scrollbars.

Returns

:Ext.util.Region

A Region containing "top, left, bottom, right" properties.

getColor ( attr, defaultValue, [prefix] )
private pri

Return the CSS color for the specified CSS attribute. rgb, 3 digit (like #fff) and valid values are convert to standard 6 digit hex color.

Parameters

attr :  String

The css attribute

defaultValue :  String

The default value to use when a valid color isn't found

prefix :  String (optional)

defaults to #. Use an empty string when working with color anims.

getComputedHeight Number
deprecated dep

Returns either the offsetHeight or the height of this element based on CSS height adjusted by padding or borders when needed to simulate offsetHeight when offsets aren't available. This may not work on display:none elements if a height has not been set using CSS.

Returns

:Number

Deprecated since version 5.0.0
use Ext.dom.Element#getHeight instead

getComputedWidth Number
deprecated dep

Returns either the offsetWidth or the width of this element based on CSS width adjusted by padding or borders when needed to simulate offsetWidth when offsets aren't available. This may not work on display:none elements if a width has not been set using CSS.

Returns

:Number

Deprecated since version 5.0.0
use Ext.dom.Element#getWidth instead.

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

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

Parameters

name :  String (optional)

The name of the config property to get.

peek :  Boolean (optional)

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

Defaults to: false

Returns

:Object

The config property value.

getConstrainRegion Ext.util.Region

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.

Returns

:Ext.util.Region

A Region containing "top, left, bottom, right" properties.

getConstrainVector ( [constrainTo], [proposedPosition], [proposedSize] ) : Number[]/Boolean

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.

Parameters

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

Returns

:Number[]/Boolean

If the element needs to be translated, an [X, Y] vector by which this element must be translated. Otherwise, false.

getHTML String
deprecated dep

Returns the innerHTML of an Element or an empty string if the element's dom no longer exists.

Returns

:String

Deprecated since version 5.0.0
Please use getHtml instead.

getHeight ( [contentHeight] ) : Number

Returns the offset height of the element.

Parameters

contentHeight :  Boolean (optional)

true to get the height minus borders and padding.

Returns

:Number

The element's height.

getHtml String

Returns the innerHTML of an Element or an empty string if the element's dom no longer exists.

Returns

:String

getId String

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

Returns

:String

id

getInitialConfig ( [name] ) : Object/Mixed

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

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

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

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

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

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

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

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

Parameters

name :  String (optional)

Name of the config option to return.

Returns

:Object/Mixed

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

getLeft ( local ) : Number

Gets the left X coordinate

Parameters

local :  Boolean

True to get the local css position instead of page coordinate

Returns

:Number

getLoader Ext.ElementLoader

Gets this element's Ext.ElementLoader

Returns

:Ext.ElementLoader

The loader

getLocalX Number

Returns the x coordinate of this element reletive to its offsetParent.

Returns

:Number

The local x coordinate

getLocalXY Number[]

Returns the x and y coordinates of this element relative to its offsetParent.

Returns

:Number[]

The local XY position of the element

getLocalY Number

Returns the y coordinate of this element reletive to its offsetParent.

Returns

:Number

The local y coordinate

getMargin ( [sides] ) : Object/Number

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

Parameters

sides :  String (optional)

Any combination of 'l', 'r', 't', 'b' to get the sum of those sides.

Returns

:Object/Number

getOffsetsTo ( offsetsTo ) : Number[]

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.

Parameters

offsetsTo :  Ext.util.Positionable/HTMLElement/String

The Positionable, HTMLElement, or element id to get get the offsets from.

Returns

:Number[]

The XY page offsets (e.g. [100, -200])

getOuterHeight
deprecated dep removed rem

Retrieves the height of the element account for the top and bottom margins.

Deprecated
getOuterHeight

This method has been REMOVED since 5.0.0

getOuterWidth
deprecated dep removed rem

Retrieves the width of the element accounting for the left and right margins.

Deprecated
getOuterWidth

This method has been REMOVED since 5.0.0

getPadding ( side ) : Number

Gets the width of the padding(s) for the specified side(s).

Parameters

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.

Returns

:Number

The padding of the sides passed added together.

getPageBox ( [asRegion] ) : Object/Ext.util.Region
deprecated dep

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.

Parameters

asRegion :  Boolean (optional)

If true an Ext.util.Region will be returned

Returns

:Object/Ext.util.Region

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.

getPositioning ( [autoPx] ) : Object

Gets an object with all CSS positioning properties. Useful along with setPositioning to get snapshot before performing an update and then restoring the element.

Parameters

autoPx :  Boolean (optional)

true to return pixel values for "auto" styles.

Defaults to: false

Returns

:Object

getRegion ( [contentBox] ) : Ext.util.Region

Returns a region object that defines the area of this element.

Parameters

contentBox :  Boolean (optional)

If true a box for the content of the element is returned.

Returns

:Ext.util.Region

A Region containing "top, left, bottom, right" properties.

getRight ( local ) : Number

Gets the right X coordinate of the element (element X position + element width)

Parameters

local :  Boolean

True to get the local css position instead of page coordinates

Returns

:Number

getRightMarginFixCleaner ( target )
private pri

Creates a function to call to clean up problems with the work-around for the WebKit RightMargin bug. The work-around is to add "display: 'inline-block'" to the element before calling getComputedStyle and then to restore its original display value. The problem with this is that it corrupts the selection of an INPUT or TEXTAREA element (as in the "I-beam" goes away but the focus remains). To cleanup after this, we need to capture the selection of any such element and then restore it after we have restored the display style.

Parameters

target :  HTMLElement

The top-most element being adjusted.

getScroll Object

Returns the current scroll position of the element.

Returns

:Object

An object containing the scroll position in the format {left: (scrollLeft), top: (scrollTop)}

getScrollIntoViewXY ( container, scrollX, scrollY ) : Object
private pri

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.

Parameters

container :  String/HTMLElement/Ext.dom.Element

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

Returns

:Object

An object with "x" and "y" properties

getScrollLeft Number

Gets the left scroll position

Returns

:Number

The left scroll position

getScrollParent
deprecated dep removed rem

Gets the Scroller instance of the first parent that has one.

Deprecated
getScrollParent

This method has been REMOVED since 5.0.0

getScrollTop Number

Gets the top scroll position

Returns

:Number

The top scroll position

getSize ( [contentSize] ) : Object

Returns the size of the element.

Parameters

contentSize :  Boolean (optional)

true to get the width/size minus borders and padding.

Returns

:Object

An object containing the element's size:

width :  Number

height :  Number

getStyle ( property, [inline] ) : String/Object

Returns a named style property based on computed/currentStyle (primary) and inline-style if primary is not available.

Parameters

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

Returns

:String/Object

The current value of the style property for this element (or a hash of named style values if multiple property arguments are requested).

getStyleSize Object
deprecated dep

Returns the dimensions of the element available to lay content out in.

getStyleSize utilizes prefers style sizing if present, otherwise it chooses the larger of offsetHeight/clientHeight and offsetWidth/clientWidth. To obtain the size excluding scrollbars, use getViewSize.

Sizing of the document body is handled at the adapter level which handles special cases for IE and strict modes, etc.

Returns

:Object

Object describing width and height.

width :  Number

height :  Number

Deprecated since version 5.0.0
Use Ext.dom.Element#getSize instead.

getTextWidth ( text, [min], [max] ) : Number

Returns the width in pixels of the passed text, or the width of the text in this Element.

Parameters

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.

Returns

:Number

The text width in pixels.

getTop ( local ) : Number

Gets the top Y coordinate

Parameters

local :  Boolean

True to get the local css position instead of page coordinates

Returns

:Number

getTouchAction Object

Returns this element's touch action. (see setTouchAction)

The returned object is shared and should not be mutated.

Returns

:Object

getValue ( asNumber ) : String/Number

Returns the value of the value attribute.

Parameters

asNumber :  Boolean

true to parse the value as a number.

Returns

:String/Number

getViewRegion Ext.util.Region

Returns the content region of this element. That is the region within the borders and padding.

Returns

:Ext.util.Region

A Region containing "top, left, bottom, right" member data.

getViewSize Object

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.

Returns

:Object

Object describing width and height.

width :  Number

height :  Number

getWidth ( [contentWidth] ) : Number

Returns the offset width of the element.

Parameters

contentWidth :  Boolean (optional)

true to get the width minus borders and padding.

Returns

:Number

The element's width.

getX Number

Gets element X position in page coordinates

Returns

:Number

getXY Array

Gets element X and Y positions in page coordinates

Returns

:Array

[x, y]

getY Number

Gets element Y position in page coordinates

Returns

:Number

getZIndex Number

Returns this element's z-index

Returns

:Number

ghost ( [anchor], [options] ) : Ext.dom.Element
chainable ch

Slides the element while fading it out of view. An anchor point can be optionally passed to set the ending point of the effect. Usage:

// default: slide the element downward while fading out
el.ghost();

// custom: slide the element out to the right with a 2-second duration
el.ghost('r', { duration: 2000 });

// common config options shown with default values
el.ghost('b', {
    easing: 'easeOut',
    duration: 500
});

Parameters

anchor :  String (optional)

One of the valid Ext.fx.Anim anchor positions (defaults to bottom: 'b')

options :  Object (optional)

Object literal with any of the Ext.fx.Anim config options

Returns

:Ext.dom.Element

The Element

hasActiveFx Ext.fx.Anim/Boolean
deprecated dep

Returns the current animation if this object has any effects actively running or queued, else returns false.

Returns

:Ext.fx.Anim/Boolean

Anim if element has active effects, else false

Deprecated since version 4.0
Replaced by getActiveAnimation

hasCls ( name ) : Boolean

Checks if the specified CSS class exists on this element's DOM node.

Parameters

name :  String

The CSS class to check for.

Returns

:Boolean

true if the class exists, else false.

hasConfig ( name )
private pri

Parameters

name :  String

hasListener ( eventName ) : Boolean

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

Parameters

eventName :  String

The name of the event to check for

Returns

:Boolean

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

hide Ext.dom.Element
chainable ch

Hide this element - Uses display mode to determine whether to use "display", "visibility", or "offsets". See setVisible.

Returns

:Ext.dom.Element

this

highlight ( [color], [options] ) : Ext.dom.Element
chainable ch

Highlights the Element by setting a color (applies to the background-color by default, but can be changed using the "attr" config option) and then fading back to the original color. If no original color is available, you should provide the "endColor" config option which will be cleared after the animation. Usage:

// default: highlight background to yellow
el.highlight();

// custom: highlight foreground text to blue for 2 seconds
el.highlight("0000ff", { attr: 'color', duration: 2000 });

// common config options shown with default values
el.highlight("ffff9c", {
    attr: "backgroundColor", //can be any valid CSS property (attribute) that supports a color value
    endColor: (current color) or "ffffff",
    easing: 'easeIn',
    duration: 1000
});

Parameters

color :  String (optional)

The highlight color. Should be a 6 char hex color without the leading # (defaults to yellow: 'ffff9c')

options :  Object (optional)

Object literal with any of the Ext.fx.Anim config options

Returns

:Ext.dom.Element

The Element

hover ( overFn, outFn, [scope], [options] ) : Ext.dom.Element
chainable ch

Sets up event handlers to call the passed functions when the mouse is moved into and out of the Element.

Parameters

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 {@link Ext.util.Observable#method!addListener the options parameter}.

Returns

:Ext.dom.Element

this

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

Initialize configuration for this class. a typical example:

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

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

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

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

Parameters

instanceConfig :  Object

Returns

:Ext.Base

this

initDD ( group, config, overrides ) : Ext.dd.DD

Initializes a Ext.dd.DD drag drop object for this element.

Parameters

group :  String

The group the DD object is member of

config :  Object

The DD config object

overrides :  Object

An object containing methods to override/implement on the DD object

Returns

:Ext.dd.DD

The DD object

initDDProxy ( group, config, overrides ) : Ext.dd.DDProxy

Initializes a Ext.dd.DDProxy object for this element.

Parameters

group :  String

The group the DDProxy object is member of

config :  Object

The DDProxy config object

overrides :  Object

An object containing methods to override/implement on the DDProxy object

Returns

:Ext.dd.DDProxy

The DDProxy object

initDDTarget ( group, config, overrides ) : Ext.dd.DDTarget

Initializes a Ext.dd.DDTarget object for this element.

Parameters

group :  String

The group the DDTarget object is member of

config :  Object

The DDTarget config object

overrides :  Object

An object containing methods to override/implement on the DDTarget object

Returns

:Ext.dd.DDTarget

The DDTarget object

insertAfter ( el ) : Ext.dom.Element
chainable ch

Inserts this element after the passed element in the DOM.

Parameters

el :  String/HTMLElement/Ext.dom.Element

The element to insert after. The id of the node, a DOM Node or an existing Element.

Returns

:Ext.dom.Element

This element.

insertBefore ( el ) : Ext.dom.Element
chainable ch

Inserts this element before the passed element in the DOM.

Parameters

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.

Returns

:Ext.dom.Element

This element.

insertFirst ( el, [returnDom] ) : Ext.dom.Element/HTMLElement

Inserts (or creates) an element as the first child of this element

Parameters

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

Returns

:Ext.dom.Element/HTMLElement

The new child element (or HTMLElement if returnDom is true).

insertHtml ( where, html, [returnEl] ) : HTMLElement/Ext.dom.Element

Inserts an html fragment into this element

Parameters

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

Returns

:HTMLElement/Ext.dom.Element

The inserted node (or nearest related if more than 1 inserted)

insertSibling ( el, [where], [returnDom] ) : Ext.dom.Element/HTMLElement

Inserts (or creates) the passed element (or DomHelper config) as a sibling of this element

Parameters

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

Returns

:Ext.dom.Element/HTMLElement

The inserted Ext.dom.Element (or HTMLElement if returnDom is true). If an array is passed, the last inserted element is returned.

is ( selector ) : Boolean

Returns true if this element matches the passed simple selector (e.g. 'div.some-class' or 'span:first-child').

Parameters

selector :  String/Function

The simple selector to test or a function which is passed candidate nodes, and should return true for nodes which match.

Returns

:Boolean

true if this element matches the selector, else false.

isAncestor ( el ) : Boolean

Returns true if this element is an ancestor of the passed element

Parameters

el :  String/HTMLElement/Ext.dom.Element

The element or id of the element to search for in this elements descendants.

Returns

:Boolean

isBorderBox Boolean

Returns true if this element uses the border-box-sizing model. This method is deprecated as of version 5.0 because border-box sizing is forced upon all elements via a style sheet rule, and the browsers that do not support border-box (IE6/7 strict mode) are no longer supported.

Returns

:Boolean

isDescendent
deprecated dep removed rem

Determines if this element is a descendant of the passed in Element.

Deprecated
isDescendent

This method has been REMOVED since 5.0.0

isDisplayed Boolean
deprecated dep

Returns true if display is not "none"

Returns

:Boolean

Deprecated since version 5.0.0
use element.isStyle('display', 'none');

isFocusable Boolean

Checks whether this element can be focused programmatically or by clicking. To check if an element is in the document tab flow, use isTabbable.

Returns

:Boolean

True if the element is focusable

isInputField Boolean

Returns true if this Element is an input field, or is editable in any way.

Returns

:Boolean

true if this Element is an input field, or is editable in any way.

isMasked ( [deep] ) : Boolean

Returns true if this element is masked. Also re-centers any displayed message within the mask.

Parameters

deep :  Boolean (optional)

Go up the DOM hierarchy to determine if any parent element is masked.

Returns

:Boolean

isScrollable Boolean

Returns true if this element is scrollable.

Returns

:Boolean

isStyle ( style, value ) : Boolean

Checks if the current value of a style is equal to a given value.

Parameters

style :  String

property whose value is returned.

value :  String

to check against.

Returns

:Boolean

true for when the current value equals the given value.

isSuspended ( [event] ) : Boolean

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

Parameters

event :  String (optional)

The name of the specific event to check

Returns

:Boolean

true if events are suspended

isTabbable ( [includeHidden] ) : Boolean

Checks whether this element participates in the sequential focus navigation, and can be reached by using Tab key.

Parameters

includeHidden :  Boolean (optional)

pass true if hidden, or unattached elements should be returned.

Defaults to: false

Returns

:Boolean

True if the element is tabbable.

isTransparent ( prop ) : Boolean

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.

Parameters

prop :  String

The style property whose value is to be tested.

Returns

:Boolean

true if the style property is visually transparent.

isVisible ( [deep] ) : Boolean

Checks whether the element is currently visible using both visibility and display properties.

Parameters

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

Returns

:Boolean

true if the element is currently visible, else false

last ( [selector], [returnDom] ) : Ext.dom.Element/HTMLElement

Gets the last child, skipping text nodes

Parameters

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

Returns

:Ext.dom.Element/HTMLElement

The last child Ext.dom.Element (or HTMLElement if returnDom is true). Or null if no match is found.

load ( options ) : Ext.dom.Element
chainable ch

Direct access to the Ext.ElementLoader Ext.ElementLoader#method-load method. The method takes the same object parameter as Ext.ElementLoader#method-load

Parameters

options :  Object

a options object for Ext.ElementLoader Ext.ElementLoader#method-load

Returns

:Ext.dom.Element

this

makeSelectionRestoreFn

Helper function to create the function that will restore the selection.

mask ( [msg], [msgCls] ) : Ext.dom.Element

Puts a mask over this element to disable user interaction. This method can only be applied to elements which accept child nodes. Use unmask to remove the mask.

Parameters

msg :  String (optional)

A message to display in the mask

msgCls :  String (optional)

A css class to apply to the msg element

Returns

:Ext.dom.Element

The mask element

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

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

Example:

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

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

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

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

Parameters

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

The item to which to add a listener/listeners.

ename :  Object/String

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

fn :  Function/String (optional)

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

scope :  Object (optional)

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

options :  Object (optional)

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

Returns

:Object

Only when the destroyable option is specified.

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

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

And when those listeners need to be removed:

Ext.destroy(this.btnListeners);

or

this.btnListeners.destroy();

monitorMouseLeave ( delay, handler, [scope] ) : Object

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.

Parameters

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.

Returns

:Object

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 ( direction, distance )

Move the element relative to its current position.

Parameters

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

moveTo ( x, y, [animate] ) : Ext.dom.Element
deprecated dep

Sets the position of the element in page coordinates.

Parameters

x :  Number

X value for new position (coordinates are page-based)

y :  Number

Y value for new position (coordinates are page-based)

animate :  Boolean/Object (optional)

True for the default animation, or a standard Element animation config object

Returns

:Ext.dom.Element

this

Deprecated since version 4.2.0
Use Ext.dom.Element#setXY instead.

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

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

Parameters

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

The item from which to remove a listener/listeners.

ename :  Object/String

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

fn :  Function (optional)

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

scope :  Object (optional)

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

next ( [selector], [returnDom] ) : Ext.dom.Element/HTMLElement

Gets the next sibling, skipping text nodes

Parameters

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

Returns

:Ext.dom.Element/HTMLElement

The next sibling Ext.dom.Element (or HTMLElement if asDom is true). Or null if no match is found.

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

The on method is shorthand for addListener.

Appends an event handler to this object. For example:

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

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

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

One can also specify options for each event handler separately:

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

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

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

Parameters

eventName :  String/Object

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

fn :  Function/String (optional)

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

scope :  Object (optional)

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

options :  Object (optional)

An object containing handler configuration.

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

This object may contain any of the following properties:

scope :  Object

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

delay :  Number

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

single :  Boolean

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

buffer :  Number

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

onFrame :  Number

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

target :  Ext.util.Observable

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

element :  String

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

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

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

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

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

 panel.body.un(...)
                        

delegate :  String (optional)

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

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

See the delegate example below.

capture :  Boolean (optional)

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

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

stopPropagation :  Boolean (optional)

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

preventDefault :  Boolean (optional)

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

stopEvent :  Boolean (optional)

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

args :  Array (optional)

Optional set of arguments to pass to the handler function before the actual fired event arguments. For example, if args is set to ['foo', 42], the event handler function will be called with an arguments list like this:

 handler('foo', 42, <actual event arguments>...);
                        

destroyable :  Boolean (optional)

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

Defaults to:

false

priority :  Number (optional)

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

order :  String (optional)

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

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

Defaults to:

'current'

order :  String (optional)

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

Combining Options

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

A delayed, one-time listener.

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

Attaching multiple handlers in 1 call

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

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

Delegate

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

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

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

Defaults to: 'current'

Returns

:Object

Only when the destroyable option is specified.

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

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

And when those listeners need to be removed:

Ext.destroy(this.btnListeners);

or

this.btnListeners.destroy();

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

Appends an after-event handler.

Same as addListener with order set to 'after'.

Parameters

eventName :  String/String[]/Object

The name of the event to listen for.

fn :  Function/String

The method the event invokes.

scope :  Object (optional)

The scope for fn.

options :  Object (optional)

An object containing handler configuration.

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

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

Same as addListener with order set to 'before'.

Parameters

eventName :  String/String[]/Object

The name of the event to listen for.

fn :  Function/String

The method the event invokes.

scope :  Object (optional)

The scope for fn.

options :  Object (optional)

An object containing handler configuration.

parent ( [selector], [returnDom] ) : Ext.dom.Element/HTMLElement

Gets the parent node for this element, optionally chaining up trying to match a selector

Parameters

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

Returns

:Ext.dom.Element/HTMLElement

The parent node (Ext.dom.Element or HTMLElement if returnDom is true). Or null if no match is found.

pause ( seconds ) : Ext.dom.Element
chainable ch deprecated dep

Creates a pause before any subsequent queued effects begin. If there are no effects queued after the pause it will have no effect. Usage:

el.pause(1);

Parameters

seconds :  Number

The length of time to pause (in seconds)

Returns

:Ext.dom.Element

The Element

Deprecated since version 4.0
Use the `delay` config to animate instead.

position ( [pos], [zIndex], [x], [y] )

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.

Parameters

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

prev ( [selector], [returnDom] ) : Ext.dom.Element/HTMLElement

Gets the previous sibling, skipping text nodes

Parameters

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

Returns

:Ext.dom.Element/HTMLElement

The previous sibling (Ext.dom.Element or HTMLElement if returnDom is true). Or null if no match is found.

puff ( [options] ) : Ext.dom.Element
chainable ch

Fades the element out while slowly expanding it in all directions. When the effect is completed, the element will be hidden (visibility = 'hidden') but block elements will still take up space in the document. Usage:

// default
el.puff();

// common config options shown with default values
el.puff({
    easing: 'easeOut',
    duration: 500,
    useDisplay: false
});

Parameters

options :  Object (optional)

Object literal with any of the Ext.fx.Anim config options

Returns

:Ext.dom.Element

The Element

purgeAllListeners
deprecated dep

Removes all listeners for this object including the managed listeners

Deprecated since version 5.0.0
Please use clearListeners instead.

query ( selector, [asDom] ) : HTMLElement[]/Ext.dom.Element[]

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.

Element Selectors:

  • * any element
  • E an element with the tag E
  • E F All descendant elements of E that have the tag F
  • E > F or E/F all direct children elements of E that have the tag F
  • E + F all elements with the tag F that are immediately preceded by an element with the tag E
  • E ~ F all elements with the tag F that are preceded by a sibling element with the tag E

Attribute Selectors:

The use of @ and quotes are optional. For example, div[@foo='bar'] is also a valid attribute selector.

  • E[foo] has an attribute "foo"
  • E[foo=bar] has an attribute "foo" that equals "bar"
  • E[foo^=bar] has an attribute "foo" that starts with "bar"
  • E[foo$=bar] has an attribute "foo" that ends with "bar"
  • E[foo*=bar] has an attribute "foo" that contains the substring "bar"
  • E[foo%=2] has an attribute "foo" that is evenly divisible by 2
  • E[foo!=bar] has an attribute "foo" that does not equal "bar"

Pseudo Classes:

  • E:first-child E is the first child of its parent
  • E:last-child E is the last child of its parent
  • E:nth-child(n) E is the nth child of its parent (1 based as per the spec)
  • E:nth-child(odd) E is an odd child of its parent
  • E:nth-child(even) E is an even child of its parent
  • E:only-child E is the only child of its parent
  • E:checked E is an element that is has a checked attribute that is true (e.g. a radio or checkbox)
  • E:first the first E in the resultset
  • E:last the last E in the resultset
  • E:nth(n) the nth E in the resultset (1 based)
  • E:odd shortcut for :nth-child(odd)
  • E:even shortcut for :nth-child(even)
  • E:not(S) an E element that does not match simple selector S
  • E:has(S) an E element that has a descendant that matches simple selector S
  • E:next(S) an E element whose next sibling matches simple selector S
  • E:prev(S) an E element whose previous sibling matches simple selector S
  • E:any(S1|S2|S2) an E element which matches any of the simple selectors S1, S2 or S3//\

CSS Value Selectors:

  • E{display=none} CSS value "display" that equals "none"
  • E{display^=none} CSS value "display" that starts with "none"
  • E{display$=none} CSS value "display" that ends with "none"
  • E{display*=none} CSS value "display" that contains the substring "none"
  • E{display%=2} CSS value "display" that is evenly divisible by 2
  • E{display!=none} CSS value "display" that does not equal "none"

Parameters

selector :  String

The CSS selector.

asDom :  Boolean (optional)

false to return an array of Ext.dom.Element

Defaults to: true

Returns

:HTMLElement[]/Ext.dom.Element[]

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.

radioCls ( className ) : Ext.dom.Element

Adds one or more CSS classes to this element and removes the same class(es) from all siblings.

Parameters

className :  String/String[]

The CSS class to add, or an array of classes.

Returns

:Ext.dom.Element

this

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

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

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

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

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

Parameters

origin :  Object

The Observable whose events this object is to relay.

events :  String[]/Object

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

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

prefix :  String (optional)

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

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

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

Returns

:Object

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

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

Can be undone by calling

Ext.destroy(this.storeRelayers);

or this.store.relayers.destroy();

remove
deprecated dep

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.

removeAllListeners
deprecated dep

Removes all listeners for this object including the managed listeners

Deprecated since version 5.0.0
Please use clearListeners instead.

removeAnchor Ext.util.Positionable
chainable ch

Remove any anchor to this element. See anchorTo.

Returns

:Ext.util.Positionable

this

removeCls ( names, [prefix], [suffix] ) :
chainable ch

Removes the given CSS class(es) from this Element.

Parameters

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

Returns

:

removeListener ( eventName, fn, [scope] ) :
chainable ch

Removes an event handler.

Parameters

eventName :  String

The type of event the handler was associated with.

fn :  Function

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

scope :  Object (optional)

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

Convenience Syntax

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

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

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

Exception - DOM event handlers using the element config option

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

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

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

Returns

:

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

Removes listeners that were added by the mon method.

Parameters

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

The item from which to remove a listener/listeners.

ename :  Object/String

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

fn :  Function (optional)

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

scope :  Object (optional)

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

removeManagedListenerItem ( isClear, managedListener )
private pri

Remove a single managed listener item

Parameters

isClear :  Boolean

True if this is being called during a clear

managedListener :  Object

The managed listener item See removeManagedListener for other args

repaint Ext.dom.Element
chainable ch

Forces the browser to repaint this element.

Returns

:Ext.dom.Element

this

replace ( el, [destroy] ) : Ext.dom.Element
chainable ch

Replaces the passed element with this element

Parameters

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

Returns

:Ext.dom.Element

This element

replaceCls ( oldName, newName, [prefix], [suffix] ) : Ext.dom.Element
chainable ch

Replaces a CSS class on the element with another. If the old name does not exist, the new name will simply be added.

Parameters

oldName :  String

The CSS class to replace.

newName :  String

The replacement CSS class.

prefix :  String (optional)

Prefix to prepend to each class to be replaced.

Defaults to: ''

suffix :  String (optional)

Suffix to append to each class to be replaced.

Defaults to: ''

Returns

:Ext.dom.Element

this

replaceWith ( el ) : Ext.dom.Element
chainable ch

Replaces this element with the passed element

Parameters

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

Returns

:Ext.dom.Element

This element

resolveListenerScope ( [defaultScope] ) : Object
protected pro

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

Parameters

defaultScope :  Object (optional)

The default scope to return if none is found.

Defaults to: this

Returns

:Object

The default event scope

restoreTabbableState ( skipSelf, skipChildren ) :
chainable ch private pri

Parameters

skipSelf :  Object

skipChildren :  Object

Returns

:

resumeEvent ( eventName )

Resumes firing of the named event(s).

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

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

Parameters

eventName :  String...

Multiple event names to resume.

resumeEvents ( [discardQueue] )

Resumes firing events (see suspendEvents).

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

Parameters

discardQueue :  Boolean (optional)

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

reverseTranslateXY ( xy ) : Number[]
private pri

Converts local coordinates into page-level coordinates

Parameters

xy :  Number[]

The local x and y coordinates

Returns

:Number[]

The translated coordinates

saveTabbableState ( options )
private pri

Parameters

options :  Object

scale ( width, height, [options] ) : Ext.dom.Element
chainable ch deprecated dep

Animates the transition of an element's dimensions from a starting height/width to an ending height/width. This method is a convenience implementation of shift. Usage:

// change height and width to 100x100 pixels
el.scale(100, 100);

// common config options shown with default values.  The height and width will default to
// the element's existing values if passed as null.
el.scale(
    [element's width],
    [element's height], {
        easing: 'easeOut',
        duration: 350
    }
);

Parameters

width :  Number

The new width (pass undefined to keep the original width)

height :  Number

The new height (pass undefined to keep the original height)

options :  Object (optional)

Object literal with any of the Ext.fx.Anim config options

Returns

:Ext.dom.Element

The Element

Deprecated since version 4.0
Just use animate instead.

scroll ( direction, distance, [animate] ) : Boolean

Scrolls this element the specified direction. Does bounds checking to make sure the scroll is within this element's scrollable range.

Parameters

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

:Boolean

Returns true if a scroll was triggered or false if the element was scrolled as far as it could go.

scrollBy ( deltaX, deltaY, animate ) : Ext.dom.Element
chainable ch

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

Parameters

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.

Returns

:Ext.dom.Element

this

scrollChildIntoView ( child, hscroll )
private pri

Parameters

child :  Object

hscroll :  Object

scrollIntoView ( [container], [hscroll], [animate], [highlight] ) : Ext.dom.Element

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":"lisa@simpsons.com",  "phone":"555-111-1224"  },
          { 'name': 'Bart',  "email":"bart@simpsons.com",  "phone":"555-222-1234" },
          { 'name': 'Homer', "email":"homer@simpsons.com",  "phone":"555-222-1244"  },
          { 'name': 'Marge', "email":"marge@simpsons.com", "phone":"555-222-1254"  },
          { 'name': 'Milhouse', "email":"milhouse@simpsons.com",  "phone":"555-222-1244"  },
          { 'name': 'Willy', "email":"willy@simpsons.com", "phone":"555-222-1254"  },
          { 'name': 'Skinner', "email":"skinner@simpsons.com",  "phone":"555-222-1244"  },
          { 'name': 'Hank (last row)', "email":"hank@simpsons.com", "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);
          }
      }]
  });

Parameters

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

highlight :  Boolean (optional)

true to highlight the element when it is in view.

Defaults to: false

Returns

:Ext.dom.Element

this

scrollTo ( side, value, [animate] ) : Ext.dom.Element
chainable ch

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.

Parameters

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

Returns

:Ext.dom.Element

this

select ( selector, composite ) : Ext.dom.CompositeElementLite/Ext.dom.CompositeElement

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.

Parameters

selector :  String/HTMLElement[]

The CSS selector or an array of elements

composite :  Boolean

Return a CompositeElement as opposed to a CompositeElementLite. Defaults to false.

Returns

:Ext.dom.CompositeElementLite/Ext.dom.CompositeElement

selectNode ( selector, [asDom] ) : HTMLElement/Ext.dom.Element

Selects a single descendant element of this element using a CSS selector (see method-query).

Parameters

selector :  String

The selector query

asDom :  Boolean (optional)

false to return an Ext.dom.Element

Defaults to: true

Returns

:HTMLElement/Ext.dom.Element

The DOM element (or Ext.dom.Element if asDom is false) which matched the selector.

selectable Ext.dom.Element
chainable ch

Enable text selection for this element (normalized across browsers)

Returns

:Ext.dom.Element

this

sequenceFx Object
chainable ch

Ensures that all effects queued after sequenceFx is called on this object are run in sequence. This is the opposite of syncFx.

Returns

:Object

this

set ( attributes, [useSet] ) : Ext.dom.Element
chainable ch

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:

Parameters

attributes :  Object

The object with the attributes.

useSet :  Boolean (optional)

false to override the default setAttribute to use expandos.

Defaults to: true

Returns

:Ext.dom.Element

this

setBottom ( bottom ) : Ext.dom.Element
chainable ch

Sets the element's CSS bottom style.

Parameters

bottom :  Number/String

Number of pixels or CSS string value to set as the bottom CSS property value

Returns

:Ext.dom.Element

this

setBounds ( x, y, width, height, [animate] ) : Ext.dom.Element
deprecated dep

Sets the element's position and size in one shot. If animation is true then width, height, x and y will be animated concurrently.

Parameters

x :  Number

X value for new position (coordinates are page-based)

y :  Number

Y value for new position (coordinates are page-based)

width :  Number/String

The new width. This may be one of:

  • A Number specifying the new width in pixels
  • A String used to set the CSS width style. Animation may not be used.

height :  Number/String

The new height. This may be one of:

  • A Number specifying the new height in pixels
  • A String used to set the CSS height style. Animation may not be used.

animate :  Boolean/Object (optional)

true for the default animation or a standard Element animation config object

Returns

:Ext.dom.Element

this

Deprecated since version 4.2.0
Use Ext.util.Positionable#setBox instead.

setBox ( box ) : Ext.util.Positionable
chainable ch

Sets the element's box.

Parameters

box :  Object

The box to fill {x, y, width, height}

Returns

:Ext.util.Positionable

this

setCls ( className )

Sets the specified CSS class on this element's DOM node.

Parameters

className :  String/String[]

The CSS class to set on this element.

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

Sets a single/multiple configuration options.

Parameters

name :  String/Object

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

value :  Object (optional)

The value to set for the name parameter.

Returns

:Ext.Base

this

setDisplayed ( value ) : Ext.dom.Element
chainable ch

Sets the CSS display property. Uses originalDisplay if the specified value is a boolean true.

Parameters

value :  Boolean/String

Boolean value to display the element using its default display, or a string to set the display directly.

Returns

:Ext.dom.Element

this

setHTML ( html, [loadScripts], [callback], [scope] ) : Ext.dom.Element
deprecated dep

Updates the innerHTML of this element, optionally searching for and processing scripts.

Parameters

html :  String

The new HTML

loadScripts :  Boolean (optional)

Pass true to look for and process scripts.

callback :  Function (optional)

For async script loading you can be notified when the update completes.

scope :  Object (optional)

The scope (this reference) in which to execute the callback.

Also used as the scope for any inline script source if the loadScripts parameter is true. Scripts with a src attribute cannot be executed in this scope.

Defaults to this Element.

Defaults to: `this`

Returns

:Ext.dom.Element

this

Deprecated since version 5.0.0
Please use setHtml instead.

setHeight ( height ) : Ext.dom.Element
chainable ch

Set the height of this Element.

Parameters

height :  Number/String

The new height.

Returns

:Ext.dom.Element

this

setHorizontal
private pri

Removes "vertical" state from this element (reverses everything done by setVertical).

setHtml ( html ) : Ext.dom.Element
chainable ch

Sets the innerHTML of this element.

Parameters

html :  String

The new HTML.

Returns

:Ext.dom.Element

this

setLeft ( left ) : Ext.dom.Element
chainable ch

Sets the element's left position directly using CSS style (instead of setX).

Parameters

left :  Number/String

Number of pixels or CSS string value to set as the left CSS property value

Returns

:Ext.dom.Element

this

setLeftTop ( left, top ) : Ext.dom.Element
chainable ch deprecated dep

Sets the element's left and top positions directly using CSS style

Parameters

left :  Number/String

Number of pixels or CSS string value to set as the left CSS property value

top :  Number/String

Number of pixels or CSS string value to set as the top CSS property value

Returns

:Ext.dom.Element

this

Deprecated since version 4.2.0
Use Ext.dom.Element#setLocalXY instead

setListeners ( listeners )

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

Parameters

listeners :  Object

The listeners

setLocalX ( x ) : Ext.util.Positionable

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.

Parameters

x :  Number

The x coordinate. A value of null sets the left style to 'auto'.

Returns

:Ext.util.Positionable

this

setLocalXY ( x, [y] ) : Ext.util.Positionable

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.

Parameters

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'

Returns

:Ext.util.Positionable

this

setLocalY ( y ) : Ext.util.Positionable

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.

Parameters

y :  Number

The y coordinate. A value of null sets the top style to 'auto'.

Returns

:Ext.util.Positionable

this

setLocation ( x, y, [animate] ) : Ext.dom.Element
deprecated dep

Sets the position of the element in page coordinates.

Parameters

x :  Number

X value for new position

y :  Number

Y value for new position

animate :  Boolean/Object (optional)

True for the default animation, or a standard Element animation config object

Returns

:Ext.dom.Element

this

Deprecated since version 4.2.0
Use Ext.dom.Element#setXY instead.

setMaxHeight ( height ) : Ext.dom.Element
chainable ch

Set the maximum height of this Element.

Parameters

height :  Number/String

The new maximum height.

Returns

:Ext.dom.Element

this

setMaxWidth ( width ) : Ext.dom.Element
chainable ch

Set the maximum width of this Element.

Parameters

width :  Number/String

The new maximum width.

Returns

:Ext.dom.Element

this

setMinHeight ( height ) : Ext.dom.Element
chainable ch

Set the minimum height of this Element.

Parameters

height :  Number/String

The new minimum height.

Returns

:Ext.dom.Element

this

setMinWidth ( width ) : Ext.dom.Element
chainable ch

Set the minimum width of this Element.

Parameters

width :  Number/String

The new minimum width.

Returns

:Ext.dom.Element

this

setOpacity ( opacity ) : Ext.dom.Element
chainable ch

Set the opacity of the element

Parameters

opacity :  Number

The new opacity. 0 = transparent, .5 = 50% visibile, 1 = fully visible, etc

Returns

:Ext.dom.Element

this

setPositioning ( posCfg ) : Ext.dom.Element

Set positioning with an object returned by getPositioning.

Parameters

posCfg :  Object

Returns

:Ext.dom.Element

this

setRight ( right ) : Ext.dom.Element
chainable ch

Sets the element's CSS right style.

Parameters

right :  Number/String

Number of pixels or CSS string value to set as the right CSS property value

Returns

:Ext.dom.Element

this

setScrollLeft ( left ) : Ext.dom.Element
chainable ch

Sets the left scroll position

Parameters

left :  Number

The left scroll position

Returns

:Ext.dom.Element

this

setScrollTop ( top ) : Ext.dom.Element
chainable ch

Sets the top scroll position

Parameters

top :  Number

The top scroll position

Returns

:Ext.dom.Element

this

setSize ( width, height ) : Ext.dom.Element
chainable ch

Set the size of this Element.

Parameters

width :  Number/String

The new width. This may be one of:

  • A Number specifying the new width in pixels.
  • A String used to set the CSS width style. Animation may not be used.
  • A size object in the format {width: widthValue, height: heightValue}.

height :  Number/String

The new height. This may be one of:

  • A Number specifying the new height in pixels.
  • A String used to set the CSS height style. Animation may not be used.

Returns

:Ext.dom.Element

this

setStyle ( property, [value] ) : Ext.dom.Element
chainable ch

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

Parameters

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

Returns

:Ext.dom.Element

this

setTop ( top ) : Ext.dom.Element
chainable ch

Sets the element's top position directly using CSS style (instead of setY).

Parameters

top :  Number/String

Number of pixels or CSS string value to set as the top CSS property value

Returns

:Ext.dom.Element

this

setTopLeft
deprecated dep removed rem

Sets the element's top and left positions directly using CSS style.

Deprecated
setTopLeft

This method has been REMOVED since 5.0.0

setTouchAction ( touchAction ) : Ext.dom.Element

Sets the CSS href="https://www.w3.org/TR/pointerevents/#the-touch-action-css-property" class="external-link" target="_blank">https://www.w3.org/TR/pointerevents/#the-touch-action-css-property touch-action property on this element and emulates its behavior on browsers where touch-action is not supported.

Parameters

touchAction :  Object

An object with touch-action names as the keys, and boolean values to enable or disable specific touch actions. Accepted keys are:

  • panX
  • panY
  • pinchZoom
  • doubleTapZoom

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

Returns

:Ext.dom.Element

this

setVertical ( angle, cls )
private pri

Changes this Element's state to "vertical" (rotated 90 or 270 degrees). This involves inverting the getters and setters for height and width, and applying hooks for rotating getters and setters for border/margin/padding. (getWidth becomes getHeight and vice versa), setStyle and getStyle will also return the inverse when height or width are being operated on.

Parameters

angle :  Number

the angle of rotation - either 90 or 270

cls :  String

an optional css class that contains the required styles for switching the element to vertical orientation. Omit this if the element already contains vertical styling. If cls is provided, it will be removed from the element when setHorizontal is called.

setVisibility ( isVisible )
private pri

Parameters

isVisible :  Object

setVisibilityMode ( mode ) : Ext.dom.Element
chainable ch

Use this to change the visibility mode between VISIBILITY, DISPLAY, OFFSETS, or CLIP.

Parameters

mode :  Ext.dom.Element.VISIBILITY/Ext.dom.Element.DISPLAY/Ext.dom.Element.OFFSETS/Ext.dom.Element.CLIP

The method by which the element will be hidden (you can also use the setVisible or toggle method to toggle element visibility).

Returns

:Ext.dom.Element

this

setVisible ( visible ) : Ext.dom.Element
chainable ch

Sets the visibility of the element based on the current visibility mode. Use setVisibilityMode to switch between the following visibility modes:

Parameters

visible :  Boolean

Whether the element is visible.

Returns

:Ext.dom.Element

this

setWidth ( width ) : Ext.dom.Element
chainable ch

Set the width of this Element.

Parameters

width :  Number/String

The new width.

Returns

:Ext.dom.Element

this

setX ( x ) : Ext.dom.Element

Sets this Element's page-level x coordinate

Parameters

x :  Number

Returns

:Ext.dom.Element

this

setXY ( xy ) : Ext.dom.Element
chainable ch

Sets this Element's page-level x and y coordinates

Parameters

xy :  Number[]

Returns

:Ext.dom.Element

this

setY ( y ) : Ext.dom.Element

Sets this Element's page-level y coordinate

Parameters

y :  Number

Returns

:Ext.dom.Element

this

setZIndex ( zindex ) : Ext.dom.Element

Sets the z-index of this Element and synchronizes the z-index of shadow and/or shim if present.

Parameters

zindex :  Number

The new z-index to set

Returns

:Ext.dom.Element

this

shift ( options ) : Ext.dom.Element
chainable ch deprecated dep

Animates the transition of any combination of an element's dimensions, xy position and/or opacity. Any of these properties not specified in the config object will not be changed. This effect requires that at least one new dimension, position or opacity setting must be passed in on the config object in order for the function to have any effect. Usage:

// slide the element horizontally to x position 200 while changing the height and opacity
el.shift({ x: 200, height: 50, opacity: .8 });

// common config options shown with default values.
el.shift({
    width: [element's width],
    height: [element's height],
    x: [element's x position],
    y: [element's y position],
    opacity: [element's opacity],
    easing: 'easeOut',
    duration: 350
});

Parameters

options :  Object

Object literal with any of the Ext.fx.Anim config options

Returns

:Ext.dom.Element

The Element

Deprecated since version 4.0
Just use animate instead.

show Ext.dom.Element
chainable ch

Show this element - Uses display mode to determine whether to use "display", "visibility", "offsets", or "clip". See setVisible.

Returns

:Ext.dom.Element

this

slideIn ( [anchor], [options] ) : Ext.dom.Element
chainable ch

Slides the element into view. An anchor point can be optionally passed to set the point of origin for the slide effect. This function automatically handles wrapping the element with a fixed-size container if needed. See the Ext.fx.Anim class overview for valid anchor point options. Usage:

// default: slide the element in from the top
el.slideIn();

// custom: slide the element in from the right with a 2-second duration
el.slideIn('r', { duration: 2000 });

// common config options shown with default values
el.slideIn('t', {
    easing: 'easeOut',
    duration: 500
});

Parameters

anchor :  String (optional)

One of the valid Ext.fx.Anim anchor positions (defaults to top: 't')

options :  Object (optional)

Object literal with any of the Ext.fx.Anim config options

preserveScroll :  Boolean

Set to true if preservation of any descendant elements' scrollTop values is required. By default the DOM wrapping operation performed by slideIn and slideOut causes the browser to lose all scroll positions.

Returns

:Ext.dom.Element

The Element

slideOut ( [anchor], [options] ) : Ext.dom.Element

Slides the element out of view. An anchor point can be optionally passed to set the end point for the slide effect. When the effect is completed, the element will be hidden (visibility = 'hidden') but block elements will still take up space in the document. The element must be removed from the DOM using the 'remove' config option if desired. This function automatically handles wrapping the element with a fixed-size container if needed. See the Ext.fx.Anim class overview for valid anchor point options. Usage:

// default: slide the element out to the top
el.slideOut();

// custom: slide the element out to the right with a 2-second duration
el.slideOut('r', { duration: 2000 });

// common config options shown with default values
el.slideOut('t', {
    easing: 'easeOut',
    duration: 500,
    remove: false,
    useDisplay: false
});

Parameters

anchor :  String (optional)

One of the valid Ext.fx.Anim anchor positions (defaults to top: 't')

options :  Object (optional)

Object literal with any of the Ext.fx.Anim config options

Returns

:Ext.dom.Element

The Element

statics Ext.Class
protected pro

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

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

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

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

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

        statics.totalCreated++;
    },

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

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

        return cloned;
    }
});


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

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

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

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

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

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

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

Returns

:Ext.Class

stopAnimation ( suppressEvent ) : Ext.dom.Element
chainable ch

Stops any running effects and clears this object's internal effects queue if it contains any additional effects that haven't started yet.

Parameters

suppressEvent :  Object

Returns

:Ext.dom.Element

The Element

stopFx Ext.dom.Element
deprecated dep

Stops any running effects and clears this object's internal effects queue if it contains any additional effects that haven't started yet.

Returns

:Ext.dom.Element

The Element

Deprecated since version 4.0
Replaced by stopAnimation

suspendEvent ( eventName )

Suspends firing of the named event(s).

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

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

Parameters

eventName :  String...

Multiple event names to suspend.

suspendEvents ( queueSuspended )

Suspends the firing of all events. (see resumeEvents)

Parameters

queueSuspended :  Boolean

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

swallowEvent ( eventName, [preventDefault] ) : Ext.dom.Element
chainable ch

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": "finn@adventuretime.com"
    }]
});

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

Parameters

eventName :  String/String[]

an event / array of events to stop from bubbling

preventDefault :  Boolean (optional)

true to prevent the default action too

Returns

:Ext.dom.Element

this

swapCls ( firstClass, secondClass, flag, prefix ) : Mixed
chainable ch private pri

Parameters

firstClass :  String

secondClass :  String

flag :  Boolean

prefix :  String

Returns

:Mixed

switchOff ( [options] ) : Ext.dom.Element
chainable ch

Blinks the element as if it was clicked and then collapses on its center (similar to switching off a television). When the effect is completed, the element will be hidden (visibility = 'hidden') but block elements will still take up space in the document. The element must be removed from the DOM using the 'remove' config option if desired. Usage:

// default
el.switchOff();

// all config options shown with default values
el.switchOff({
    easing: 'easeIn',
    duration: .3,
    remove: false,
    useDisplay: false
});

Parameters

options :  Object (optional)

Object literal with any of the Ext.fx.Anim config options

Returns

:Ext.dom.Element

The Element

syncContent ( source )
private pri

Currently used for updating grid cells without modifying DOM structure

Synchronizes content of this Element with the content of the passed element.

Style and CSS class are copied from source into this Element, and contents are synced recursively. If a child node is a text node, the textual data is copied.

Parameters

source :  Object

syncFx Object
chainable ch

Ensures that all effects queued after syncFx is called on this object are run concurrently. This is the opposite of sequenceFx.

Returns

:Object

this

synchronize
chainable ch private pri

Returns

:

toggle Ext.dom.Element
chainable ch

Toggles the element's visibility, depending on visibility mode.

Returns

:Ext.dom.Element

this

toggleCls ( className, [state] ) : Ext.dom.Element

Toggles the specified CSS class on this element (removes it if it already exists, otherwise adds it).

Parameters

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.

Returns

:Ext.dom.Element

this

translatePoints ( x, [y] ) : Object

Translates the passed page coordinates into left/top css values for the element

Parameters

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

Returns

:Object

An object with left and top properties. e.g. {left: (value), top: (value)}

translateXY ( x, [y] ) : Object
private pri

Translates the passed page coordinates into x and y css values for the element

Parameters

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

Returns

:Object

An object with x and y properties. e.g. {x: (value), y: (value)}

un ( eventName, fn, [scope] ) :

Shorthand for removeListener. Removes an event handler.

Parameters

eventName :  String

The type of event the handler was associated with.

fn :  Function

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

scope :  Object (optional)

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

Convenience Syntax

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

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

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

Exception - DOM event handlers using the element config option

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

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

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

Returns

:

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

Removes a before-event handler.

Same as removeListener with order set to 'after'.

Parameters

eventName :  String/String[]/Object

The name of the event the handler was associated with.

fn :  Function/String

The handler to remove.

scope :  Object (optional)

The scope originally specified for fn.

options :  Object (optional)

Extra options object.

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

Removes a before-event handler.

Same as removeListener with order set to 'before'.

Parameters

eventName :  String/String[]/Object

The name of the event the handler was associated with.

fn :  Function/String

The handler to remove.

scope :  Object (optional)

The scope originally specified for fn.

options :  Object (optional)

Extra options object.

unclip Ext.dom.Element
chainable ch

Return clipping (overflow) to original clipping before clip was called

Returns

:Ext.dom.Element

this

unmask

Hides a previously applied mask.

unselectable Ext.dom.Element
chainable ch

Disables text selection for this element (normalized across browsers)

Returns

:Ext.dom.Element

this

unwrap
chainable ch private pri

Returns

:

up ( selector, [limit], [returnDom] ) : Ext.dom.Element/HTMLElement

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

Parameters

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

Returns

:Ext.dom.Element/HTMLElement

The matching DOM node (or HTMLElement if returnDom is true). Or null if no match was found.

update ( html ) : Ext.dom.Element
deprecated dep

Updates the innerHTML of this element, optionally searching for and processing scripts.

Parameters

html :  String

The new HTML

Returns

:Ext.dom.Element

this

Deprecated since version 5.0.0
Please use setHtml instead.

updateText ( text )

Updates the text value of this element. Replaces the content of this element with a single text node containing the passed text.

Parameters

text :  String

The text to display in this Element.

wrap ( [config], [returnDom], [selector] ) : HTMLElement/Ext.dom.Element

Creates and wraps this element with another element

Parameters

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.

Returns

:HTMLElement/Ext.dom.Element

The newly created wrapper element

Static Methods

_onWindowFocusChange ( e )
static sta private pri

Parameters

e :  Object

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

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

Parameters

config :  Object

mixinClass :  Ext.Class (optional)

The mixin class if the configs are from a mixin.

addInheritableStatics ( members ) :
chainable ch static sta private pri

Parameters

members :  Object

Returns

:

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

Parameters

name :  Object

member :  Object

Returns

:

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

Add methods / properties to the prototype of this class.

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

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

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

Parameters

members :  Object

The members to add to this class.

isStatic :  Boolean (optional)

Pass true if the members are static.

Defaults to: false

privacy :  Boolean (optional)

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

Defaults to: false

Returns

:

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

Add / override static properties of this class.

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

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

Parameters

members :  Object

Returns

:Ext.Base

this

addUnits ( size, units ) : String
static sta private pri

Test if size has a unit, otherwise appends the passed unit string, or the default for this Element.

Parameters

size :  Object

The size to set.

units :  String

The units to append to a numeric size value.

Returns

:String

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

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

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

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

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

var steve = new Thief();

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

Parameters

fromClass :  Ext.Base

The class to borrow members from

members :  Array/String

The names of the members to borrow

Returns

:Ext.Base

this

callParent ( args )
static sta protected pro

Parameters

args :  Object

callSuper ( args )
static sta protected pro

Parameters

args :  Object

create ( attributes, domNode )
static sta private pri

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

Parameters

attributes :  Object

domNode :  Object

createAlias ( alias, origin )
static sta

Create aliases for existing prototype methods. Example:

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

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

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

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

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

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

Parameters

alias :  String/Object

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

origin :  String/Object

The original method name

detach
chainable ch static sta private pri

Returns

:

extend ( parentClass )
static sta private pri

Parameters

parentClass :  Object

fly ( dom, named ) : Ext.dom.Element
static sta

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.

Parameters

dom :  String/HTMLElement

The DOM node or id.

named :  Object

Returns

:Ext.dom.Element

The shared Element object (or null if no matching element was found).

fromPagePoint ( x, y, [asDom] ) : Ext.dom.Element/HTMLElement
static sta

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

Parameters

x :  Number

The x coordinate

y :  Number

The y coordinate

asDom :  Boolean (optional)

true to return a DOM element.

Defaults to: false

Returns

:Ext.dom.Element/HTMLElement

The found element.

fromPoint ( x, y, [asDom] ) : Ext.dom.Element/HTMLElement
static sta

Returns the top Element that is located at the passed coordinates in the current viewport.

Parameters

x :  Number

The x coordinate

y :  Number

The y coordinate

asDom :  Boolean (optional)

true to return a DOM element.

Defaults to: false

Returns

:Ext.dom.Element/HTMLElement

The found element.

get ( el ) : Ext.dom.Element
static sta

Retrieves Ext.dom.Element objects. Ext#get is alias for Ext.dom.Element#get.

This method does not retrieve Ext.Components. 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.

Parameters

el :  String/HTMLElement/Ext.dom.Element

The id of the node, a DOM Node or an existing Element.

Returns

:Ext.dom.Element

The Element object (or null if no matching element was found).

getActiveElement ( asElement ) : HTMLElement
static sta

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.

Parameters

asElement :  Boolean

Return Ext.Element instance instead of DOM node.

Returns

:HTMLElement

The active (focused) element in the document.

getCommonAncestor ( nodeA, nodeB, returnDom ) : Ext.dom.Element/HTMLElement
static sta

Returns the common ancestor of the two passed elements.

Parameters

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.

Returns

:Ext.dom.Element/HTMLElement

The common ancestor.

getConfigurator Ext.Configurator
static sta private pri

Returns the Ext.Configurator for this class.

Returns

:Ext.Configurator

getDocumentHeight Number
static sta

Retrieves the document height

Returns

:Number

documentHeight

getDocumentWidth Number
static sta

Retrieves the document width

Returns

:Number

documentWidth

getName String
static sta

Get the current class' name in string format.

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

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

Returns

:String

className

getOrientation String
static sta

Retrieves the current orientation of the window. This is calculated by determining if the height is greater than the width.

Returns

:String

Orientation of window: 'portrait' or 'landscape'

getViewportHeight Number
static sta

Retrieves the viewport height of the window.

Returns

:Number

viewportHeight

getViewportScale Number
static sta private pri

Returns the current zoom level of the viewport as a ratio of page pixels to screen pixels.

Returns

:Number

getViewportTouchScale ( forceRead )
static sta private pri

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

Parameters

forceRead :  Object

getViewportWidth Number
static sta

Retrieves the viewport width of the window.

Returns

:Number

viewportWidth

getViewSize Object
static sta

Retrieves the viewport size of the window.

Returns

:Object

object containing width and height properties

hasUnit ( size ) : Boolean
static sta

Checks if the passed size has a css unit attached.

Available since: 6.2.1

Parameters

size :  String

The size.

Returns

:Boolean

true if the size has a css unit.

maskIframes
static sta private pri

Mask iframes when shim is true. See Ext.util.Floating#shim.

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

Used internally by the mixins pre-processor

Parameters

name :  Object

mixinClass :  Object

Returns

:

normalize ( prop ) : String
static sta

Normalizes CSS property keys from dash delimited to camel case JavaScript Syntax. For example:

  • border-width -> borderWidth
  • padding-top -> paddingTop

Parameters

prop :  String

The property to normalize

Returns

:String

The normalized string

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

Parameters

fn :  Object

scope :  Object

Returns

:

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

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

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

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

        this.callParent(arguments);

        alert("Meeeeoooowwww");
    }
});

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

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

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

        this.callParent(arguments);

        alert("Meeeeoooowwww");
    }
});

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

Parameters

members :  Object

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

Returns

:Ext.Base

this class

parseBox ( box ) : Object
static sta

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)

Parameters

box :  Number/String

The encoded margins

Returns

:Object

An object with margin sizes for top, right, bottom and left containing the unit

parseStyles ( styles ) : Object
static sta

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

Parameters

styles :  String

A CSS string

Returns

:Object

styles

query ( selector, [asDom], [root] ) : HTMLElement[]/Ext.dom.Element[]
static sta

Selects child nodes of a given root based on the passed CSS selector.

Parameters

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

Returns

:HTMLElement[]/Ext.dom.Element[]

An Array of elements that match the selector. If there are no matches, an empty Array is returned.

select ( selector, [composite], [root] ) : Ext.dom.CompositeElementLite/Ext.dom.CompositeElement
static sta

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.

Parameters

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

Returns

:Ext.dom.CompositeElementLite/Ext.dom.CompositeElement

serializeForm ( form ) : String
static sta

Serializes a DOM form into a url encoded string

Parameters

form :  Object

The form

Returns

:String

The url encoded form

triggerExtended
static sta private pri

unitizeBox ( box, units ) : String
static sta

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)

Parameters

box :  Number/String/Object

The encoded margins, or an object with top, right,

units :  String

The type of units to add

Returns

:String

An string with unitized (px if units is not specified) metrics for top, right, bottom and left

unmaskIframes
static sta private pri

Unmask iframes when shim is true. See Ext.util.Floating#shim.

events

abort ( e, t, eOpts )

Fires when an object/image is stopped from loading before completely loaded.

Parameters

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.

blur ( e, t, eOpts )

Fires when an element loses focus either via the pointing device or by tabbing navigation.

Parameters

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.

change ( e, t, eOpts )

Fires when a control loses the input focus and its value has been modified since gaining focus.

Parameters

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.

click ( e, t, eOpts )

Fires when a mouse click is detected within the element.

Parameters

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.

contextmenu ( e, t, eOpts )

Fires when a right click is detected within the element.

Parameters

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.

dblclick ( e, t, eOpts )

Fires when a mouse double click is detected within the element.

Parameters

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.

DOMActivate ( e, t, eOpts )

Where supported. Fires when an element is activated, for instance, through a mouse click or a keypress.

Parameters

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.

DOMAttrModified ( e, t, eOpts )

Where supported. Fires when an attribute has been modified.

Parameters

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.

DOMCharacterDataModified ( e, t, eOpts )

Where supported. Fires when the character data has been modified.

Parameters

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.

DOMFocusIn ( e, t, eOpts )

Where supported. Similar to HTML focus event, but can be applied to any focusable element.

Parameters

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.

DOMFocusOut ( e, t, eOpts )

Where supported. Similar to HTML blur event, but can be applied to any focusable element.

Parameters

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.

DOMNodeInserted ( e, t, eOpts )

Where supported. Fires when a node has been added as a child of another node.

Parameters

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.

DOMNodeInsertedIntoDocument ( e, t, eOpts )

Where supported. Fires when a node is being inserted into a document.

Parameters

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.

DOMNodeRemoved ( e, t, eOpts )

Where supported. Fires when a descendant node of the element is removed.

Parameters

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.

DOMNodeRemovedFromDocument ( e, t, eOpts )

Where supported. Fires when a node is being removed from a document.

Parameters

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.

DOMSubtreeModified ( e, t, eOpts )

Where supported. Fires when the subtree is modified.

Parameters

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.

doubletap ( event, node, options, eOpts )

Fires when there is a double tap.

Parameters

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.

error ( e, t, eOpts )

Fires when an object/image/frame cannot be loaded properly.

Parameters

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.

focus ( e, t, eOpts )

Fires when an element receives focus either via the pointing device or by tab navigation.

Parameters

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.

focusmove ( e, t, eOpts )

Fires when focus is moved within an element.

Parameters

e :  Ext.event.Event

The Ext.event.Event encapsulating the DOM event.

target :  Ext.dom.Element

The Ext.dom.Element element which recieved focus.

relatedTarget :  Ext.dom.Element

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.

keydown ( e, t, eOpts )

Fires when a keydown is detected within the element.

Parameters

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.

keypress ( e, t, eOpts )

Fires when a keypress is detected within the element.

Parameters

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.

keyup ( e, t, eOpts )

Fires when a keyup is detected within the element.

Parameters

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.

load ( e, t, eOpts )

Fires when the user agent finishes loading all content within the element. Only supported by window, frames, objects and images.

Parameters

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.

longpress ( event, node, options, eOpts )

Fires when you touch and hold still for more than 1 second.

Parameters

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.

mousedown ( e, t, eOpts )

Fires when a mousedown is detected within the element.

Parameters

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.

mouseenter ( e, t, eOpts )

Fires when the mouse enters the element.

Parameters

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.

mouseleave ( e, t, eOpts )

Fires when the mouse leaves the element.

Parameters

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.

mousemove ( e, t, eOpts )

Fires when a mousemove is detected with the element.

Parameters

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.

mouseout ( e, t, eOpts )

Fires when a mouseout is detected with the element.

Parameters

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.

mouseover ( e, t, eOpts )

Fires when a mouseover is detected within the element.

Parameters

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.

mouseup ( e, t, eOpts )

Fires when a mouseup is detected within the element.

Parameters

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.

painted ( this, eOpts )

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.

Parameters

this :  Ext.dom.Element

The component instance.

eOpts : Object

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

pinch ( event, node, options, eOpts )

Fires continuously when there is pinching (the touch must move for this to be fired).

Parameters

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.

pinchend ( event, node, options, eOpts )

Fires when a pinch has ended.

Parameters

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.

pinchstart ( event, node, options, eOpts )

Fired once when a pinch has started.

Parameters

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.

reset ( e, t, eOpts )

Fires when a form is reset.

Parameters

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.

resize ( this, info, eOpts )

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.

Parameters

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.

rotate ( event, node, options, eOpts )

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.

Parameters

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.

rotateend ( event, node, options, eOpts )

Fires when a rotation event has ended.

Parameters

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.

rotatestart ( event, node, options, eOpts )

Fired once when a rotation has started.

Parameters

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.

scroll ( e, t, eOpts )

Fires when a document view is scrolled.

Parameters

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.

select ( e, t, eOpts )

Fires when a user selects some text in a text field, including input and textarea.

Parameters

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.

singletap ( event, node, options, eOpts )

Fires when there is a single tap.

Parameters

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.

submit ( e, t, eOpts )

Fires when a form is submitted.

Parameters

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.

swipe ( event, node, options, eOpts )

Fires when there is a swipe When listening to this, ensure you know about the Ext.event.Event#direction property in the event object.

Parameters

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.

taphold ( event, node, options, eOpts )

Fires when you touch and hold still for more than 1 second.

Parameters

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.

unload ( e, t, eOpts )

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.

Parameters

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.

Ext JS 6.2.1 - Classic Toolkit