ExtReact Docs Help

Introduction

The documentation for the ExtReact product diverges somewhat from the documentation of other Sencha products. The sections below describe documentation for all products except where indicated as unique to ExtReact.

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.

ExtReact component classes list the configurable name prominently at the top of the API class doc followed by the fully-qualified class name.

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

Or in the case of an ExtReact component class this indicates a member of type prop

- Indicates a class member of type property

- Indicates a class member of type method

- Indicates a class member of type event

- Indicates a class member of type theme variable

- Indicates a class member of type theme mixin

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

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.

ExtReact component classes do not hoist the getter / setter methods into the prop. All methods will be described in the Methods section

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.

ExtAngular 7.2.0


top

NPM Package

@sencha/ext-core

Hierarchy

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

$configTransforms : Object / Array
private pri

A prototype-chained object storing transform method names and priorities stored on the class prototype. On first instantiation, this object is converted into an array that is sorted by priority and stored on the constructor.

Defaults to:

{}

$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

autoGenId : Boolean
private pri

true indicates an id was auto-generated rather than provided by configuration.

Defaults to:

false

Available since: 6.7.0

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 : <ExtComponent/>

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

destroyed : Boolean

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"]'

maxRippleDiameter
static sta

Determines the maximum size for all ripples

Defaults to:

75

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

OPACITY : Number
static sta

Visibility mode constant for use with Ext.dom.Element#setVisibilityMode. Use CSS opacity property to reduce element's opacity to 0

Defaults to:

5

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

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

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

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 <ExtComponent/>. The name of a Component property which references an Ext.dom.Element to add a listener to.

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

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

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

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

 panel.body.un(...)

delegate :  String (optional)

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

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

See the delegate example below.

capture :  Boolean (optional)

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

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

stopPropagation :  Boolean (optional)

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

preventDefault :  Boolean (optional)

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

stopEvent :  Boolean (optional)

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

args :  Array (optional)

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

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

destroyable :  Boolean (optional)

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

Defaults to:

false

priority :  Number (optional)

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

order :  String (optional)

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

  • 'before': equal to a priority of 100
  • 'current': equal to a priority of 0 or default priority
  • 'after': equal to a priority of -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.

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.SomeSharedMenu, 'show', this.doSomething);
        this.callParent();
    }
});

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

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

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

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.

Following are all of the supported predefined anchor positions:

 Value  Description
 -----  -----------------------------
 tl     The top left corner
 t      The center of the top edge
 tr     The top right corner
 l      The center of the left edge
 c      The center
 r      The center of the right edge
 bl     The bottom left corner
 b      The center of the bottom edge
 br     The bottom right corner

You can put a '?' at the end of the alignment string to constrain the positioned element to the Ext.Viewport. The element will attempt to align as specified, but the position will be adjusted to constrain to the viewport if necessary. Note that the element being aligned might be swapped to align to a different position than that specified in order to enforce the viewport constraints.

Example Usage:

// align el to other-el using the default positioning
// ("tl-bl", non-constrained)
el.alignTo("other-el");

// align the top left corner of el with the top right corner of other-el
// (constrained to viewport)
el.alignTo("other-el", "tl-tr?");

// align the bottom right corner of el with the center left edge of other-el
el.alignTo("other-el", "br-l?");

// align the center of el with the bottom left corner of other-el and
// adjust the x position by -6 pixels (and the y position by 0)
el.alignTo("other-el", "c-bl", [-6, 0]);

// align the 25% point on the bottom edge of this el
// with the 75% point on the top edge of other-el.
el.alignTo("other-el", 'b25-t75');

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

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

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

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.

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

dom :  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)

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

destroy

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

destroyMembers ( args )

Destroys member properties by name.

If a property name is the name of a config, the getter is not invoked, so if the config has not been initialized, nothing will be done.

The property will be destroyed, and the corrected name (if the property is a config and config names are prefixed) will set to null in this object's dictionary.

Parameters

args :  String...

One or more names of the properties to destroy and remove from the object.

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)

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.

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

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

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

Parameters

simpleSelector :  String

The simple selector to test. See Ext.dom.Query for information about simple selectors.

limit :  Number/String/HTMLElement/Ext.dom.Element (optional)

The max depth to search as a number or an element which causes the upward traversal to stop and is not considered for inclusion as the result. (defaults to 50 || document.documentElement)

returnEl :  Boolean (optional)

True to return a Ext.dom.Element object instead of DOM node

Defaults to: false

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

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

Parameters

simpleSelector :  String

The simple selector to test. See Ext.dom.Query for information about simple selectors.

limit :  Number/String/HTMLElement/Ext.dom.Element (optional)

The max depth to search as a number or an element which causes the upward traversal to stop and is not considered for inclusion as the result. (defaults to 50 || document.documentElement)

returnEl :  Boolean (optional)

True to return a Ext.dom.Element object instead of DOM node

Defaults to: false

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

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

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.

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.

getClassMap Object

Returns an object holding as properties this element's CSS classes. The object can be modified to effect arbitrary class manipulations that won't immediately go to the DOM. When completed, the DOM node can be updated by calling setClassMap. The values of the properties should either be set to truthy values (such as 1 or true) or removed via delete.

 var classes = el.getClassMap();

 // Add the 'foo' class:
 classes.foo = 1;

 // Remove the 'bar' class:
 delete classes.bar;

 // Update the DOM in one step:
 el.setClassMap(classes);

Available since: 6.5.0

Returns

:Object

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.

getConfig ( [name], [peek], [ifInitialized] ) : 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

ifInitialized :  Boolean (optional)

true to only return the initialized property value, not the raw config value, and not to trigger initialization. Returns undefined if the property has not yet been initialized.

Defaults to: false

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.

getData Object
private pri

Returns this element's data object. This object holds options that may be needed by an Ext.fly() call when there is no (cached) Ext.dom.Element instance tracked.

This method will only return null if this instance has no associated DOM node. If the DOM node does not have a data object, one will be created. To avoid this creation, use peekData() instead.

Returns

:Object

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], [preciseHeight] ) : Number

Returns the offset height of the element.

Parameters

contentHeight :  Boolean (optional)

true to get the height minus borders and padding.

preciseHeight :  Boolean (optional)

true to get the precise height

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. This method Will auto-generate an id if one has not already been configured.

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

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

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 ( [getRegion] ) : 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

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

getRegion ( [contentBox], [local] ) : 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.

local :  Boolean (optional)

If true the element's left and top relative to its offsetParent are returned instead of page x/y.

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

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, [align] ) : 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/Ext.util.Region

The container

scrollX :  Number

The container's current scroll position on the x axis

scrollY :  Number

The container's current scroll position on the y axis

align :  Object (optional)

The alignment for the scroll.

x :  'start' / 'center' / 'end' (optional)

The alignment of the x scroll. If not specified, the minimum will be done to make the element visible. The behavior is undefined if the request cannot be honored. If the alignment is suffixed with a ?, the alignment will only take place if the item is not already in the visible area.

y :  'start' / 'center' / 'end' (optional)

The alignment of the x scroll. If not specified, the minimum will be done to make the element visible. The behavior is undefined if the request cannot be honored. If the alignment is suffixed with a ?, the alignment will only take place if the item is not already in the visible area.

Returns

:Object

An object with "x" and "y" properties

getScrollLeft Number

Gets the left scroll position

Returns

:Number

The left scroll position

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

getTextSelection Array

Returns the selection range of an input element as an array of three values:

 [ start, end, direction ]

These have the same meaning as the parameters to selectText.

Available since: 6.5.0

Returns

:Array

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], [preciseWidth] ) : Number

Returns the offset width of the element.

Parameters

contentWidth :  Boolean (optional)

true to get the width minus borders and padding.

preciseWidth :  Boolean (optional)

true to get the precise width

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

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

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

Returns

:Ext.dom.Element

this

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 the options parameter.

Returns

:Ext.dom.Element

this

indexOf ( childEl ) : Number

Returns the index of the given element in the childNodes of this element. If not present, -1 is returned.

Available since: 6.5.0

Parameters

childEl :  String/HTMLElement/Ext.dom.Element

The potential child element.

Returns

:Number

The index of childEl in childNodes or -1 if not found.

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

Initialize configuration for this class. a typical example:

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

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

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

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

Parameters

instanceConfig :  Object

Returns

:Ext.Base

this

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

isFocusable ( skipVisibility ) : 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.

Parameters

skipVisibility :  Object

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.

isScrollable Boolean

Returns true if this element is scrollable.

Returns

:Boolean

isStyle ( style, val ) : Boolean

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

Parameters

style :  String

property whose value is returned.

val :  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
deprecated dep

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.

Deprecated since version 5.0.0
This method is deprecated.

isVisible ( [deep], [mode] ) : 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

mode :  Number (optional)

Bit flag indicating which CSS properties to test:

  • 1 - check display only
  • 2 - check visibility only
  • 3 - check both visibility and display

Defaults to: 3

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.

measure ( [dimension] ) : Number/Object
private pri

Measures and returns the size of this element. When dimension is null (or not specified), this will be an object with width and height properties.

If dimension is 'w' the value returned will be this element's width. If dimension is 'h' the returned value will be this element's height.

Unlike getWidth and getHeight this method only returns "precise" (sub-pixel) sizes based on the getBoundingClientRect API.

Available since: 6.5.0

Parameters

dimension :  'w'/'h' (optional)

Specifies which dimension is desired. If omitted then an object with width and height properties is returned.

Returns

:Number/Object

This element's width, height or both as a readonly object. This object may be the direct result of getBoundingClientRect and hence immutable on some browsers.

measureContent ( [dimension] ) : Number/Object
private pri

Measures and returns this element's content. When dimension is null (or not specified), this will be an object with width and height properties.

If dimension is 'w' the value returned will be this element's width. If dimension is 'h' the returned value will be this element's height.

Unlike getWidth and getHeight this method only returns "precise" (sub-pixel) sizes based on the getBoundingClientRect API.

Available since: 6.5.0

Parameters

dimension :  'w'/'h' (optional)

Specifies which dimension is desired. If omitted then an object with width and height properties is returned.

Returns

:Number/Object

This element's width, height or both as a readonly object. This object may be the direct result of getBoundingClientRect and hence immutable on some browsers.

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.SomeSharedMenu, 'show', this.doSomething);
        this.callParent();
    }
});

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

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

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

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 <ExtComponent/>. The name of a Component property which references an Ext.dom.Element to add a listener to.

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

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

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

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

 panel.body.un(...)

delegate :  String (optional)

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

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

See the delegate example below.

capture :  Boolean (optional)

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

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

stopPropagation :  Boolean (optional)

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

preventDefault :  Boolean (optional)

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

stopEvent :  Boolean (optional)

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

args :  Array (optional)

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

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

destroyable :  Boolean (optional)

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

Defaults to:

false

priority :  Number (optional)

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

order :  String (optional)

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

  • 'before': equal to a priority of 100
  • 'current': equal to a priority of 0 or default priority
  • 'after': equal to a priority of -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.

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.

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.

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.

removeCls ( names, [prefix], [suffix] )

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

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.

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, item, ename, fn, scope )
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

item :  Object

ename :  String

fn :  Function

scope :  Object

See removeManagedListener for other args

repaint ( cls, state ) : Ext.dom.Element
chainable ch

Forces the browser to repaint this element.

Parameters

cls :  Object

state :  Object

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 ( [remove], [add], [prefix], [suffix] ) : Ext.dom.Element
chainable ch

Replaces one or more CSS classes on this element with other classes. If the old name does not exist, the new name will simply be added.

Parameters

remove :  String/String[] (optional)

The CSS class(es) to be removed.

add :  String/String[] (optional)

The CSS class(es) to be added.

prefix :  String (optional)

The string to prepend to each class name.

suffix :  String (optional)

The string to append to each class name.

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 ( options ) :
chainable ch private pri

Parameters

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

ripple ( [event], [options] )

Creates a ripple effect over this element. The element should be positioned (either relative or absolute) prior to calling this method.

Parameters

event :  String/Event/Ext.event.Event (optional)

The event to use for ripple positioning.

options :  Object/String (optional)

Ripple options object or color to use for ripple

color :  String (optional)

The color to use for the ripple effect or 'default' to use the stylesheet default color Global_CSS#$ripple-background-color. When no color is given, the element's color style is used.

release :  Boolean (optional)

Optional determines if the ripple should happen on release. Defaults to down/start.

delegate :  String (optional)

Optional selector for which child to add the ripple into

measureSelector :  String (optional)

Optional selector for which child to use to measure for ripple size.

position :  Number[] (optional)

The [x,y] position in which to start the ripple.

centered :  Boolean (optional)

Set to true to override all position information and forces the ripple to be centered inside its parent.

bound :  Boolean / String (optional)

Determines if the ripple is bound to the parent container (default). If false ripple will expand outside of container.

diameterLimit :  Boolean / Number (optional)

Maximum size, in pixels, that a ripple can be. A value of false or 0 will cause the ripple to fill its container. A value of true will cause the ripple to use the default maximum size.

fit :  Boolean / String (optional)

For bound ripples only. Determines if ripple should search up the dom for an element that will fit the ripple without clipping. Setting to false will force the unbound ripple into the specified container. Defaults to true.

Defaults to:

true

destroyTime :  Number (optional)

The time (in milliseconds) to wait until the ripple is destroyed.

saveTabbableState ( options )
private pri

Parameters

options :  Object

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":"[email protected]", "phone":"555-111-1224" },
          { 'name': 'Bart',  "email":"[email protected]",  "phone":"555-222-1234" },
          { 'name': 'Homer', "email":"[email protected]",  "phone":"555-222-1244" },
          { 'name': 'Marge', "email":"[email protected]", "phone":"555-222-1254" },
          { 'name': 'Milhouse', "email":"[email protected]",
            "phone":"555-222-1244" },
          { 'name': 'Willy', "email":"[email protected]", "phone":"555-222-1254" },
          { 'name': 'Skinner', "email":"[email protected]",
            "phone":"555-222-1244" },
          { 'name': 'Hank (last row)', "email":"[email protected]",
            "phone":"555-222-1254" }
      ]},
      proxy: {
          type: 'memory',
          reader: {
              type: 'json',
              rootProperty: 'items'
          }
      }
  });

  var grid = Ext.create('Ext.grid.Panel', {
      title: 'Simpsons',
      store: Ext.data.StoreManager.lookup('simpsonsStore'),
      columns: [
          { text: 'Name',  dataIndex: 'name', width: 125 },
          { text: 'Email', dataIndex: 'email', flex: 1 },
          { text: 'Phone', dataIndex: 'phone' }
      ],
      height: 190,
      width: 400,
      renderTo: Ext.getBody(),
      tbar: [{
          text: 'Scroll row 7 into view',
          handler: function () {
              var view = grid.getView();

              Ext.get(view.getRow(7)).scrollIntoView(view.getEl(), null, true);
          }
      }]
  });

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.

selectText ( [start], [end], [direction] ) : Ext.dom.Element
chainable ch

Selects the specified contents of the input element (all by default).

Available since: 6.5.0

Parameters

start :  Number (optional)

The starting index to select.

Defaults to: 0

end :  Number (optional)

The end index to select (defaults to all remaining text).

direction :  "f"/"b"/"forward"/"backward" (optional)

Pass "f" for forward, "b" for backwards.

Defaults to: "f"

Returns

:Ext.dom.Element

this

selectable Ext.dom.Element
chainable ch

Enable text selection for this element (normalized across browsers)

Returns

:Ext.dom.Element

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

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

setClassMap ( classMap, [keep] )

Sets the CSS classes of this element to the keys of the given object. The classMap object is typically returned by getClassMap. The values of the properties in the classMap should be truthy (such as 1 or true).

Parameters

classMap :  Object

The object whose keys will be the CSS classes.

keep :  Boolean (optional)

Pass true to indicate the the classMap object can be kept (instead of copied).

Defaults to: false

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 ) : Ext.dom.Element
deprecated dep

Sets the innerHTML of this element.

Parameters

html :  String

The new HTML.

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

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

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

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

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 ( prop, [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

prop :  String/Object

The style property to be set, or an object of multiple styles.

value :  String (optional)

The value to apply to the given property, or null if an object was passed.

Returns

:Ext.dom.Element

this

setTabIndex ( tabIndex )
private pri

Parameters

tabIndex :  Object

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

setTouchAction ( touchAction ) : Ext.dom.Element

Sets the CSS 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

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, CLIP, or OPACITY.

Parameters

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

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

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

show Ext.dom.Element

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

Returns

:Ext.dom.Element

this

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

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


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

        statics.totalCreated++;
    },

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

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

        return cloned;
    }
});


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

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

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

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

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

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

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

Returns

:Ext.Class

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

Stops the specified event(s) from bubbling and optionally prevents the default action

var store = Ext.create('Ext.data.Store', {
    fields: ['name', 'email'],
    data: [{
        'name': 'Finn',
        "email": "[email protected]"
    }]
});

Ext.create('Ext.grid.Panel', {
    title: 'Land of Ooo',
    store: store,
    columns: [{
        text: 'Name',
        dataIndex: 'name'
    }, {
        text: 'Email <img style="vertical-align:middle;" src="{some-image-src}" />',
        dataIndex: 'email',
        flex: 1,
        listeners: {
            render: function(col) {
                // Swallow the click event when the click occurs on the
                // help icon - preventing the sorting of data by that
                // column and instead performing an action specific to
                // the help icon
                var img = col.getEl().down('img');
                img.swallowEvent(['click', 'mousedown'], true);
                col.on('click', function() {
                    // logic to show a help dialog
                    console.log('image click handler');
                }, col);
            }
        }
    }],
    height: 200,
    width: 400,
    renderTo: document.body
});

Parameters

eventName :  String/String[]

an event / array of events to stop from bubbling

preventDefault :  Boolean (optional)

true to prevent the default action too

Returns

:Object

Object with a destroy method to unswallow events

destroy :  Function

method to clean up any listeners that are swallowing events

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

Parameters

firstClass :  String

secondClass :  String

flag :  Boolean

prefix :  String

Returns

:Mixed

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.

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.

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 ( simpleSelector, [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

simpleSelector :  String

The simple selector to test. See Ext.dom.Query for information about simple selectors.

limit :  Number/String/HTMLElement/Ext.dom.Element (optional)

The max depth to search as a number or an element that causes the upward traversal to stop and is not considered for inclusion as the result. (defaults to 50 || document.documentElement)

returnDom :  Boolean (optional)

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

Defaults to: false

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

Sets the innerHTML of this element.

Parameters

html :  String

The new HTML.

Returns

:Ext.dom.Element

this

Deprecated since version 5.0.0
Please use setHtml instead.

visit ( options ) : *

Visits nodes in this elements tree which conform to the passed filter bitmask and calls the specified callback on each one.

Parameters

options :  Object

Properties used to affect the traverse.

callback :  Function

A method to call on every node visited. Return false to terminate the traverse.

node :  HTMLElement

The node being visited.

scope :  Object (optional)

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

selector :  String

A DOM query selector string to filter the nodes visited..

reverse :  Boolean

true to traverse the tree in reverse from lastChild to first.

excludeRoot :  Ext.dom.Element / HTMLElement (optional)

An element inside which to exclude visits.

skipSelf :  Boolean (optional)

Pass true to exclude this element.

Defaults to:

false

include :  Number (optional)

A bitwise mask of DOM node types to include. Defaults to visiting all element nodes.

Returns

:*

The return value from the last call to the callback.

watchConfig ( name, fn, scope )
private pri

Watches config properties.

 instance.watchConfig({
     title: 'onTitleChange',
     scope: me
 });

Available since: 6.7.0

Parameters

name :  Object

fn :  Object

scope :  Object

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

_onWindowResize
static sta private pri

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, privacy ) :
chainable ch static sta private pri

Parameters

name :  Object

member :  Object

privacy :  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, namespace )
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

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

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 <ExtComponent/>s. This method retrieves Ext.dom.Element objects which encapsulate DOM elements. To retrieve a Component by its ID, use Ext.ComponentManager#get.

When passing an id, it should not include the # character that is used for a css selector.

// For an element with id 'foo'
Ext.get('foo'); // Correct
Ext.get('#foo'); // Incorrect

Uses simple caching to consistently return the same object. Automatically fixes if an object was recreated with the same id via AJAX or DOM.

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.

isRelativeUnit ( size ) : Boolean
static sta

Checks if the passed css unit is a relative unit. This includes:

  • auto
  • %
  • em
  • rem
  • auto
  • vh
  • vw
  • vmin
  • vmax
  • `ex
  • ch

Available since: 6.2.0

Parameters

size :  String

The css unit and value.

Returns

:Boolean

true if the value is relative.

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

ExtAngular 7.2.0