Docs Help

Terms, Icons, and Labels

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

Access Levels

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

Member Types

Member Syntax

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

lookupComponent ( item ) : Ext.Component
protected

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

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

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

Parameters

item :  Object

The config object being added.

Returns
Ext.Component

The component to be added.

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

Member Flags

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

Class Icons

- Indicates a framework class

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

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

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

Member Icons

- Indicates a class member of type config

- Indicates a class member of type property

- Indicates a class member of type method

- Indicates a class member of type event

- Indicates a class member of type theme variable

- Indicates a class member of type theme mixin

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

Class Member Quick-Nav Menu

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

Getter and Setter Methods

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

History Bar

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

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

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

Search and Filters

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

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

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

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

API Doc Class Metadata

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

Expanding and Collapsing Examples and Class Members

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

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

Desktop -vs- Mobile View

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

Viewing the Class Source

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

Ext JS 5.0.1

Guides
API
Ext
Getting Started
What's New?
Upgrades and Migrations
Core Concepts
Architecture
UI Components
Tutorials
Backend Connectors
Other Resources
Supported Browsers
top

Ext.app.bindinspector.ComponentList xtype: bindinspector-componentlist private

Filters
Related Classes
No members found using the current filters

configs

columns : Ext.grid.column.Column[] / Object
bindable bind required req

An array of Ext.grid.column.Column definition objects which define all columns that appear in this grid. Each column definition provides the header text for the column, and a definition of where the data for that column comes from.

This can also be a configuration object for a Ext.grid.header.Container which may override certain default configurations if necessary. For example, the special layout may be overridden to use a simpler layout, or one can set default values shared by all columns:

columns: {
    items: [
        {
            text: "Column A",
            dataIndex: "field_A"
        },{
            text: "Column B",
            dataIndex: "field_B"
        },
        ...
    ],
    defaults: {
        flex: 1
    }
}

getColumns Ext.grid.column.Column[] / Object

Returns the value of columns

Returns

Ext.grid.column.Column[] / Object

setColumns ( columns )
private pri

Parameters

columns :  Object

store : Ext.data.TreeStore
bindable bind required req

The Ext.data.TreeStore the tree should use as its data source.

getStore : Ext.data.Store

Returns the store associated with this Panel.

Returns

:Ext.data.Store

The store

setStore ( store )
private pri

Parameters

store :  Object

activeCounter : Number
bindable bind private pri

An incrementing numeric counter indicating activation index for use by the zIndexManager to sort its stack.

Defaults to: 0

getActiveCounter Number

Returns the value of activeCounter

Returns

Number

setActiveCounter (activeCounter)

Sets the value of activeCounter

Parameters

activeCounter :  Number

activeItem : String / Number
bindable bind

A string component id or the numeric index of the component that should be initially activated within the container's layout on render. For example, activeItem: 'item-1' or activeItem: 0 (index 0 = the first item in the container's collection). activeItem only applies to layout styles that can display items one at a time (like Ext.layout.container.Card and Ext.layout.container.Fit).

Available since: 2.3.0

getActiveItem String / Number

Returns the value of activeItem

Returns

String / Number

setActiveItem ( item ) : Ext.Component

Sets a component as the active layout item. This only applies when using a Ext.layout.container.Card layout.

var card1 = Ext.create('Ext.panel.Panel', {itemId: 'card-1'});
            var card2 = Ext.create('Ext.panel.Panel', {itemId: 'card-2'});
            var panel = Ext.create('Ext.panel.Panel', {
                layout: 'card',
                items: [card1, card2]
            });
            // These are all equivalent
            panel.getLayout().setActiveItem(card2);
            panel.getLayout().setActiveItem('card-2');
            panel.getLayout().setActiveItem(1);
            

Parameters

item :  Ext.Component / Number / String

The component, component id, itemId, or index of component.

Returns

:Ext.Component

the activated component or false when nothing activated. False is returned also when trying to activate an already active item.

alignTarget : String

A Component or Element by which to position this component according to the defaultAlign. Defaults to ths owning Container.

Only applicable if this component is floating

Used upon first show.

Defaults to: null

allowDeselect : Boolean

True to allow deselecting a record. This config is forwarded to Ext.selection.Model#allowDeselect.

Defaults to: false

alwaysOnTop : Boolean / Number
bindable bind

A flag indicating that this component should be on the top of the z-index stack for use by the zIndexManager to sort its stack.

This may be a positive number to prioritize the ordering of multiple visible always on top components.

This may be set to a negative number to prioritize a component to the bottom of the z-index stack.

Defaults to: false

getAlwaysOnTop Boolean / Number

Returns the value of alwaysOnTop

Returns

Boolean / Number

setAlwaysOnTop (alwaysOnTop)

Sets the value of alwaysOnTop

Parameters

alwaysOnTop :  Boolean / Number

anchorSize : Number / Object

Defines the anchoring size of container. Either a number to define the width of the container or an object with width and height fields.

animate : Boolean

True to enable animated expand/collapse. Defaults to the value of Ext#enableFx.

animCollapse : Boolean

true to animate the transition when the panel is collapsed, false to skip the animation (defaults to true if the Ext.fx.Anim class is available, otherwise false). May also be specified as the animation duration in milliseconds.

Defaults to: Ext.enableFx

autoDestroy : Boolean

If true the container will automatically destroy any contained component that is removed from it, else destruction must be handled manually.

Defaults to: true

Available since: 2.3.0

autoEl : String / Object

A tag name or Ext.dom.Helper spec used to create the Element which will encapsulate this Component.

You do not normally need to specify this. For the base classes Ext.Component and Ext.container.Container, this defaults to 'div'. The more complex Sencha classes use a more complex DOM structure specified by their own renderTpls.

This is intended to allow the developer to create application-specific utility Components encapsulated by different DOM elements. Example usage:

{
    xtype: 'component',
    autoEl: {
        tag: 'img',
        src: 'http://www.example.com/example.jpg'
    }
}, {
    xtype: 'component',
    autoEl: {
        tag: 'blockquote',
        html: 'autoEl is cool!'
    }
}, {
    xtype: 'container',
    autoEl: 'ul',
    cls: 'ux-unordered-list',
    items: {
        xtype: 'component',
        autoEl: 'li',
        html: 'First list item'
    }
}

Available since: 2.3.0

autoLoad

Use true to load the store as soon as this component is fully constructed. It is best to initiate the store load this way to allow this component and potentially its plugins (such as Ext.grid.filters.Filters to be ready to load.

Defaults to: false

autoRender : Boolean / String / HTMLElement / Ext.dom.Element

This config is intended mainly for non-floating Components which may or may not be shown. Instead of using renderTo in the configuration, and rendering upon construction, this allows a Component to render itself upon first show. If floating is true, the value of this config is omitted as if it is true.

Specify as true to have this Component render to the document body upon first show.

Specify as an element, or the ID of an element to have this Component render to a specific element upon first show.

Defaults to: false

autoScroll : Boolean
bindable bind

true to use overflow:'auto' on the components layout element and show scroll bars automatically when necessary, false to clip any overflowing content. This should not be combined with overflowX or overflowY.

Defaults to: false

getAutoScroll Boolean

Returns the value of autoScroll

Returns

Boolean

setAutoScroll ( scroll ) : Ext.Component
chainable ch

Sets the overflow on the content element of the component.

Parameters

scroll :  Boolean

True to allow the Component to auto scroll.

Returns

:Ext.Component

this

autoShow : Boolean

true to automatically show the component upon creation. This config option may only be used for floating components or components that use autoRender.

Defaults to: false

Available since: 2.3.0

baseCls : String

The base CSS class to apply to this component's element. This will also be prepended to elements within this component like Panel's body will get a class x-panel-body. This means that if you create a subclass of Panel, and you want it to get all the Panels styling for the element and the body, you leave the baseCls x-panel and use componentCls to add specific styling for this component.

Defaults to: 'x-component'

bbar : Object / Object[]

Convenience config. Short for 'Bottom Bar'.

bbar: [
  { xtype: 'button', text: 'Button 1' }
]

is equivalent to

dockedItems: [{
    xtype: 'toolbar',
    dock: 'bottom',
    items: [
        { xtype: 'button', text: 'Button 1' }
    ]
}]

Defaults to: null

bind : Object / String
bindable bind

Setting this config option adds or removes data bindings for other configs. For example, to bind the title config:

 var panel = Ext.create({
     xtype: 'panel',
     bind: {
         title: 'Hello {user.name}'
     }
 });

To dynamically add bindings:

 panel.setBind({
     title: 'Greetings {user.name}!'
 });

To remove bindings:

 panel.setBind({
     title: null
 });

The bind expressions are presented to Ext.app.ViewModel#bind. The ViewModel instance is determined by lookupViewModel.

Note: If bind is passed as a string, it will use the Ext.Component#defaultBindProperty for the binding

Defaults to: null

getBind Object / String

Returns the value of bind

Returns

Object / String

setBind (bind)

Sets the value of bind

Parameters

bind :  Object / String

bodyBorder : Boolean

A shortcut to add or remove the border on the body of a panel. In the classic theme this only applies to a panel which has the frame configuration set to true.

Available since: 2.3.0

bodyCls : String / String[]

A CSS class, space-delimited string of classes, or array of classes to be applied to the panel's body element. The following examples are all valid:

bodyCls: 'foo'
bodyCls: 'foo bar'
bodyCls: ['foo', 'bar']

bodyPadding : Number / String

A shortcut for setting a padding style on the body element. The value can either be a number to be applied to all sides, or a normal css string describing padding.

bodyStyle : String / Object / Function
bindable bind

Custom CSS styles to be applied to the panel's body element, which can be supplied as a valid CSS style string, an object containing style property name/value pairs or a function that returns such a string or object. For example, these two formats are interpreted to be equivalent:

bodyStyle: 'background:#ffc; padding:10px;'

bodyStyle: {
    background: '#ffc',
    padding: '10px'
}

Available since: 2.3.0

getBodyStyle String / Object / Function

Returns the value of bodyStyle

Returns

String / Object / Function

setBodyStyle ( style , value ) : Ext.panel.Panel
chainable ch

Sets the body style according to the passed parameters.

Parameters

style :  Mixed

A full style specification string, or object, or the name of a style property to set.

value :  String

If the first param was a style property name, the style property value.

Returns

:Ext.panel.Panel

this

border : Boolean
bindable bind

Specify as false to render the Panel with zero width borders.

Leaving the value as true uses the selected theme's Ext.panel.Panel#$panel-border-width

Defaults to false when using or extending Neptune.

Defaults to: true

getBorder Boolean

Returns the value of border

Returns

Boolean

setBorder ( border , targetEl )
private pri

Parameters

border :  Object

targetEl :  Object

bubbleEvents : String[]

An array of events that, when fired, should be bubbled to any parent container. See Ext.util.Observable#enableBubble.

Available since: 3.4.0

bufferedRenderer : Boolean

Buffered rendering is enabled by default.

Configure as false to disable buffered rendering. See Ext.grid.plugin.BufferedRenderer.

Defaults to: true

Available since: 5.0.0

buttonAlign : String

The alignment of any buttons added to this panel. Valid values are 'right', 'left' and 'center' (defaults to 'right' for buttons/fbar, 'left' for other toolbar types).

NOTE: The prefered way to specify toolbars is to use the dockedItems config. Instead of buttonAlign you would add the layout: { pack: 'start' | 'center' | 'end' } option to the dockedItem config.

buttons : Object / Object[]

Convenience config used for adding buttons docked to the bottom of the panel. This is a synonym for the fbar config.

buttons: [
  { text: 'Button 1' }
]

is equivalent to

dockedItems: [{
    xtype: 'toolbar',
    dock: 'bottom',
    ui: 'footer',
    defaults: {minWidth: <a href='#cfg-minButtonWidth'>minButtonWidth</a>},
    items: [
        { xtype: 'component', flex: 1 },
        { xtype: 'button', text: 'Button 1' }
    ]
}]

The minButtonWidth is used as the default minWidth for each of the buttons in the buttons toolbar.

Defaults to: null

childEls : Object / String[] / Object[]
bindable bind

The canonical form of childEls is an object keyed by child's property name with values that are objects with the following properties.

  • itemId - The id to combine with the Component's id that is the id of the child element.
  • id - The id of the child element.
  • leaf - Set to true to ignore content when scanning for childEls. This should be set on things like the generated content for an Ext.view.View.
  • select: A selector that will be passed to Ext.dom.Element#select.
  • selectNode: A selector that will be passed to Ext.dom.Element#selectNode.

For example:

 childEls: {
     button: true,
     buttonText: 'text',
     buttonImage: {
         itemId: 'image'
     }
 }

The above is translated into the following complete form:

 childEls: {
     button: {
         name: 'button',
         itemId: 'button'
     },
     buttonText: {
         name: 'buttonText',
         itemId: 'text'
     },
     buttonImage: {
         name: 'buttonImage',
         itemId: 'image'
     }
 }

The above can be provided as an array like so:

 childEls: [
     'button',
     { name: 'buttonText', itemId: 'text' },
     { name: 'buttonImage', itemId: 'image' }
 }

For example, a Component which renders a title and body text:

When using select, the property will be an instance of Ext.CompositeElement. In all other cases, the property will be an Ext.dom.Element or null if not found.

Care should be taken when using select or selectNode to find child elements. The following issues should be considered:

  • Performance: using selectors can be 10x slower than id lookup.
  • Over-selecting: selectors are applied after the DOM elements for all children have been rendered, so selectors can match elements from child components (including nested versions of the same component) accidentally.

This above issues are most important when using select since it returns multiple elements.

Defaults to: { frameTable: { frame: true }, frameTL: { frame: 'tl' }, frameTC: { frame: 'tc' }, frameTR: { frame: 'tr' }, frameML: { frame: 'ml' }, frameBody: { frame: 'mc' }, frameMR: { frame: 'mr' }, frameBL: { frame: 'bl' }, frameBC: { frame: 'bc' }, frameBR: { frame: 'br' } }

getChildEls Object / String[] / Object[]

Returns the value of childEls

Returns

Object / String[] / Object[]

setChildEls (childEls)

Sets the value of childEls

Parameters

childEls :  Object / String[] / Object[]

closable : Boolean

True to display the 'close' tool button and allow the user to close the window, false to hide the button and disallow closing the window.

By default, when close is requested by clicking the close button in the header, the close method will be called. This will destroy the Panel and its content meaning that it may not be reused.

To make closing a Panel hide the Panel so that it may be reused, set closeAction to 'hide'.

Defaults to: false

closeAction : String

The action to take when the close header tool is clicked:

  • destroy :

    remove the window from the DOM and destroy it and all descendant Components. The window will not be available to be redisplayed via the show method.

  • hide :

    hide the window by setting visibility to hidden and applying negative offsets. The window will be available to be redisplayed via the show method.

Note: This behavior has changed! setting does affect the close method which will invoke the approriate closeAction.

Defaults to: 'destroy'

cls : String

An optional extra CSS class that will be added to this component's Element. This can be useful for adding customized styles to the component or any of its children using standard CSS rules.

Defaults to: ''

Available since: 1.1.0

collapsed : Boolean
bindable bind

true to render the panel collapsed, false to render it expanded.

Defaults to: false

getCollapsed : Boolean / String

Returns the current collapsed state of the panel.

Returns

:Boolean / String

False when not collapsed, otherwise the value of collapseDirection.

setCollapsed ( collapsed )

Collapses or expands the panel.

Parameters

collapsed :  Boolean

true to collapse the panel, false to expand it.

collapsedCls : String

A CSS class to add to the panel's element after it has been collapsed.

Defaults to: 'collapsed'

collapseDirection : String

The direction to collapse the Panel when the toggle button is clicked.

Defaults to the headerPosition

Important: This config is ignored for collapsible Panels which are direct child items of a Ext.layout.container.Border.

Specify as 'top', 'bottom', 'left' or 'right'.

collapseFirst : Boolean

true to make sure the collapse/expand toggle button always renders first (to the left of) any other tools in the panel's title bar, false to render it last.

Defaults to: true

collapseMode : String

Important: this config is only effective for collapsible Panels which are direct child items of a Ext.layout.container.Border.

When not a direct child item of a Ext.layout.container.Border, then the Panel's header remains visible, and the body is collapsed to zero dimensions. If the Panel has no header, then a new header (orientated correctly depending on the collapseDirection) will be inserted to show a the title and a re- expand tool.

When a child item of a Ext.layout.container.Border, this config has three possible values:

  • undefined - When collapsed, a placeholder Ext.panel.Header is injected into the layout to represent the Panel and to provide a UI with a Tool to allow the user to re-expand the Panel.

  • "header" - The Panel collapses to leave its header visible as when not inside a Ext.layout.container.Border.

  • "mini" - The Panel collapses without a visible header.

collapsible : Boolean
bindable bind

True to make the panel collapsible and have an expand/collapse toggle Tool added into the header tool button area. False to keep the panel sized either statically, or by an owning layout manager, with no toggle Tool. When a panel is used in a Ext.layout.container.Border, the floatable option can influence the behavior of collapsing. See collapseMode and collapseDirection

getCollapsible Boolean

Returns the value of collapsible

Returns

Boolean

setCollapsible ( collapsible )
private pri

Parameters

collapsible :  Object

columnLines : Boolean

Adds column line styling

columnWidth : Number / String

Defines the column width inside Ext.layout.container.Column.

Can be specified as a number or as a percentage.

componentCls : String

CSS Class to be added to a components root level element to give distinction to it via styling.

componentLayout : String / Object
bindable bind

The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager which sizes a Component's internal structure in response to the Component being sized.

Generally, developers will not use this configuration as all provided Components which need their internal elements sizing (Such as Ext.form.field.Base) come with their own componentLayout managers.

The Ext.layout.container.Auto will be used on instances of the base Ext.Component class which simply sizes the Component's encapsulating element to the height and width specified in the setSize method.

Defaults to: 'autocomponent'

setComponentLayout (componentLayout)

Sets the value of componentLayout

Parameters

componentLayout :  String / Object

constrain : Boolean

True to constrain the panel within its containing element, false to allow it to fall outside of its containing element. By default floating components such as Windows will be rendered to document.body. To render and constrain the window within another element specify renderTo. Optionally the header only can be constrained using constrainHeader.

Defaults to: false

constrainHeader : Boolean

True to constrain the panel header within its containing element (allowing the panel body to fall outside of its containing element) or false to allow the header to fall outside its containing element. Optionally the entire panel can be constrained using constrain.

Defaults to: false

constraintInsets : Object / String

An object or a string (in TRBL order) specifying insets from the configured constrain region within which this component must be constrained when positioning or sizing. example:

constraintInsets: '10 10 10 10' // Constrain with 10px insets from parent

constrainTo : Ext.util.Region / Ext.dom.Element

A Ext.util.Region (or an element from which a Region measurement will be read) which is used to constrain the component. Only applies when the component is floating.

contentEl : String

Specify an existing HTML element, or the id of an existing HTML element to use as the content for this component.

This config option is used to take an existing HTML element and place it in the layout element of a new component (it simply moves the specified DOM element after the Component is rendered to use as the content.

Notes:

The specified HTML element is appended to the layout element of the component after any configured HTML has been inserted, and so the document will not contain this element at the time the render event is fired.

The specified HTML element used will not participate in any layout scheme that the Component may use. It is just HTML. Layouts operate on child items.

Add either the x-hidden or the x-hidden-display CSS class to prevent a brief flicker of the content before it is rendered to the panel.

Available since: 3.4.0

controller : String / Object / Ext.app.ViewController
bindable bind

A string alias, a configuration object or an instance of a ViewController for this container. Sample usage:

Ext.define('MyApp.UserController', {
    alias: 'controller.user'
});

Ext.define('UserContainer', {
    extend: 'Ext.container.container',
    controller: 'user'
});
// Or
Ext.define('UserContainer', {
    extend: 'Ext.container.container',
    controller: {
        type: 'user',
        someConfig: true
    }
});

// Can also instance at runtime
var ctrl = new MyApp.UserController();
var view = new UserContainer({
    controller: ctrl
});

Defaults to: null

getController String / Object / Ext.app.ViewController

Returns the value of controller

Returns

String / Object / Ext.app.ViewController

setController (controller)

Sets the value of controller

Parameters

controller :  String / Object / Ext.app.ViewController

data : Object
bindable bind

The initial set of data to apply to the tpl to update the content area of the Component.

Defaults to: null

Available since: 3.4.0

getData Object

Returns the value of data

Returns

Object

setData (data)

Sets the value of data

Parameters

data :  Object

defaultAlign : String

The default Ext.dom.Element#getAlignToXY anchor position value for this component relative to its alignTarget (which defaults to its owning Container).

Only applicable if this component is floating

Used upon first show.

Defaults to: "c-c"

defaultDockWeights : Object

This object holds the default weights applied to dockedItems that have no weight. These start with a weight of 1, to allow negative weights to insert before top items and are odd numbers so that even weights can be used to get between different dock orders.

To make default docking order match border layout, do this:

 Ext.panel.Panel.prototype.defaultDockWeights = { top: 1, bottom: 3, left: 5, right: 7 };

Changing these defaults as above or individually on this object will effect all Panels. To change the defaults on a single panel, you should replace the entire object:

 initComponent: function () {
     // NOTE: Don't change members of defaultDockWeights since the object is shared.
     this.defaultDockWeights = { top: 1, bottom: 3, left: 5, right: 7 };

     this.callParent();
 }

To change only one of the default values, you do this:

 initComponent: function () {
     // NOTE: Don't change members of defaultDockWeights since the object is shared.
     this.defaultDockWeights = Ext.applyIf({ top: 10 }, this.defaultDockWeights);

     this.callParent();
 }

Defaults to: { top: { render: 1, visual: 1 }, left: { render: 3, visual: 5 }, right: { render: 5, visual: 7 }, bottom: { render: 7, visual: 3 } }

defaultListenerScope : Boolean
bindable bind

If true, this component will be the default scope (this pointer) for events specified with string names so that the scope can be dynamically resolved. The component will automatically become the defaultListenerScope if a controller is specified.

See the introductory docs for Ext.container.Container for some sample usages.

NOTE: This value can only be reliably set at construction time. Setting it after that time may not correctly rewire all of the potentially effected listeners.

Defaults to: false

getDefaultListenerScope Boolean

Returns the value of defaultListenerScope

Returns

Boolean

setDefaultListenerScope (defaultListenerScope)

Sets the value of defaultListenerScope

Parameters

defaultListenerScope :  Boolean

defaults : Object / Function

This option is a means of applying default settings to all added items whether added through the items config or via the add or insert methods.

Defaults are applied to both config objects and instantiated components conditionally so as not to override existing properties in the item (see Ext#applyIf).

If the defaults option is specified as a function, then the function will be called using this Container as the scope (this reference) and passing the added item as the first parameter. Any resulting object from that call is then applied to the item as default properties.

For example, to automatically apply padding to the body of each of a set of contained Ext.panel.Panel items, you could pass: defaults: {bodyStyle:'padding:15px'}.

Usage:

defaults: { // defaults are applied to items, not the container
    autoScroll: true
},
items: [
    // default will not be applied here, panel1 will be autoScroll: false
    {
        xtype: 'panel',
        id: 'panel1',
        autoScroll: false
    },
    // this component will have autoScroll: true
    new Ext.panel.Panel({
        id: 'panel2'
    })
]

Available since: 2.3.0

defaultType : String

The default Ext.Component of child Components to create in this Container when a child item is specified as a raw configuration object, rather than as an instantiated Component.

Defaults to: "panel"

Available since: 2.3.0

deferRowRender : Boolean

Configure as true to enable deferred row rendering.

This allows the View to execute a refresh quickly, with the update of the row structure deferred so that layouts with GridPanels appear, and lay out more quickly.

Defaults to: false

detachOnRemove : Boolean

True to move any component to the detachedBody when the component is removed from this container. This option is only applicable when the component is not destroyed while being removed, see autoDestroy and remove. If this option is set to false, the DOM of the component will remain in the current place until it is explicitly moved.

Defaults to: true

disabled : Boolean
bindable bind

true to disable the component.

Defaults to: false

Available since: 2.3.0

getDisabled Boolean

Returns the value of disabled

Returns

Boolean

setDisabled ( disabled )
chainable ch

Enable or disable the component.

Parameters

disabled :  Boolean

true to disable.

disabledCls : String

CSS class to add when the Component is disabled.

Defaults to: 'x-item-disabled'

disableSelection : Boolean

True to disable selection model.

Defaults to: false

displayField : String

The field inside the model that will be used as the node's text.

Defaults to: text

dockedItems : Object / Object[]
bindable bind

A component or series of components to be added as docked items to this panel. The docked items can be docked to either the top, right, left or bottom of a panel. This is typically used for things like toolbars or tab bars:

var panel = new Ext.panel.Panel({
    dockedItems: [{
        xtype: 'toolbar',
        dock: 'top',
        items: [{
            text: 'Docked to the top'
        }]
    }]
});

Defaults to: null

getDockedItems ( selector , beforeBody ) : Ext.Component[]

Retrieves an array of all currently docked Components.

For example to find a toolbar that has been docked at top:

panel.getDockedItems('toolbar[dock="top"]');
            

Parameters

selector :  String

A Ext.ComponentQuery selector string to filter the returned items.

beforeBody :  Boolean

An optional flag to limit the set of items to only those before the body (true) or after the body (false). All components are returned by default.

Returns

:Ext.Component[]

The array of docked components meeting the specified criteria.

setDockedItems (dockedItems)

Sets the value of dockedItems

Parameters

dockedItems :  Object / Object[]

draggable : Boolean / Object

Specify as true to make a floating Component draggable using the Component's encapsulating element as the drag handle.

This may also be specified as a config object for the Ext.util.ComponentDragger which is instantiated to perform dragging.

For example to create a Component which may only be dragged around using a certain internal element as the drag handle, use the delegate option:

new Ext.Component({
    constrain: true,
    floating: true,
    style: {
        backgroundColor: '#fff',
        border: '1px solid black'
    },
    html: '<h1 style="cursor:move">The title</h1><p>The content</p>',
    draggable: {
        delegate: 'h1'
    }
}).show();

Defaults to: false

emptyText : String

Default text (HTML tags are accepted) to display in the Panel body when the Store is empty. When specified, and the Store is empty, the text will be rendered inside a DIV with the CSS class "x-grid-empty". The emptyText will not display until the first load of the associated store by default. If you want the text to be displayed prior to the first store load use the deferEmptyText config in the viewConfig config.

enableColumnHide : Boolean

False to disable column hiding within this grid.

Defaults to: true

enableColumnMove : Boolean

False to disable column dragging within this grid.

Defaults to: true

enableColumnResize : Boolean

False to disable column resizing within this grid.

Defaults to: true

enableLocking : Boolean

Configure as true to enable locking support for this grid. Alternatively, locking will also be automatically enabled if any of the columns in the columns configuration contain a locked config option.

A locking grid is processed in a special way. The configuration options are cloned and two grids are created to be the locked (left) side and the normal (right) side. This Panel becomes merely a Ext.container.Container which arranges both in an Ext.layout.container.HBox layout.

Plugins may be targeted at either locked, or unlocked grid, or, both, in which case the plugin is cloned and used on both sides.

Plugins may also be targeted at the containing locking Panel.

This is configured by specifying a lockableScope property in your plugin which may have the following values:

  • "both" (the default) - The plugin is added to both grids
  • "top" - The plugin is added to the containing Panel
  • "locked" - The plugin is added to the locked (left) grid
  • "normal" - The plugin is added to the normal (right) grid

If both is specified, then each copy of the plugin gains a property lockingPartner which references its sibling on the other side so that they can synchronize operations is necessary.

Features may also be configured with lockableScope and may target the locked grid, the normal grid or both grids. Features also get a lockingPartner reference injected.

Defaults to: false

fbar : Object / Object[]

Convenience config used for adding items to the bottom of the panel. Short for Footer Bar.

fbar: [
  { type: 'button', text: 'Button 1' }
]

is equivalent to

dockedItems: [{
    xtype: 'toolbar',
    dock: 'bottom',
    ui: 'footer',
    defaults: {minWidth: <a href='#cfg-minButtonWidth'>minButtonWidth</a>},
    items: [
        { xtype: 'component', flex: 1 },
        { xtype: 'button', text: 'Button 1' }
    ]
}]

The minButtonWidth is used as the default minWidth for each of the buttons in the fbar.

Defaults to: null

features : Ext.grid.feature.Feature[] / Object[] / Ext.enums.Feature[]

An array of grid Features to be added to this grid. Can also be just a single feature instead of array.

Features config behaves much like plugins. A feature can be added by either directly referencing the instance:

features: [Ext.create('Ext.grid.feature.GroupingSummary', {groupHeaderTpl: 'Subject: {name}'})],

By using config object with ftype:

features: [{ftype: 'groupingsummary', groupHeaderTpl: 'Subject: {name}'}],

Or with just a ftype:

features: ['grouping', 'groupingsummary'],

See Ext.enums.Feature for list of all ftypes.

fixed : Boolean

Configure as true to have this Component fixed at its X, Y coordinates in the browser viewport, immune to scrolling the document.

Defaults to: false

floatable : Boolean

Important: This config is only effective for collapsible Panels which are direct child items of a Ext.layout.container.Border.

true to allow clicking a collapsed Panel's placeholder to display the Panel floated above the layout, false to force the user to fully expand a collapsed region by clicking the expand button to see it again.

Defaults to: true

floating : Boolean

Specify as true to float the Component outside of the document flow using CSS absolute positioning.

Components such as Ext.window.Windows and Ext.menu.Menus are floating by default.

Floating Components that are programatically rendered will register themselves with the global Ext.WindowManager

Floating Components as child items of a Container

A floating Component may be used as a child item of a Container. This just allows the floating Component to seek a ZIndexManager by examining the ownerCt chain.

When configured as floating, Components acquire, at render time, a Ext.ZIndexManager which manages a stack of related floating Components. The ZIndexManager sorts its stack according to an incrementing access counter and the alwaysOnTop config when the Component's toFront method is called.

The ZIndexManager is found by traversing up the ownerCt chain to find an ancestor which itself is floating. This is so that descendant floating Components of floating Containers (Such as a ComboBox dropdown within a Window) can have its zIndex managed relative to any siblings, but always above that floating ancestor Container.

If no floating ancestor is found, a floating Component registers itself with the default Ext.WindowManager.

Floating components do not participate in the Container's layout. Because of this, they are not rendered until you explicitly show them.

After rendering, the ownerCt reference is deleted, and the floatParent property is set to the found floating ancestor Container. If no floating ancestor Container was found the floatParent property will not be set.

Defaults to: false

focusCls : String

CSS class that will be added to focused Component, and removed when Component blurs.

Defaults to: 'x-focus'

focusOnToFront : Boolean

Specifies whether the floated component should be automatically focused when it is brought to the front.

Defaults to: true

folderSort : Boolean

True to automatically prepend a leaf sorter to the store.

forceFit : Boolean

True to force the columns to fit into the available width. Headers are first sized according to configuration, whether that be a specific width, or flex. Then they are all proportionally changed in width so that the entire content width is used. For more accurate control, it is more optimal to specify a flex setting on the columns that are to be stretched & explicit widths on columns that are not.

formBind : Boolean

When inside FormPanel, any component configured with formBind: true will be enabled/disabled depending on the validity state of the form. See Ext.form.Panel for more information and example.

Defaults to: false

frame : Boolean

True to apply a frame to the panel.

Defaults to: false

frameHeader : Boolean

True to apply a frame to the panel panels header (if 'frame' is true).

Defaults to: true

glyph : Number / String
bindable bind

A numeric unicode character code to use as the icon for the panel header. The default font-family for glyphs can be set globally using Ext.setGlyphFontFamily(). Alternatively, this config option accepts a string with the charCode and font-family separated by the @ symbol. For example '65@My Font Family'.

Defaults to: null

getGlyph Number / String

Returns the value of glyph

Returns

Number / String

setGlyph ( glyph )
private pri

Parameters

glyph :  Object

header : Boolean / Object
bindable bind

Pass as false to prevent a Header from being created and shown.

Pass as a config object (optionally containing an xtype) to custom-configure this Panel's header.

See Ext.panel.Header for all the options that may be specified here.

A Ext.panel.Header is a Ext.container.Container which contains the Panel's title and tools. You may also configure the Panel's header option with its own child items which go before the tools

By default the panel title is inserted after items configured in this config, but before any tools. To insert the title at any point in the full array, specify the titlePosition config:

new Ext.panel.Panel({
    title: 'Test',
    tools: [{
        type: 'refresh'
    }, {
        type: 'help'
    }],
    titlePosition: 2 // Title will come AFTER the two tools
    ...
});

setHeader (header)

Sets the value of header

Parameters

header :  Boolean / Object

headerOverCls : String

Optional CSS class to apply to the header element on mouseover

headerPosition : String
bindable bind

Specify as 'top', 'bottom', 'left' or 'right'.

Defaults to: 'top'

getHeaderPosition String

Returns the value of headerPosition

Returns

String

setHeaderPosition (headerPosition)

Sets the value of headerPosition

Parameters

headerPosition :  String

height : Number / String
bindable bind

The height of this component. A numeric value will be interpreted as the number of pixels; a string value will be treated as a CSS value with units.

getHeight : Number

Gets the current height of the component's underlying element.

Returns

:Number

setHeight ( height ) : Ext.Component

Sets the height of the component. This method fires the resize event.

Parameters

height :  Number

The new height to set. This may be one of:

  • A Number specifying the new height in pixels.
  • A String used to set the CSS height style.
  • undefined to leave the height unchanged.

Returns

:Ext.Component

this

hidden : Boolean
bindable bind

true to hide the component.

Defaults to: false

Available since: 2.3.0

getHidden Boolean

Returns the value of hidden

Returns

Boolean

setHidden ( hidden ) : Ext.Component

Sets the hidden state of this component. This is basically the same as setVisible but the boolean parameter has the opposite meaning.

Parameters

hidden :  Boolean

Returns

:Ext.Component

hideCollapseTool : Boolean

true to hide the expand/collapse toggle button when collapsible == true,false` to display it.

Defaults to: false

hideHeaders : Boolean

True to hide the headers.

hideMode : String

A String which specifies how this Component's encapsulating DOM element will be hidden. Values may be:

  • 'display' : The Component will be hidden using the display: none style.
  • 'visibility' : The Component will be hidden using the visibility: hidden style.
  • 'offsets' : The Component will be hidden by absolutely positioning it out of the visible area of the document. This is useful when a hidden Component must maintain measurable dimensions. Hiding using display results in a Component having zero dimensions.

Defaults to: 'display'

Available since: 1.1.0

html : String / Object
bindable bind

An HTML fragment, or a Ext.dom.Helper specification to use as the layout element content. The HTML content is added after the component is rendered, so the document will not contain this HTML at the time the render event is fired. This content is inserted into the body before any configured contentEl is appended.

Defaults to: ''

Available since: 3.4.0

getHtml String / Object

Returns the value of html

Returns

String / Object

setHtml ( html )
private pri

Parameters

html :  Object

icon : String
bindable bind

Path to image for an icon.

There are no default icons that come with Ext JS.

Defaults to: null

getIcon String

Returns the value of icon

Returns

String

setIcon ( icon )
private pri

Parameters

icon :  Object

iconAlign : 'top' / 'right' / 'bottom' / 'left'
bindable bind

The side of the title to render the icon.

Defaults to: 'left'

getIconAlign 'top' / 'right' / 'bottom' / 'left'

Returns the value of iconAlign

Returns

'top' / 'right' / 'bottom' / 'left'

setIconAlign (iconAlign)

Sets the value of iconAlign

Parameters

iconAlign :  'top' / 'right' / 'bottom' / 'left'

iconCls : String
bindable bind

CSS class for an icon.

There are no default icon classes that come with Ext JS.

Defaults to: null

getIconCls String

Returns the value of iconCls

Returns

String

setIconCls ( iconCls )
private pri

Parameters

iconCls :  Object

id : String
bindable bind

The unique id of this component instance.

Use of this config should be considered carefully as this value must be unique across all existing components. Components created with an id may be accessed globally using Ext.getCmp.

Instead of using assigned ids, consider a reference config and a ViewController to respond to events and perform processing upon this Component.

Alternatively, itemId and Ext.ComponentQuery can be used to perform selector-based searching for Components analogous to DOM querying. The Ext.container.Container class contains several helpful shortcut methods to query its descendant Components by selector.

Note that this id will also be used as the element id for the containing HTML element that is rendered to the page for this component. This allows you to write id-based CSS rules to style the specific instance of this component uniquely, and also to select sub-elements using this component's id as the parent.

Defaults to an auto-assigned id.

Note: Valid identifiers start with a letter or underscore and are followed by (optional) additional letters, underscores, digits or hyphens.

Available since: 1.1.0

getId : String

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

Returns

:String

setId (id)

Sets the value of id

Parameters

id :  String

itemId : String
bindable bind

The unique id of this component instance within its container. See also the reference config.

An itemId can be used as an alternative way to get a reference to a component when no object reference is available. Instead of using an id with getCmp, use itemId with getComponent which will retrieve itemIds or ids. Since itemIds are an index to the container's internal collection, the itemId is scoped locally to the container -- avoiding potential conflicts with Ext.ComponentManager, which requires a unique id value.

var c = new Ext.panel.Panel({ //
    <a href='Ext.Component.html#cfg-height'>height</a>: 300,
    <a href='#cfg-renderTo'>renderTo</a>: document.body,
    <a href='Ext.container.Container.html#cfg-layout'>layout</a>: 'auto',
    <a href='Ext.container.Container.html#cfg-items'>items</a>: [
        {
            itemId: 'p1',
            <a href='Ext.panel.Panel.html#cfg-title'>title</a>: 'Panel 1',
            <a href='Ext.Component.html#cfg-height'>height</a>: 150
        },
        {
            itemId: 'p2',
            <a href='Ext.panel.Panel.html#cfg-title'>title</a>: 'Panel 2',
            <a href='Ext.Component.html#cfg-height'>height</a>: 150
        }
    ]
})
p1 = c.<a href='Ext.container.Container.html#method-getComponent'>getComponent</a>('p1'); // not the same as <a href='Ext.html#method-getCmp'>Ext.getCmp()</a>
p2 = p1.<a href='#property-ownerCt'>ownerCt</a>.<a href='Ext.container.Container.html#method-getComponent'>getComponent</a>('p2'); // reference via a sibling

Also see id, Ext.container.Container#query, Ext.container.Container#down and Ext.container.Container#child.

Note: Valid identifiers start with a letter or underscore and are followed by (optional) additional letters, underscores, digits or hyphens.

Note: to access the container of an item see ownerCt.

Available since: 3.4.0

getItemId : String

Returns the value of itemId assigned to this component, or when that is not set, returns the value of id.

Returns

:String

setItemId (itemId)

Sets the value of itemId

Parameters

itemId :  String

items : Object / Object[]

A single item, or an array of child Components to be added to this container

Unless configured with a layout, a Container simply renders child Components serially into its encapsulating element and performs no sizing or positioning upon them.

Example:

// specifying a single item
items: {...},
layout: 'fit',    // The single items is sized to fit

// specifying multiple items
items: [{...}, {...}],
layout: 'hbox', // The items are arranged horizontally

Each item may be:

If a configuration object is specified, the actual type of Component to be instantiated my be indicated by using the xtype option.

Every Component class has its own xtype.

If an xtype is not explicitly specified, the defaultType for the Container is used, which by default is usually panel.

Notes:

Ext uses lazy rendering. Child Components will only be rendered should it become necessary. Items are automatically laid out when they are first shown (no sizing is done while hidden), or in response to a doLayout call.

Do not specify contentEl or html with items.

Available since: 2.3.0

layout : Ext.enums.Layout / Object
bindable bind

Important: In order for child items to be correctly sized and positioned, typically a layout manager must be specified through the layout configuration option.

The sizing and positioning of child items is the responsibility of the Container's layout manager which creates and manages the type of layout you have in mind. For example:

If the layout configuration is not explicitly specified for a general purpose container (e.g. Container or Panel) the Ext.layout.container.Auto will be used which does nothing but render child components sequentially into the Container (no sizing or positioning will be performed in this situation).

layout may be specified as either as an Object or as a String:

Specify as an Object

Example usage:

layout: {
    type: 'vbox',
    align: 'left'
}
  • type

    The layout type to be used for this container. If not specified, a default Ext.layout.container.Auto will be created and used.

    Valid layout type values are listed in Ext.enums.Layout.

  • Layout specific configuration properties

    Additional layout specific configuration properties may also be specified. For complete details regarding the valid config options for each layout type, see the layout class corresponding to the type specified.

Specify as a String

Example usage:

layout: 'vbox'
  • layout

    The layout type to be used for this container (see Ext.enums.Layout for list of valid values).

    Additional layout specific configuration properties. For complete details regarding the valid config options for each layout type, see the layout class corresponding to the layout specified.

Configuring the default layout type

If a certain Container class has a default layout (For example a Ext.toolbar.Toolbar with a default Box layout), then to simply configure the default layout, use an object, but without the type property:

xtype: 'toolbar',
layout: {
    pack: 'center'
}

Defaults to: 'auto'

Available since: 2.3.0

getLayout : Ext.layout.container.Container

Returns the Ext.layout.container.Container instance currently associated with this Container. If a layout has not been instantiated yet, that is done first

Returns

:Ext.layout.container.Container

The layout

setLayout ( configuration )

Reconfigures the initially configured layout.

NOTE: this method cannot be used to change the "type" of layout after the component has been rendered to the DOM. After rendering, this method can only modify the existing layout's configuration properties. The reason for this restriction is that many container layouts insert special wrapping elements into the dom, and the framework does not currently support dynamically changing these elements once rendered.

Parameters

configuration :  Object

object for the layout

lbar : Object / Object[]

Convenience config. Short for 'Left Bar' (left-docked, vertical toolbar).

lbar: [
  { xtype: 'button', text: 'Button 1' }
]

is equivalent to

dockedItems: [{
    xtype: 'toolbar',
    dock: 'left',
    items: [
        { xtype: 'button', text: 'Button 1' }
    ]
}]

Defaults to: null

leadingBufferZone : Number

TableViews are buffer rendered in 5.x which means that only the visible subset of data rows are rendered into the DOM. These are removed and added as scrolling demands.

This configures the number of extra rows to render on the leading side of scrolling outside the numFromEdge buffer as scrolling proceeds.

Defaults to: 20

lines : Boolean

False to disable tree lines.

Defaults to: true

listeners : Object

A config object containing one or more event handlers to be added to this object during initialization. This should be a valid listeners config object as specified in the addListener example for attaching multiple handlers at once.

DOM events from Ext JS Ext.Component

While some Ext JS Component classes export selected DOM events (e.g. "click", "mouseover" etc), this is usually only done when extra value can be added. For example the Ext.view.Views itemclick event passing the node clicked on. To access DOM events directly from a child element of a Component, we need to specify the element option to identify the Component property to add a DOM listener to:

new Ext.panel.Panel({
    width: 400,
    height: 200,
    dockedItems: [{
        xtype: 'toolbar'
    }],
    listeners: {
        click: {
            element: 'el', //bind to the underlying el property on the panel
            fn: function(){ console.log('click el'); }
        },
        dblclick: {
            element: 'body', //bind to the underlying body property on the panel
            fn: function(){ console.log('dblclick body'); }
        }
    }
});

loader : Ext.ComponentLoader / Object
bindable bind

A configuration object or an instance of a Ext.ComponentLoader to load remote content for this Component.

Ext.create('Ext.Component', {
    loader: {
        url: 'content.html',
        autoLoad: true
    },
    renderTo: Ext.getBody()
});

getLoader : Ext.ComponentLoader

Gets the Ext.ComponentLoader for this Component.

Returns

:Ext.ComponentLoader

The loader instance, null if it doesn't exist.

setLoader (loader)

Sets the value of loader

Parameters

loader :  Ext.ComponentLoader / Object

manageHeight : Boolean

When true, the dock component layout writes height information to the panel's DOM elements based on its shrink wrap height calculation. This ensures that the browser respects the calculated height. When false, the dock component layout will not write heights on the panel or its body element. In some simple layout cases, not writing the heights to the DOM may be desired because this allows the browser to respond to direct DOM manipulations (like animations).

Defaults to: true

margin : Number / String
bindable bind

Specifies the margin for this component. The margin can be a single numeric value to apply to all sides or it can be a CSS style specification for each style, for example: '10 5 3 10' (top, right, bottom, left).

getMargin Number / String

Returns the value of margin

Returns

Number / String

setMargin ( margin )

Sets the margin on the target element.

Parameters

margin :  Number / String

The margin to set. See the margin config.

maskElement : String

The name of the element property in this Panel to mask when masked by a LoadMask.

Defaults to "el" to indicate that any LoadMask should be rendered into this Panel's encapsulating element.

This could be configured to be "body" so that only the body is masked and toolbars and the header are still mouse-accessible.

Defaults to: "el"

maxHeight : Number
bindable bind

The maximum value in pixels which this Component will set its height to.

Warning: This will override any size management applied by layout managers.

Defaults to: null

getMaxHeight Number

Returns the value of maxHeight

Returns

Number

setMaxHeight (maxHeight)

Sets the value of maxHeight

Parameters

maxHeight :  Number

maxWidth : Number
bindable bind

The maximum value in pixels which this Component will set its width to.

Warning: This will override any size management applied by layout managers.

Defaults to: null

getMaxWidth Number

Returns the value of maxWidth

Returns

Number

setMaxWidth (maxWidth)

Sets the value of maxWidth

Parameters

maxWidth :  Number

minButtonWidth : Number

Minimum width of all footer toolbar buttons in pixels. If set, this will be used as the default value for the Ext.button.Button#minWidth config of each Button added to the footer toolbar via the fbar or buttons configurations. It will be ignored for buttons that have a minWidth configured some other way, e.g. in their own config object or via the defaults of their parent container.

Defaults to: 75

minHeight : Number
bindable bind

The minimum value in pixels which this Component will set its height to.

Warning: This will override any size management applied by layout managers.

Defaults to: null

getMinHeight Number

Returns the value of minHeight

Returns

Number

setMinHeight (minHeight)

Sets the value of minHeight

Parameters

minHeight :  Number

minWidth : Number
bindable bind

The minimum value in pixels which this Component will set its width to.

Warning: This will override any size management applied by layout managers.

Defaults to: null

getMinWidth Number

Returns the value of minWidth

Returns

Number

setMinWidth (minWidth)

Sets the value of minWidth

Parameters

minWidth :  Number

modelValidation : Boolean

This config enables binding to your Ext.data.Model#validators. This is only processed by form fields (e.g., Ext.form.field.Text) at present, but this setting is inherited and so can be set on a parent container.

When set to true by a component or not set by a component but inherited from an ancestor container, Ext.data.Validation records are used to automatically bind validation results for any form field to which a value is bound.

While this config can be set arbitrarily high in the component hierarchy, doing so can create a lot overhead if most of your form fields do not actually rely on validators in your data model.

Using this setting for a form that is bound to an Ext.data.Model might look like this:

 {
     xtype: 'panel',
     modelValidation: true,
     items: [{
         xtype: 'textfield',
         bind: '{theUser.firstName}'
     },{
         xtype: 'textfield',
         bind: '{theUser.lastName}'
     },{
         xtype: 'textfield',
         bind: '{theUser.phoneNumber}'
     },{
         xtype: 'textfield',
         bind: '{theUser.email}'
     }]
 }

The above is equivalent to the following manual binding of validation:

 {
     xtype: 'panel',
     items: [{
         xtype: 'textfield',
         bind: {
             value:      '{theUser.firstName}'
             validation: '{theUser.validation.firstName}'
         }
     },{
         xtype: 'textfield',
         bind: {
             value:      '{theUser.lastName}'
             validation: '{theUser.validation.lastName}'
         }
     },{
         xtype: 'textfield',
         bind: {
             value:      '{theUser.phoneNumber}'
             validation: '{theUser.validation.phoneNumber}'
         }
     },{
         xtype: 'textfield',
         bind: {
             value:      '{theUser.email}'
             validation: '{theUser.validation.email}'
         }
     }]
 }

Notice that "validation" is a pseudo-association defined for all entities. See Ext.data.Model#getValidation for further details.

multiColumnSort : Boolean

Configure as true to have columns remember their sorted state after other columns have been clicked upon to sort.

As subsequent columns are clicked upon, they become the new primary sort key.

The maximum number of sorters allowed in a Store is configurable via its underlying data collection. See Ext.util.Collection#multiSortLimit

Defaults to: false

multiSelect : Boolean
deprecated dep

True to enable 'MULTI' selection mode on selection model.

Defaults to: false

Deprecated since version 4.1.1
Use Ext.selection.Model#mode 'MULTI' instead.

numFromEdge : Number

This configures the zone which causes new rows to be appended to the view. As soon as the edge of the rendered grid is this number of rows from the edge of the viewport, the view is moved.

Defaults to: 2

overCls : String

An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. This can be useful for adding customized 'active' or 'hover' styles to the component or any of its children using standard CSS rules.

Defaults to: ''

Available since: 2.3.0

overflowX : String

Possible values are:

  • 'auto' to enable automatic horizontal scrollbar (Style overflow-x: 'auto').
  • 'scroll' to always enable horizontal scrollbar (Style overflow-x: 'scroll').

The default is overflow-x: 'hidden'. This should not be combined with autoScroll.

overflowY : String

Possible values are:

  • 'auto' to enable automatic vertical scrollbar (Style overflow-y: 'auto').
  • 'scroll' to always enable vertical scrollbar (Style overflow-y: 'scroll').

The default is overflow-y: 'hidden'. This should not be combined with autoScroll.

overlapHeader : Boolean

True to overlap the header in a panel over the framing of the panel itself. This is needed when frame:true (and is done automatically for you). Otherwise it is undefined. If you manually add rounded corners to a panel header which does not have frame:true, this will need to be set to true.

padding : Number / String

Specifies the padding for this component. The padding can be a single numeric value to apply to all sides or it can be a CSS style specification for each style, for example: '10 5 3 10' (top, right, bottom, left).

placeholder : Ext.Component / Object
bindable bind

Important: This config is only effective for collapsible Panels which are direct child items of a Ext.layout.container.Border when not using the 'header' collapseMode.

Optional. A Component (or config object for a Component) to show in place of this Panel when this Panel is collapsed by a Ext.layout.container.Border. Defaults to a generated Ext.panel.Header containing a Ext.panel.Tool to re-expand the Panel.

getPlaceholder ( direction )
private pri

Parameters

direction :  Object

setPlaceholder (placeholder)

Sets the value of placeholder

Parameters

placeholder :  Ext.Component / Object

placeholderCollapseHideMode : Number

The mode for hiding collapsed panels when using collapseMode "placeholder".

Defaults to: Ext.Element.VISIBILITY

plugins : Ext.plugin.Abstract[] / Ext.plugin.Abstract / Object[] / Object / Ext.enums.Plugin[] / Ext.enums.Plugin
bindable bind

An array of plugins to be added to this component. Can also be just a single plugin instead of array.

Plugins provide custom functionality for a component. The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself. Each plugin can then call methods or respond to events on the component as needed to provide its functionality.

Plugins can be added to component by either directly referencing the plugin instance:

plugins: [Ext.create('Ext.grid.plugin.CellEditing', {clicksToEdit: 1})],

By using config object with ptype:

plugins: {ptype: 'cellediting', clicksToEdit: 1},

Or with just a ptype:

plugins: ['cellediting', 'gridviewdragdrop'],

See Ext.enums.Plugin for list of all ptypes.

Available since: 2.3.0

getPlugins
private pri

Returns an array of current fully constructed plugin instances.

setPlugins (plugins)

Sets the value of plugins

Parameters

plugins :  Ext.plugin.Abstract[] / Ext.plugin.Abstract / Object[] / Object / Ext.enums.Plugin[] / Ext.enums.Plugin

preventHeader : Boolean
deprecated dep

Defaults to: false

Deprecated since version 4.1.0
Use #header instead. Prevent a Header from being created and shown.

publishes : String / String[] / Object
bindable bind

One or more names of config properties that this component should publish to its ViewModel. Some components override this and publish their most useful configs by default.

This config uses the reference to determine the name of the data object to place in the ViewModel. If reference is not set then this config is ignored.

By using this config and reference you can bind configs between components. For example:

 ...
     items: [{
         xtype: 'textfield',
         reference: 'somefield',  // component's name in the ViewModel
         publishes: 'value' // value is not published by default
     },{
         ...
     },{
         xtype: 'displayfield',
         bind: 'You have entered "{somefield.value}"'
     }]
 ...

Classes must provide this config as an Object:

 Ext.define('App.foo.Bar', {
     publishes: {
         foo: true,
         bar: true
     }
 });

This is required for the config system to properly merge values from derived classes.

For instances this value can be specified as a value as show above or an array or object as follows:

 {
     xtype: 'textfield',
     reference: 'somefield',
     publishes: [
         'value',
         'rawValue',
         'dirty'
     ]
 }

 // This achieves the same result as the above array form.
 {
     xtype: 'textfield',
     reference: 'somefield',
     publishes: {
         value: true,
         rawValue: true,
         dirty: true
     }
 }

Defaults to: null

Available since: 5.0.0

getPublishes String / String[] / Object

Returns the value of publishes

Returns

String / String[] / Object

setPublishes (publishes)

Sets the value of publishes

Parameters

publishes :  String / String[] / Object

rbar : Object / Object[]

Convenience config. Short for 'Right Bar' (right-docked, vertical toolbar).

rbar: [
  { xtype: 'button', text: 'Button 1' }
]

is equivalent to

dockedItems: [{
    xtype: 'toolbar',
    dock: 'right',
    items: [
        { xtype: 'button', text: 'Button 1' }
    ]
}]

Defaults to: null

reference : String
bindable bind

Specifies a name for this component inside its component hierarchy. This name must be unique within its view or its Ext.app.ViewController. See the documentation in Ext.container.Container for more information about references.

Note: Valid identifiers start with a letter or underscore and are followed by zero or more additional letters, underscores or digits. References are case sensitive.

Defaults to: null

getReference String

Returns the value of reference

Returns

String

setReference (reference)

Sets the value of reference

Parameters

reference :  String

referenceHolder : Boolean

If true, this container will be marked as being a point in the hierarchy where references to items with a specified reference config will be held. The container will automatically become a referenceHolder if a controller is specified.

See the introductory docs for Ext.container.Container for more information about references & reference holders.

region : "north" / "south" / "east" / "west" / "center"
bindable bind

Defines the region inside Ext.layout.container.Border.

Possible values:

  • north - Positions component at top.
  • south - Positions component at bottom.
  • east - Positions component at right.
  • west - Positions component at left.
  • center - Positions component at the remaining space. There must be a component with region: "center" in every border layout.

getRegion : Ext.util.Region

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

Returns

:Ext.util.Region

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

setRegion (region)

Sets the value of region

Parameters

region :  "north" / "south" / "east" / "west" / "center"

renderData : Object

The data used by renderTpl in addition to the following property values of the component:

  • id
  • ui
  • uiCls
  • baseCls
  • componentCls
  • frame

See renderSelectors and childEls for usage examples.

renderSelectors : Object
deprecated dep

An object containing properties specifying CSS selectors which identify child elements created by the render process.

After the Component's internal structure is rendered according to the renderTpl, this object is iterated through, and the found Elements are added as properties to the Component using the renderSelector property name.

For example, a Component which renders a title and description into its element:

 Ext.create('Ext.Component', {
     renderTo: Ext.getBody(),
     renderTpl: [
         '<h1 class="title">{title}</h1>',
         '<p>{desc}</p>'
     ],
     renderData: {
         title: "Error",
         desc: "Something went wrong"
     },
     renderSelectors: {
         titleEl: 'h1.title',
         descEl: 'p'
     },
     listeners: {
         afterrender: function(cmp){
             // After rendering the component will have a titleEl and descEl properties
             cmp.titleEl.setStyle({color: "red"});
         }
     }
 });

The use of renderSelectors is deprecated (for performance reasons). The above code should be refactored into something like this:

 Ext.create('Ext.Component', {
     renderTo: Ext.getBody(),
     renderTpl: [
         '<h1 class="title" id="{id}-titleEl" data-ref="titleEl">{title}</h1>',
         '<p id="{id}-descEl" data-ref="descEl">{desc}</p>'
     ],
     renderData: {
         title: "Error",
         desc: "Something went wrong"
     },
     childEls: [
         'titleEl',
         'descEl'
     ]
 });

To use childEls yet retain the use of selectors (which remains as expensive as renderSelectors):

 Ext.create('Ext.Component', {
     renderTo: Ext.getBody(),
     renderTpl: [
         '<h1 class="title">{title}</h1>',
         '<p>{desc}</p>'
     ],
     renderData: {
         title: "Error",
         desc: "Something went wrong"
     },
     childEls: {
         titleEl: { selectNode: 'h1.title' },
         descEl: { selectNode: 'p' }
     }
 });

Deprecated since version 5.0
Use #childEls instead.

renderTo : String / HTMLElement / Ext.dom.Element

Specify the id of the element, a DOM element or an existing Element that this component will be rendered into.

Notes:

Do not use this option if the Component is to be a child item of a Ext.container.Container. It is the responsibility of the Ext.container.Containers layout manager to render and manage its child items.

When using this config, a call to render() is not required.

See also: render.

Available since: 2.3.0

renderTpl : Ext.XTemplate / String / String[]
protected pro

An Ext.XTemplate used to create the internal structure inside this Component's encapsulating Element.

You do not normally need to specify this. For the base classes Ext.Component and Ext.container.Container, this defaults to null which means that they will be initially rendered with no internal structure; they render their Element empty. The more specialized Ext JS and Sencha Touch classes which use a more complex DOM structure, provide their own template definitions.

This is intended to allow the developer to create application-specific utility Components with customized internal structure.

Upon rendering, any created child elements may be automatically imported into object properties using the renderSelectors and childEls options.

Defaults to: [ '<tpl if="renderScroller">', '<div class="{scrollerCls}" style="{%this.renderPadding(out, values)%}">', '</tpl>', '{%this.renderContent(out,values)%}', '<tpl if="renderScroller"></div></tpl>' ]

reserveScrollbar : Boolean

Set this to true to always leave a scrollbar sized space at the end of the grid content when fitting content into the width of the grid.

If the grid's record count fluctuates enough to hide and show the scrollbar regularly, this setting avoids the multiple layouts associated with switching from scrollbar present to scrollbar not present.

Defaults to: false

resizable : Boolean / Object

Specify as true to apply a Ext.resizer.Resizer to this Component after rendering.

May also be specified as a config object to be passed to the constructor of Ext.resizer.Resizer to override any defaults. By default the Component passes its minimum and maximum size, and uses Ext.resizer.Resizer#dynamic: false`

resizeHandles : String

A valid Ext.resizer.Resizer handles config string. Only applies when resizable = true.

Defaults to: 'all'

root : Ext.data.Model / Ext.data.TreeModel / Object

Allows you to not specify a store on this TreePanel. This is useful for creating a simple tree with preloaded data without having to specify a TreeStore and Model. A store and model will be created and root will be passed to that store. For example:

Ext.create('Ext.tree.Panel', {
    title: 'Simple Tree',
    root: {
        text: "Root node",
        expanded: true,
        children: [
            { text: "Child 1", leaf: true },
            { text: "Child 2", leaf: true }
        ]
    },
    renderTo: Ext.getBody()
});

Defaults to: null

rootVisible : Boolean

False to hide the root node.

Note that trees always have a root node. If you do not specify a root node, one will be created.

If the root node is not visible, then in order for a tree to appear to the end user, the root node is autoloaded with its child nodes.

Defaults to: true

rowLines : Boolean

Configure as true to separate rows with visible horizontal lines (depends on theme).

Defaults to: false

saveDelay : Number

A buffer to be applied if many state events are fired within a short period.

Defaults to: 100

scroll : String / Boolean

Scrollers configuration. Valid values are 'both', 'horizontal' or 'vertical'. True implies 'both'. False implies 'none'.

Defaults to: true

sealedColumns : Boolean

True to constrain column dragging so that a column cannot be dragged in or out of it's current group. Only relevant while enableColumnMove is enabled.

Defaults to: false

selection
bindable bind private pri

Defaults to: null

getSelection : Ext.data.Model[]

Returns the grid's selection. See Ext.selection.Model#getSelection. Returns an array of the currently selected records.

Returns

:Ext.data.Model[]

The selected records

setSelection (selection)

Sets the value of selection

Parameters

selection :  Object

selModel : Ext.selection.Model / Object

A Ext.selection.Model instance or config object. In latter case the selType config option determines to which type of selection model this config is applied.

selType : String

An xtype of selection model to use. This is used to create selection model if just a config object or nothing at all given in selModel config.

Defaults to: 'rowmodel'

session : Boolean / Object / Ext.data.Session
bindable bind

If provided this creates a new Session instance for this component. If this is a Container, this will then be inherited by all child components.

To create a new session you can specify true:

 Ext.create({
     xtype: 'viewport',
     session: true,

     items: [{
         ...
     }]
 });

Alternatively, a config object can be provided:

 Ext.create({
     xtype: 'viewport',
     session: {
         ...
     },

     items: [{
         ...
     }]
 });

Defaults to: null

getSession Boolean / Object / Ext.data.Session

Returns the value of session

Returns

Boolean / Object / Ext.data.Session

setSession (session)

Sets the value of session

Parameters

session :  Boolean / Object / Ext.data.Session

shadow : String / Boolean

Specifies whether the floating component should be given a shadow. Set to true to automatically create an Ext.Shadow, or a string indicating the shadow's display Ext.Shadow#mode. Set to false to disable the shadow.

Defaults to: 'sides'

shadowOffset : Number

Number of pixels to offset the shadow.

shrinkWrap : Boolean / Number

If this property is a number, it is interpreted as follows:

  • 0 (or false): Neither width nor height depend on content.
  • 1: Width depends on content (shrink wraps), but height does not.
  • 2 (default): Height depends on content (shrink wraps), but width does not.
  • 3 (or true): Both width and height depend on content (shrink wrap).

In CSS terms, shrink-wrap width is analogous to an inline-block element as opposed to a block-level element. Some container layouts always shrink-wrap their children, effectively ignoring this property (e.g., Ext.layout.container.HBox, Ext.layout.container.VBox, Ext.layout.component.Dock).

Defaults to: 2

shrinkWrapDock : Boolean / Number

Allows for this panel to include the dockedItems when trying to determine the overall size of the panel. This option is only applicable when this panel is also shrink wrapping in the same dimensions. See Ext.Component#shrinkWrap for an explanation of the configuration options.

Defaults to: false

simpleDrag : Boolean

When draggable is true, Specify this as true to cause the draggable config to work the same as it does in Ext.window.Window. This Panel just becomes movable. No DragDrop instances receive any notifications. For example:

Defaults to: false

simpleSelect : Boolean
deprecated dep

True to enable 'SIMPLE' selection mode on selection model.

Defaults to: false

Deprecated since version 4.1.1
Use Ext.selection.Model#mode 'SIMPLE' instead.

singleExpand : Boolean

True if only 1 node per branch may be expanded.

Defaults to: false

sortableColumns : Boolean

False to disable column sorting via clicking the header and via the Sorting menu items.

Defaults to: true

stateEvents : String[]

stateEvents may be any type of event supported by this object, including browser or custom events (e.g., ['click', 'customerchange']).

See stateful for an explanation of saving and restoring object state.

stateful : Boolean

A flag which causes the object to attempt to restore the state of internal properties from a saved state on startup. The object must have a stateId for state to be managed.

Auto-generated ids are not guaranteed to be stable across page loads and cannot be relied upon to save and restore the same state for a object.

For state saving to work, the state manager's provider must have been set to an implementation of Ext.state.Provider which overrides the set and get methods to save and recall name/value pairs. A built-in implementation, Ext.state.CookieProvider is available.

To set the state provider for the current page:

Ext.state.Manager.setProvider(new Ext.state.CookieProvider({ expires: new Date(new Date().getTime()+(10006060247)), //7 days from now }));

A stateful object attempts to save state when one of the events listed in the stateEvents configuration fires.

To save state, a stateful object first serializes its state by calling getState.

The Component base class implements getState to save its width and height within the state only if they were initially configured, and have changed from the configured value.

The Panel class saves its collapsed state in addition to that.

The Grid class saves its column state and store state (sorters and filters and grouper) in addition to its superclass state.

If there is more application state to be save, the developer must provide an implementation which first calls the superclass method to inherit the above behaviour, and then injects new properties into the returned object.

The value yielded by getState is passed to Ext.state.Manager#set which uses the configured Ext.state.Provider to save the object keyed by the stateId.

During construction, a stateful object attempts to restore its state by calling Ext.state.Manager#get passing the stateId

The resulting object is passed to applyState*. The default implementation of applyState simply copies properties into the object, but a developer may override this to support restoration of more complex application state.

You can perform extra processing on state save and restore by attaching handlers to the beforestaterestore, staterestore, beforestatesave and statesave events.

Defaults to: false

stateId : String
bindable bind

The unique id for this object to use for state management purposes.

See stateful for an explanation of saving and restoring state.

getStateId : String
private pri

Gets the state id for this object.

Returns

:String

The 'stateId' or the implicit 'id' specified by component configuration.

setStateId (stateId)

Sets the value of stateId

Parameters

stateId :  String

style : String / Object
bindable bind

A custom style specification to be applied to this component's Element. Should be a valid argument to Ext.dom.Element#applyStyles.

new Ext.panel.Panel({
    title: 'Some Title',
    renderTo: Ext.getBody(),
    width: 400, height: 300,
    layout: 'form',
    items: [{
        xtype: 'textarea',
        style: {
            width: '95%',
            marginBottom: '10px'
        }
    },
    new Ext.button.Button({
        text: 'Send',
        minWidth: '100',
        style: {
            marginBottom: '10px'
        }
    })
    ]
});

Available since: 1.1.0

getStyle String / Object

Returns the value of style

Returns

String / Object

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

Sets the style for this Component's primary element.

Parameters

property :  String / Object

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

value :  String (optional)

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

Returns

:Ext.Component

this

suspendLayout : Boolean

If true, suspend calls to doLayout. Useful when batching multiple adds to a container and not passing them as multiple arguments or an array.

Defaults to: false

tabIndex : Number
bindable bind

DOM tabIndex attribute for this Focusable

getTabIndex : Number

Return the actual tabIndex for this Focusable.

Returns

:Number

tabIndex attribute value

setTabIndex ( newTabIndex )

Set the tabIndex property for this Focusable. If the focusEl is avalable, set tabIndex attribute on it, too.

Parameters

newTabIndex :  Number

new tabIndex to set

tbar : Object / Object[]

Convenience config. Short for 'Top Bar'.

tbar: [
  { xtype: 'button', text: 'Button 1' }
]

is equivalent to

dockedItems: [{
    xtype: 'toolbar',
    dock: 'top',
    items: [
        { xtype: 'button', text: 'Button 1' }
    ]
}]

Defaults to: null

title : String
bindable bind

The title text to be used to display in the Ext.panel.Header. Or a config object for a Ext.panel.Title. When a title is specified the Ext.panel.Header will automatically be created and displayed unless header is set to false.

Defaults to: null

getTitle String

Returns the value of title

Returns

String

setTitle ( title )
private pri

Parameters

title :  Object

titleAlign : String
bindable bind

The alignment of the title text within the available space between the icon and the tools.

Defaults to: 'left'

getTitleAlign String

Returns the value of titleAlign

Returns

String

setTitleAlign (titleAlign)

Sets the value of titleAlign

Parameters

titleAlign :  String

titleCollapse : Boolean

true to allow expanding and collapsing the panel (when collapsible = true) by clicking anywhere in the header bar,false`) to allow it only by clicking to tool button). When a panel is used in a Ext.layout.container.Border, the floatable option can influence the behavior of collapsing.

titleRotation : 'default' / 0 / 1 / 2
bindable bind

The rotation of the header's title text. Can be one of the following values:

  • 'default' - use the default rotation, depending on the dock position of the header
  • 0 - no rotation
  • 1 - rotate 90deg clockwise
  • 2 - rotate 90deg counter-clockwise

The default behavior of this config depends on the dock position of the header:

  • 'top' or 'bottom' - 0
  • 'right' - 1
  • 'left' - 1

Defaults to: 'default'

getTitleRotation 'default' / 0 / 1 / 2

Returns the value of titleRotation

Returns

'default' / 0 / 1 / 2

setTitleRotation (titleRotation)

Sets the value of titleRotation

Parameters

titleRotation :  'default' / 0 / 1 / 2

toFrontOnShow : Boolean

True to automatically call toFront when the show method is called on an already visible, floating component.

Defaults to: true

tools : Object[] / Ext.panel.Tool[]

An array of Ext.panel.Tool configs/instances to be added to the header tool area. The tools are stored as child components of the header container. They can be accessed using down and {#query}, as well as the other component methods. The toggle tool is automatically created if collapsible is set to true.

Note that, apart from the toggle tool which is provided when a panel is collapsible, these tools only provide the visual button. Any required functionality must be provided by adding handlers that implement the necessary behavior.

Example usage:

tools:[{
    type:'refresh',
    tooltip: 'Refresh form Data',
    // hidden:true,
    handler: function(event, toolEl, panelHeader) {
        // refresh logic
    }
},
{
    type:'help',
    tooltip: 'Get Help',
    callback: function(panel, tool, event) {
        // show help here
    }
}]

The difference between handler and callback is the signature. For details on the distinction, see Ext.panel.Tool.

tpl : Ext.XTemplate / Ext.Template / String / String[]
bindable bind

An Ext.Template, Ext.XTemplate or an array of strings to form an Ext.XTemplate. Used in conjunction with the data and tplWriteMode configurations.

Available since: 3.4.0

getTpl ( name )
private pri

Parameters

name :  Object

setTpl (tpl)

Sets the value of tpl

Parameters

tpl :  Ext.XTemplate / Ext.Template / String / String[]

tplWriteMode : String

The Ext.(X)Template method to use when updating the content area of the Component. See Ext.XTemplate#overwrite for information on default mode.

Defaults to: 'overwrite'

Available since: 3.4.0

trailingBufferZone : Number

TableViews are buffer rendered in 5.x which means that only the visible subset of data rows are rendered into the DOM. These are removed and added as scrolling demands.

This configures the number of extra rows to render on the trailing side of scrolling outside the numFromEdge buffer as scrolling proceeds.

Defaults to: 10

twoWayBindable : String / String[] / Object
bindable bind private pri

This object holds a map of config properties that will update their binding as they are modified. For example, value is a key added by form fields. The form of this config is the same as publishes.

This config is defined so that updaters are not created and added for all bound properties since most cannot be modified by the end-user and hence are not appropriate for two-way binding.

Defaults to: null

getTwoWayBindable String / String[] / Object

Returns the value of twoWayBindable

Returns

String / String[] / Object

setTwoWayBindable (twoWayBindable)

Sets the value of twoWayBindable

Parameters

twoWayBindable :  String / String[] / Object

ui : String
bindable bind

A UI style for a component.

Defaults to: 'default'

setUI ( ui )
private pri

Parameters

ui :  Object

uiCls : String[]
private pri

An array of of classNames which are currently applied to this component.

Defaults to: []

useArrows : Boolean

True to use Vista-style arrows in the tree.

Defaults to: false

variableRowHeight : Boolean
deprecated dep

Defaults to: false

Deprecated since version 5.0.0
Use Ext.grid.column.Column#variableRowHeight instead. Configure as `true` if the row heights are not all the same height as the first row.

view : Ext.view.Table
bindable bind

The Ext.view.Table used by the grid. Use viewConfig to just supply some config options to view (instead of creating an entire View instance).

getView : Ext.view.Table

Gets the view for this panel.

Returns

:Ext.view.Table

setView (view)

Sets the value of view

Parameters

view :  Ext.view.Table

viewConfig : Object

A config object that will be applied to the grid's UI view. Any of the config options available for Ext.view.Table can be specified here. This option is ignored if view is specified.

viewModel : String / Object / Ext.app.ViewModel
bindable bind

The ViewModel is a data provider for this component and its children. The data contained in the ViewModel is typically used by adding bind configs to the components that want present or edit this data.

When set, the ViewModel is created and links to any inherited viewModel instance from an ancestor container as the "parent". The ViewModel hierarchy, once established, only supports creation or destruction of children. The parent of a ViewModel cannot be changed on the fly.

If this is a root-level ViewModel, the data model connection is made to this component's associated Ext.data.Session. This is determined by calling getInheritedSession.

Defaults to: null

getViewModel String / Object / Ext.app.ViewModel

Returns the value of viewModel

Returns

String / Object / Ext.app.ViewModel

setViewModel (viewModel)

Sets the value of viewModel

Parameters

viewModel :  String / Object / Ext.app.ViewModel

viewType : String
protected pro

An xtype of view to use. This is automatically set to 'gridview' by Ext.grid.Panel and to 'treeview' by Ext.tree.Panel.

Defaults to: null

weight : Number

A value to control how Components are laid out in a Ext.layout.container.Border layout or as docked items.

In a Border layout, this can control how the regions (not the center) region lay out if the west or east take full height or if the north or south region take full width. Also look at the Ext.layout.container.Border#regionWeights on the Border layout. An example to show how you can take control of this is:

Ext.create('Ext.container.Viewport', {
    layout      : 'border',
    defaultType : 'panel',
    items       : [
        {
            region : 'north',
            title  : 'North',
            height : 100
        },
        {
            region : 'south',
            title  : 'South',
            height : 100,
            weight : -25
        },
        {
            region : 'west',
            title  : 'West',
            width  : 200,
            weight : 15
        },
        {
            region : 'east',
            title  : 'East',
            width  : 200
        },
        {
            region : 'center',
            title  : 'center'
        }
    ]
});

If docked items, the weight will order how the items are laid out. Here is an example to put a Ext.toolbar.Toolbar above a Ext.panel.Panels header:

Ext.create('Ext.panel.Panel', {
    renderTo    : document.body,
    width       : 300,
    height      : 300,
    title       : 'Panel',
    html        : 'Panel Body',
    dockedItems : [
        {
            xtype : 'toolbar',
            items : [
                {
                    text : 'Save'
                }
            ]
        },
        {
            xtype  : 'toolbar',
            weight : -10,
            items  : [
                {
                    text : 'Remove'
                }
            ]
        }
    ]
});

Defaults to: null

width : Number / String
bindable bind

The width of this component. A numeric value will be interpreted as the number of pixels; a string value will be treated as a CSS value with units.

getWidth : Number

Gets the current width of the component's underlying element.

Returns

:Number

setWidth ( width ) : Ext.Component

Sets the width of the component. This method fires the resize event.

Parameters

width :  Number

The new width to setThis may be one of:

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

Returns

:Ext.Component

this

xtype : Ext.enums.Widget

This property provides a shorter alternative to creating objects than using a full class name. Using xtype is the most common way to define component instances, especially in a container. For example, the items in a form containing text fields could be created explicitly like so:

 items: [
     Ext.create('Ext.form.field.Text', {
         fieldLabel: 'Foo'
     }),
     Ext.create('Ext.form.field.Text', {
         fieldLabel: 'Bar'
     }),
     Ext.create('Ext.form.field.Number', {
         fieldLabel: 'Num'
     })
 ]

But by using xtype, the above becomes:

 items: [
     {
         xtype: 'textfield',
         fieldLabel: 'Foo'
     },
     {
         xtype: 'textfield',
         fieldLabel: 'Bar'
     },
     {
         xtype: 'numberfield',
         fieldLabel: 'Num'
     }
 ]

When the xtype is common to many items, Ext.container.Container#defaultType is another way to specify the xtype for all items that don't have an explicit xtype:

 defaultType: 'textfield',
 items: [
     { fieldLabel: 'Foo' },
     { fieldLabel: 'Bar' },
     { fieldLabel: 'Num', xtype: 'numberfield' }
 ]

Each member of the items array is now just a "configuration object". These objects are used to create and configure component instances. A configuration object can be manually used to instantiate a component using Ext#widget:

 var text1 = Ext.create('Ext.form.field.Text', {
     fieldLabel: 'Foo'
 });

 // or alternatively:

 var text1 = Ext.widget({
     xtype: 'textfield',
     fieldLabel: 'Foo'
 });

This conversion of configuration objects into instantiated components is done when a container is created as part of its {Ext.container.AbstractContainer#initComponent} process. As part of the same process, the items array is converted from its raw array form into a Ext.util.MixedCollection instance.

You can define your own xtype on a custom Ext.Component by specifying the xtype property in Ext#define. For example:

Ext.define('MyApp.PressMeButton', {
    extend: 'Ext.button.Button',
    xtype: 'pressmebutton',
    text: 'Press Me'
});

Care should be taken when naming an xtype in a custom component because there is a single, shared scope for all xtypes. Third part components should consider using a prefix to avoid collisions.

Ext.define('Foo.form.CoolButton', {
    extend: 'Ext.button.Button',
    xtype: 'ux-coolbutton',
    text: 'Cool!'
});

See Ext.enums.Widget for list of all available xtypes.

Available since: 2.3.0

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

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

_isLayoutRoot : Boolean
protected pro

Setting this property to true causes the isLayoutRoot method to return true and stop the search for the top-most component for a layout.

Defaults to: false

_renderState : Number
readonly ro private pri

This property holds one of the following values during the render process:

  • 0 - The component is not rendered.
  • 1 - The component has fired beforerender and is about to call beforeRender. The component has just started rendering.
  • 2 - The component has finished the beforeRender process and is about to call onRender. This is when rendering is set to true.
  • 3 - The component has started onRender. This is when rendered is set to true.
  • 4 - The component has finished its afterrender process.

Defaults to: 0

Available since: 5.0.0

autoGenId : Boolean
private pri

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

Defaults to: false

beforeBlur
protected pro

Template method to do any pre-blur processing.

Defaults to: Ext.emptyFn

Parameters

e :  Ext.event.Event

The event object

beforeFocus
protected pro

Template method to do any pre-focus processing.

Defaults to: Ext.emptyFn

Parameters

e :  Ext.event.Event

The event object

body : Ext.dom.Element
readonly ro

The Panel's body Ext.dom.Element which may be used to contain HTML content. The content may be specified in the html config, or it may be loaded using the loader config. Read-only.

If this is used to load visible HTML elements in either way, then the Panel may not be used as a Layout for hosting nested Panels.

If this Panel is intended to be used as the host of a Layout (See layout then the body Element must not be loaded or changed - it is under the control of the Panel's Layout.

componentLayoutCounter : Number
private pri

The number of component layout calls made on this object.

Defaults to: 0

contentPaddingProperty : String

The name of the padding property that is used by the layout to manage padding. See managePadding

Defaults to: 'bodyPadding'

convertPositionSpec
private pri

By default this method does nothing but return the position spec passed to it. In rtl mode it is overridden to convert "l" to "r" and vice versa when required.

Defaults to: Ext.identityFn

dd : Ext.dd.DragSource / Ext.util.ComponentDragger
private pri

Only present if this Panel has been configured with draggable true.

Simple dragging

If this Panel is configured simpleDrag true (the default is false), this property will reference an instance of Ext.util.ComponentDragger (A subclass of Ext.dd.DragTracker) which handles moving the Panel's DOM Element, and constraining according to the constrain and constrainHeader .

This object fires various events during its lifecycle and during a drag operation.

Complex dragging interacting with other DragDrop instances

By default, this property in a draggable Panel will contain an instance of Ext.dd.DragSource which handles dragging the Panel.

The developer must provide implementations of the abstract methods of Ext.dd.DragSource in order to supply behaviour for each stage of the drag/drop process. See draggable.

Defaults to: new Ext.panel.DD(me, Ext.isBoolean(me.draggable) ? null : me.draggable)

defaultBindProperty : String
protected pro

This property is used to determine the property of a bind config that is just the value. For example, if defaultBindProperty="value", then this shorthand bind config:

 bind: '{name}'

Is equivalent to this object form:

 bind: {
     value: '{name}'
 }

The defaultBindProperty is set to "value" for form fields and to "store" for grids and trees.

Defaults to: null

eventsSuspended
private pri

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

Defaults to: 0

floatParent : Ext.container.Container
readonly ro

Only present for floating Components which were inserted as child items of Containers.

There are other similar relationships such as the Ext.button.Button which activates a menu, or the Ext.menu.Item which activated a submenu, or the Ext.grid.column.Column which activated the column menu.

These differences are abstracted away by the up method.

Floating Components that are programatically rendered will not have a floatParent property.

See floating and zIndexManager

focusable : Boolean

true for interactive Components, false for static Components

frameSize : Object
readonly ro

Indicates the width of any framing elements which were added within the encapsulating element to provide graphical, rounded borders. See the frame config. This property is null if the component is not framed.

This is an object containing the frame width in pixels for all four sides of the Component containing the following properties:

Defaults to: null

Properties

top : Number

The width of the top framing element in pixels.

Defaults to: 0

right : Number

The width of the right framing element in pixels.

Defaults to: 0

bottom : Number

The width of the bottom framing element in pixels.

Defaults to: 0

left : Number

The width of the left framing element in pixels.

Defaults to: 0

width : Number

The total width of the left and right framing elements in pixels.

Defaults to: 0

height : Number

The total height of the top and right bottom elements in pixels.

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

hasView : Boolean

True to indicate that a view has been injected into the panel.

Defaults to: false

horizontalDocks
private pri

Number of dock 'left' and 'right' items.

Defaults to: 0

initFocusable
protected pro

Template method to do any Focusable related initialization that does not involve event listeners creation.

Defaults to: Ext.emptyFn

isComponent : Boolean

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

Defaults to: true

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

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

isPanel : Boolean

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

Defaults to: true

items : Ext.util.AbstractMixedCollection

The MixedCollection containing all the child items of this container.

Defaults to: new Ext.util.AbstractMixedCollection(false, me.getComponentId)

Available since: 2.3.0

layoutCounter : Number
private pri

The number of container layout calls made on this object.

Defaults to: 0

liquidLayout
private pri

Components that achieve their internal layout results using solely CSS with no JS intervention must set this to true. Failure to set this property to true may result in setSize failing to work if the component opted out of the layout run.

Defaults to: false

maskOnDisable : Boolean

This is an internal flag that you use when creating custom components. By default this is set to true which means that every component gets a mask when it's disabled. Components like FieldContainer, FieldSet, Field, Button, Tab override this property to false since they want to implement custom disable logic.

Defaults to: true

optimizedColumnMove : Boolean

If you are writing a grid plugin or a {Ext.grid.feature.Feature Feature} which creates a column-based structure which needs a view refresh when columns are moved, then set this property in the grid.

An example is the built in Ext.grid.feature.AbstractSummary Feature. This creates summary rows, and the summary columns must be in the same order as the data columns. This plugin sets the optimizedColumnMove to `false.

ownerCt : Ext.container.Container
readonly ro

This Component's owner Ext.container.Container (is set automatically when this Component is added to a Container).

Important. This is not a universal upwards navigation pointer. It indicates the Container which owns and manages this Component if any. There are other similar relationships such as the Ext.button.Button which activates a menu, or the Ext.menu.Item which activated a submenu, or the Ext.grid.column.Column which activated the column menu.

These differences are abstracted away by the up method.

Note: to access items within the Container see itemId.

Available since: 2.3.0

ownerGrid : Ext.view.Table
readonly ro private pri

A reference to the top-level owning grid component.

This is a reference to this GridPanel if this GridPanel is not part of a locked grid arrangement.

Defaults to: null

Available since: 5.0.0

postBlur
protected pro

Template method to do any post-blur processing.

Defaults to: Ext.emptyFn

Parameters

e :  Ext.event.Event

The event object

postFocus
protected pro

Template method to do any post-focus processing.

Defaults to: Ext.emptyFn

Parameters

e :  Ext.event.Event

The event object

rendered : Boolean
readonly ro

Indicates whether or not the component has been rendered.

Defaults to: false

Available since: 1.1.0

scrollFlags : Object
readonly ro private pri

An object property which provides unified information as to which dimensions are scrollable based upon the autoScroll, overflowX and overflowY settings (And for views of trees and grids, the owning panel's scroll setting).

Note that if you set overflow styles using the style config or bodyStyle config, this object does not include that information; it is best to use autoScroll, overflowX and overflowY if you need to access these flags.

This object has the following properties:

Defaults to: { overflowX: ox, overflowY: oy, x: ox = (ox === 'auto' || ox === 'scroll'), y: oy = (oy === 'auto' || oy === 'scroll'), both: ox && oy }

Properties

x : Boolean

true if this Component is scrollable horizontally - style setting may be 'auto' or 'scroll'.

y : Boolean

true if this Component is scrollable vertically - style setting may be 'auto' or 'scroll'.

both : Boolean

true if this Component is scrollable both horizontally and vertically.

overflowX : String

The overflow-x style setting, 'auto' or 'scroll' or ''.

overflowY : String

The overflow-y style setting, 'auto' or 'scroll' or ''.

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

setAutoScroll
private pri

autoScroll is never valid for all classes which extend TablePanel.

Defaults to: Ext.emptyFn

synthetic : Boolean
private pri

This property is true if the component was created internally by the framework and is not explicitly user-defined. This is set for such things as Splitter instances managed by border and box layouts.

Defaults to: false

validRefRe : RegExp
private pri

Regular expression used for validating reference values.

Defaults to: /^[a-z_][a-z0-9_]*$/i

zIndexManager : Ext.ZIndexManager
readonly ro

Only present for floating Components after they have been rendered.

A reference to the ZIndexManager which is managing this Component's z-index.

The Ext.ZIndexManager maintains a stack of floating Component z-indices, and also provides a single modal mask which is insert just beneath the topmost visible modal floating Component.

Floating Components may be brought to the front or sent to the back of the z-index stack.

This defaults to the global Ext.WindowManager for floating Components that are programatically rendered.

For floating Components which are added to a Container, the ZIndexManager is acquired from the first ancestor Container found which is floating. If no floating ancestor is found, the global Ext.WindowManager is used.

See Ext.Component#floating and zIndexParent

zIndexParent : Ext.container.Container
readonly ro

Only present for Ext.Component#floating Components which were inserted as child items of Containers, and which have a floating Container in their containment ancestry.

For Ext.Component#floating Components which are child items of a Container, the zIndexParent will be a floating ancestor Container which is responsible for the base z-index value of all its floating descendants. It provides a Ext.ZIndexManager which provides z-indexing services for all its descendant floating Components.

Floating Components that are programatically rendered will not have a zIndexParent property.

For example, the dropdown Ext.view.BoundList of a ComboBox which is in a Window will have the Window as its zIndexParent, and will always show above that Window, wherever the Window is placed in the z-index stack.

See Ext.Component#floating and zIndexManager

$onExtended
static sta private pri

Defaults to: []

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

_decr_ ( ev )
private pri

Parameters

ev :  Object

_incr_ ( ev )
private pri

Parameters

ev :  Object

add ( component ) : Ext.Component[] / Ext.Component

Adds Ext.Component(s) to this Container.

Description:

Notes:

If the Container is already rendered when add is called, it will render the newly added Component into its content area.

If the Container was configured with a size-managing layout manager, the Container will recalculate its internal layout at this time too.

Note that the default layout manager simply renders child Components sequentially into the content area and thereafter performs no sizing.

If adding multiple new child Components, pass them as an array to the add method, so that only one layout recalculation is performed.

tb = new <a href='Ext.toolbar.Toolbar.html'>Ext.toolbar.Toolbar</a>({
    renderTo: document.body
});  // toolbar is rendered
// add multiple items.
// (<a href='#cfg-defaultType'>defaultType</a> for <a href='Ext.toolbar.Toolbar.html'>Ext.toolbar.Toolbar</a> is 'button')
tb.add([{text:'Button 1'}, {text:'Button 2'}]);

To inject components between existing ones, use the insert method.

Warning:

Components directly managed by the BorderLayout layout manager may not be removed or added. See the Notes for Ext.layout.container.Border for more details.

Available since: 2.3.0

Parameters

component :  Ext.Component[] / Object[] / Ext.Component... / Object...

Either one or more Components to add or an Array of Components to add. See items for additional information.

Returns

:Ext.Component[] / Ext.Component

The Components that were added.

addBindableUpdater ( property )
private pri

Ensures that the given property (if it is a Config System config) has a proper "updater" method on this instance to sync changes to the config.

Available since: 5.0.0

Parameters

property :  String

The name of the config property.

addBodyCls ( cls ) : Ext.panel.Panel
chainable ch

Adds a CSS class to the body element. If not rendered, the class will be added when the panel is rendered.

Parameters

cls :  String

The class to add

Returns

:Ext.panel.Panel

this

addCachedConfig ( config , isMixin )
private pri

Parameters

config :  Object

isMixin :  Object

addClass ( cls ) : Ext.Component
deprecated dep

Adds a CSS class to the top level element representing this component.

Available since: 2.3.0

Parameters

cls :  String / String[]

The CSS class name to add.

Returns

:Ext.Component

Returns the Component to allow method chaining.

Deprecated since version 4.1
Use #addCls instead.

addCls ( cls ) : Ext.Component
chainable ch

Adds a CSS class to the top level element representing this component.

Parameters

cls :  String / String[]

The CSS class name to add.

Returns

:Ext.Component

Returns the Component to allow method chaining.

addClsWithUI ( classes , [skip] )

Adds a cls to the uiCls array, which will also call addUIClsToElement and adds to all elements of this component.

Parameters

classes :  String / String[]

A string or an array of strings to add to the uiCls.

skip :  Boolean (optional)

true to skip adding it to the class and do it later (via the return).

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

addDocked ( items , [pos] ) : Ext.Component[]

Adds docked item(s) to the container.

Parameters

items :  Object / Object[]

The Component or array of components to add. The components must include a 'dock' parameter on each component to indicate where it should be docked ('top', 'right', 'bottom', 'left').

pos :  Number (optional)

The index at which the Component will be added

Returns

:Ext.Component[]

The added components.

addEvents
deprecated dep private pri

Deprecated
addEvents

addFocusListener
private pri

Sets up the focus listener on this Component's focusEl if it has one.

Form Components which must implicitly participate in tabbing order usually have a naturally focusable element as their focusEl, and it is the DOM event of that receiving focus which drives the Component's onFocus handling, and the DOM event of it being blurred which drives the onBlur handling.

addListener ( element , listeners , scope , options )
private pri

Parameters

element :  Object

listeners :  Object

scope :  Object

options :  Object

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

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

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

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

addPlugin ( plugin )
private pri

Parameters

plugin :  Object

addPropertyToState ( state , propName , [value] ) : Boolean
protected pro

Save a property to the given state object if it is not its default or configured value.

Parameters

state :  Object

The state object.

propName :  String

The name of the property on this object to save.

value :  String (optional)

The value of the state property (defaults to this[propName]).

Returns

:Boolean

The state object or a new object if state was null and the property was saved.

addStateEvents ( events )

Add events that will trigger the state to be saved. If the first argument is an array, each element of that array is the name of a state event. Otherwise, each argument passed to this method is the name of a state event.

Parameters

events :  String / String[]

The event name or an array of event names.

addTool ( tools )

Add tools to this panel

Parameters

tools :  Object[] / Ext.panel.Tool[]

The tools to add

addTools
template tpl protected pro

Template method to be implemented in subclasses to add their tools after the collapsible tool.

This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.

addUIClsToElement ( cls )
private pri

Parameters

cls :  Object

addUIToElement
private pri

Method which adds a specified UI to the components element.

adjustForConstraints ( xy , parent )
private pri

Parameters

xy :  Object

parent :  Object

adjustPosition ( x , y )
private pri

Parameters

x :  Object

y :  Object

afterClassMixedIn ( targetClass )
private pri

Called after the mixin is applied. We need to see if childEls were used by the targetClass and apply them to the config.

Parameters

targetClass :  Ext.Class

afterFirstLayout ( width , height )
private pri

Parameters

width :  Object

height :  Object

afterHide ( [callback] , [scope] )
template tpl protected pro

Invoked after the Component has been hidden.

Gets passed the same callback and scope parameters that #onHide received.

Parameters

callback :  Function (optional)

scope :  Object (optional)

This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.

afterLayout ( layout )
template tpl protected pro

Invoked after the Container has laid out (and rendered if necessary) its child Components.

Parameters

This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.

afterMethod ( method , fn , scope )
private pri

Parameters

method :  Object

fn :  Object

scope :  Object

afterRender
template tpl protected pro

Allows addition of behavior after rendering is complete. At this stage the Component's Element will have been styled according to the configuration, will have had any configured CSS class names added, and will be in the configured visibility and the configured enable state.

This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.

afterSetPosition ( x , y )
template tpl protected pro

Template method called after a Component has been positioned.

Parameters

x :  Number

y :  Number

This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.

afterShow ( [animateTarget] , [callback] , [scope] )
template tpl protected pro

Invoked after the Component is shown (after #onShow is called).

Gets passed the same parameters as #show.

Parameters

animateTarget :  String / Ext.dom.Element (optional)

callback :  Function (optional)

scope :  Object (optional)

This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.

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").
  • One anchor (deprecated): The passed anchor position is used as the target element's anchor point. The element being aligned will position its top-left corner (tl) to that point. This method has been deprecated in favor of the newer two anchor syntax below.
  • 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.

In addition to the anchor points, the position parameter also supports the "?" character. If "?" is passed at the end of the position string, the element will attempt to align as specified, but the position will be adjusted to constrain to the viewport if necessary. Note that the element being aligned might be swapped to align to a different position than that specified in order to enforce the viewport constraints. Following are all of the supported anchor positions:

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

Example Usage:

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

// align the top left corner of el with the top right corner of other-el
// (constrained to viewport)
el.alignTo("other-el", "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]);

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

anim ( config )
private pri

Parameters

config :  Object

animate ( animObj ) :
chainable ch private pri

Parameters

animObj :  Object

Returns

:

applyBind ( binds , currentBindings ) : Object
private pri

Available since: 5.0.0

Parameters

binds :  String / Object

currentBindings :  Object

Returns

:Object

applyData ( data )
private pri

Parameters

data :  Object

applyRenderSelectors
private pri

Sets references to elements inside the component. This applies renderSelectors as well as childEls.

applySession ( session ) : Ext.data.Session
private pri

Transforms a Session config to a proper instance.

Available since: 5.0.0

Parameters

session :  Object

Returns

:Ext.data.Session

applyState ( state )
private pri

Parameters

state :  Object

applyViewModel ( viewModel ) : Ext.app.ViewModel
private pri

Transforms a ViewModel config to a proper instance.

Available since: 5.0.0

Parameters

viewModel :  String / Object / Ext.app.ViewModel

Returns

:Ext.app.ViewModel

attachChildEls ( el , owner )
private pri

Sets references to elements inside the component.

Parameters

el :  Object

owner :  Object

attachReference ( component )
private pri

Sets up a component reference.

Parameters

component :  Ext.Component

The component to reference.

beforeComponentLayout ( adjWidth , adjHeight ) : Boolean
template tpl protected pro

Occurs before componentLayout is run. Returning false from this method will prevent the componentLayout from being executed.

Parameters

adjWidth :  Number

The box-adjusted width that was set.

adjHeight :  Number

The box-adjusted height that was set.

Returns

:Boolean

This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.

beforeLayout
template tpl protected pro

Occurs before componentLayout is run. In previous releases, this method could return false to prevent its layout but that is not supported in Ext JS 4.1 or higher. This method is simply a notification of the impending layout to give the component a chance to adjust the DOM. Ideally, DOM reads should be avoided at this time to reduce expensive document reflows.

This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.

beforeMethod ( method , fn , scope )
private pri

Parameters

method :  Object

fn :  Object

scope :  Object

beforeSetPosition ( x , y , animate )
private pri

Template method called before a Component is positioned.

Ensures that the position is adjusted so that the Component is constrained if so configured.

Parameters

x :  Object

y :  Object

animate :  Object

beforeShow
template tpl protected pro

Invoked before the Component is shown.

This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.

beginCollapse
private pri

Called before the change from default, configured state into the collapsed state. This method may be called at render time to enable rendering in an initially collapsed state, or at runtime when an existing, fully layed out Panel may be collapsed. It basically saves configs which need to be clobbered for the duration of the collapsed state.

bindStore ( store , initial )
private pri

Parameters

store :  Object

initial :  Object

bubble ( fn , [scope] , [args] ) : Ext.Component
chainable ch

Bubbles up the component/container hierarchy, calling the specified function with each component. The scope (this) of function call will be the scope provided or the current component. The arguments to the function will be the args provided or the current component. If the function returns false at any point, the bubble is stopped.

Parameters

fn :  Function

The function to call

scope :  Object (optional)

The scope of the function. Defaults to current node.

args :  Array (optional)

The args to call the function with. Defaults to passing the current component.

Returns

:Ext.Component

this

buildNode ( comp )
private pri

Parameters

comp :  Object

cacheRefEls ( el )
private pri

Ensures that all elements with "data-ref" attributes get loaded into the cache. This really helps on IE8 where getElementById is a search not a lookup. By populating our cache with one search of the DOM we then have random access to the elements as we do our childEls wire up.

Parameters

el :  Object

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

Override of Positionable method to calculate constrained position based upon possibly only constraining our header.

Parameters

constrainTo :  Object

proposedPosition :  Object

local :  Object

proposedSize :  Object

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

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

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

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

Lastly, it also works with overridden static methods.

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

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

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

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

Parameters

args :  Array / Arguments

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

Returns

:Object

Returns the result of calling the parent method

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

cancelFocus
protected pro

Cancel any deferred focus on this component

cascade ( fn , [scope] , [args] ) : Ext.container.Container
chainable ch

Cascades down the component/container heirarchy from this component (passed in the first call), calling the specified function with each component. The scope (this reference) of the function call will be the scope provided or the current component. The arguments to the function will be the args provided or the current component. If the function returns false at any point, the cascade is stopped on that branch.

Available since: 2.3.0

Parameters

fn :  Function

The function to call

scope :  Object (optional)

The scope of the function (defaults to current component)

args :  Array (optional)

The args to call the function with. The current component always passed as the last argument.

Returns

:Ext.container.Container

this

center : Ext.Component
chainable ch

Center this Component in its container.

Returns

:Ext.Component

this

child ( [selector] ) :

Retrieves the first direct child of this container which matches the passed selector or component. The passed in selector must comply with an Ext.ComponentQuery selector, or it can be an actual Ext.Component.

Parameters

selector :  String / Ext.Component (optional)

An Ext.ComponentQuery selector. If no selector is specified, the first child will be returned.

Returns

:

Ext.Component The matching child Ext.Component (or null if no match was found).

clearListeners

Removes all listeners for this object including the managed listeners

clearManagedListeners

Removes all managed listeners for this object.

clearReference ( component )
private pri

Clear a component reference.

Parameters

component :  Ext.Component

The component to remove.

clearReferences
private pri

Invalidates the references collection. Typically called when removing a container from this container, since it's difficult to know what references got removed.

cloneConfig ( overrides ) : Ext.Component

Clone the current component using the original config values passed into this instance by default.

Parameters

overrides :  Object

A new config containing any properties to override in the cloned version. An id property can be passed on this object, otherwise one will be generated to avoid duplicates.

Returns

:Ext.Component

clone The cloned copy of this component

close

Closes the Panel. By default, this method, removes it from the DOM, destroys the Panel object and all its descendant Components. The beforeclose event is fired before the close happens and will cancel the close action if it returns false.

Note: This method is also affected by the closeAction setting. For more explicit control use destroy and hide methods.

collapse ( [direction] , [animate] ) : Ext.panel.Panel
chainable ch

Collapses the panel body so that the body becomes hidden. Docked Components parallel to the border towards which the collapse takes place will remain visible. Fires the beforecollapse event which will cancel the collapse action if it returns false.

Parameters

direction :  String (optional)

The direction to collapse towards. Must be one of

  • Ext.Component.DIRECTION_TOP
  • Ext.Component.DIRECTION_RIGHT
  • Ext.Component.DIRECTION_BOTTOM
  • Ext.Component.DIRECTION_LEFT

Defaults to collapseDirection.

animate :  Boolean (optional)

True to animate the transition, else false (defaults to the value of the animCollapse panel config). May also be specified as the animation duration in milliseconds.

Returns

:Ext.panel.Panel

this

collapseAll ( [callback] , [scope] )

Collapse all nodes

Parameters

callback :  Function (optional)

A function to execute when the collapse finishes.

scope :  Object (optional)

The scope of the callback function

collapseNode ( record , [deep] , [callback] , [scope] )

Collapses a record that is loaded in the tree.

Parameters

record :  Ext.data.Model

The record to collapse

deep :  Boolean (optional)

True to collapse nodes all the way up the tree hierarchy.

callback :  Function (optional)

The function to run after the collapse is completed

scope :  Object (optional)

The scope of the callback function.

constrainBox ( box )
private pri

Parameters

box :  Object

constructPlugin ( ptype )
private pri

Parameters

ptype :  String / Object

string or config object containing a ptype property.

Constructs a plugin according to the passed config object/ptype string.

Ensures that the constructed plugin always has a cmp reference back to this component. The setting up of this is done in PluginManager. The PluginManager ensures that a reference to this component is passed to the constructor. It also ensures that the plugin's setCmp method (if any) is called.

constructPlugins
private pri

Returns an array of fully constructed plugin instances. This converts any configs into their appropriate instances.

It does not mutate the plugins array. It creates a new array.

constructor ( config )
private pri

Parameters

config :  Object

contains ( comp , [deep] ) : Boolean

Determines whether the passed Component is either an immediate child of this Container, or whether it is a descendant.

Parameters

comp :  Ext.Component

The Component to test.

deep :  Boolean (optional)

Pass true to test for the Component being a descendant at any level.

Defaults to: false

Returns

:Boolean

true if the passed Component is contained at the specified level.

convertCollapseDir ( collapseDir )

converts a collapsdDir into an anchor argument for Element.slideIn overridden in rtl mode to switch "l" and "r"

Parameters

collapseDir :  Object

createGhost ( cls )
private pri

Parameters

cls :  Object

createReExpander ( direction , defaults )
private pri

Parameters

direction :  Object

defaults :  Object

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

Creates an event handling function which refires the event from this object as the passed event name.

Parameters

newName :  String

The name under which to refire the passed parameters.

beginEnd :  Array (optional)

The caller can specify on which indices to slice.

Returns

:Function

disable :
chainable ch

Disables all child input fields and buttons.

Returns

:

doApplyRenderTpl ( out , values )
private pri

Called from the selected frame generation template to insert this Component's inner structure inside the framing structure.

When framing is used, a selected frame generation template is used as the primary template of the #getElConfig instead of the configured renderTpl. The renderTpl is invoked by this method which is injected into the framing template.

Parameters

out :  Object

values :  Object

doAutoRender
private pri

Handles autoRender. Floating Components may have an ownerCt. If they are asking to be constrained, constrain them within that ownerCt, and have their z-index managed locally. Floating Components are always rendered to document.body

doCollapseExpand ( flags , animate ) :
chainable ch private pri

Parameters

flags :  Object

animate :  Object

Returns

:

doComponentLayout : Ext.Component
chainable ch deprecated dep

This method needs to be called whenever you change something on this component that requires the Component's layout to be recalculated.

Returns

:Ext.Component

this

Deprecated since version 4.1
Use #updateLayout instead.

doConstrain ( [constrainTo] )

Moves this floating Component into a constrain region.

By default, this Component is constrained to be within the container it was added to, or the element it was rendered to.

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 floating Component was rendered.

doFireEvent ( eventName , args , bubbles )
private pri

Continue to fire event.

Parameters

eventName :  String

args :  Array

bubbles :  Boolean

doLayout : Ext.container.Container
chainable ch deprecated dep

Manually force this container's layout to be recalculated.

Available since: 2.3.0

Returns

:Ext.container.Container

this

Deprecated since version 4.1
Use `#updateLayout` instead.

doRenderDockedItems ( out , renderData , after )
private pri

Parameters

out :  Object

renderData :  Object

after :  Object

down ( [selector] ) :

Retrieves the first descendant of this container which matches the passed selector. The passed in selector must comply with an Ext.ComponentQuery selector, or it can be an actual Ext.Component.

Parameters

selector :  String / Ext.Component (optional)

An Ext.ComponentQuery selector or Ext.Component. If no selector is specified, the first child will be returned.

Returns

:

Ext.Component The matching descendant Ext.Component (or null if no match was found).

enable :
chainable ch

Enables all child input fields and buttons.

Returns

:

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.

ensureAttachedToBody ( [runLayout] )

Ensures that this component is attached to document.body. If the component was rendered to Ext#getDetachedBody, then it will be appended to document.body. Any configured position is also restored.

Parameters

runLayout :  Boolean (optional)

True to run the component's layout.

Defaults to: false

expand ( [animate] ) : Ext.panel.Panel
chainable ch

Expands the panel body so that it becomes visible. Fires the beforeexpand event which will cancel the expand action if it returns false.

Parameters

animate :  Boolean (optional)

True to animate the transition, else false (defaults to the value of the animCollapse panel config). May also be specified as the animation duration in milliseconds.

Returns

:Ext.panel.Panel

this

expandAll ( [callback] , [scope] )

Expand all nodes

Parameters

callback :  Function (optional)

A function to execute when the expand finishes.

scope :  Object (optional)

The scope of the callback function

expandNode ( record , [deep] , [callback] , [scope] )

Expands a record that is loaded in the tree.

Parameters

record :  Ext.data.Model

The record to expand

deep :  Boolean (optional)

True to expand nodes all the way down the tree hierarchy.

callback :  Function (optional)

The function to run after the expand is completed

scope :  Object (optional)

The scope of the callback function.

expandPath ( path , [field] , [separator] , [callback] , [scope] )

Expand the tree to the path of a particular node.

Parameters

path :  String

The path to expand. The path should include a leading separator.

field :  String (optional)

The field to get the data from. Defaults to the model idProperty.

separator :  String (optional)

A separator to use.

Defaults to: '/'

callback :  Function (optional)

A function to execute when the expand finishes. The callback will be called with (success, lastNode) where success is if the expand was successful and lastNode is the last node that was expanded.

scope :  Object (optional)

The scope of the callback function

filterComponentTree ( field , val )
private pri

Parameters

field :  Object

val :  Object

filterFn ( node )
private pri

Parameters

node :  Object

findParentBy ( fn ) : Ext.container.Container

Find a container above this component at any level by a custom function. If the passed function returns true, the container will be returned.

See also the up method.

Parameters

fn :  Function

The custom function to call with the arguments (container, this component).

Returns

:Ext.container.Container

The first Container for which the custom function returns true

findParentByType ( xtype ) : Ext.container.Container

Find a container above this component at any level by xtype or class

See also the up method.

Parameters

xtype :  String / Ext.Class

The xtype string for a component, or the class of the component directly

Returns

:Ext.container.Container

The first Container which matches the given xtype or class

findPlugin ( ptype ) : Ext.plugin.Abstract

Retrieves plugin from this component's collection by its ptype.

Parameters

ptype :  String

The Plugin's ptype as specified by the class's alias configuration.

Returns

:Ext.plugin.Abstract

plugin instance.

findReExpander ( direction )
private pri

Parameters

direction :  Object

finishRender ( containerIdx )
private pri

This method visits the rendered component tree in a "top-down" order. That is, this code runs on a parent component before running on a child. This method calls the onRender method of each component.

Parameters

containerIdx :  Number

The index into the Container items of this Component.

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.

fireHierarchyEvent ( eventName )
private pri

This method fires an event on Ext.GlobalEvents allowing interested parties to know of certain critical events for this component. This is done globally because the (few) listeners can immediately receive the event rather than bubbling the event only to reach the top and have no listeners.

The main usage for these events is to do with floating components. For example, the load mask is a floating component. The component it is masking may be inside several containers. As such, they need to know when component is hidden, either directly, or via a parent container being hidden. To do this they subscribe to these events and filter out the appropriate container.

This functionality is contained in Component (as opposed to Container) because a Component can be the ownerCt for a floating component (loadmask), and the loadmask needs to know when its owner is shown/hidden so that its hidden state can be synchronized.

Available since: 4.2.0

Parameters

eventName :  String

The event name.

fitContainer ( animate )
private pri

Parameters

animate :  Object

fixReference
private pri

Sets up a reference on our current reference holder.

fn ( field )
private pri

Parameters

field :  Object

focus ( [selectText] , [delay] , [callback] , [scope] ) : Ext.Component
chainable ch

Try to focus this component.

Parameters

selectText :  Mixed (optional)

If applicable, true to also select all the text in this component, or an array consisting of start and end (defaults to start) position of selection.

delay :  Boolean / Number (optional)

Delay the focus this number of milliseconds (true for 10 milliseconds).

callback :  Function (optional)

Only needed if the delay parameter is used. A function to call upon focus.

scope :  Function (optional)

Only needed if the delay parameter is used. The scope (this reference) in which to execute the callback.

Returns

:Ext.Component

The focused Component. Usually this Component. Some Containers may delegate focus to a descendant Component (Ext.window.Windows can do this through their defaultFocus config option.

forceComponentLayout
deprecated dep

Updates this component's layout. If this update affects this components ownerCt, that component's updateLayout method will be called to perform the layout instead. Otherwise, just this component (and its child items) will layout.

Deprecated since version 4.1
Use #updateLayout instead.

get
private pri

getActiveAnimation : Ext.fx.Anim / Boolean

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

Returns

:Ext.fx.Anim / Boolean

Anim if element has active effects, else false

getAlignToXY ( element , [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

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]

Returns

:Number[]

[x, y]

getAnchorToXY ( el , anchor , local , mySize )
private pri

Parameters

el :  Object

anchor :  Object

local :  Object

mySize :  Object

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

getAnimateTarget ( target )
private pri

Parameters

target :  Object

getBind

see: bind

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

getBubbleTarget
protected pro

Implements an upward event bubbling policy. By default a Component bubbles events up to its reference owner.

Component subclasses may implement a different bubbling strategy by overriding this method.

getChecked : Ext.data.TreeModel[]

Retrieve an array of checked records.

Returns

:Ext.data.TreeModel[]

An array containing the checked records

getChildByElement ( el , deep ) : Ext.Component

Return the immediate child Component in which the passed element is located.

Parameters

el :  Ext.dom.Element / HTMLElement / String

The element to test (or ID of element).

deep :  Boolean

If true, returns the deepest descendant Component which contains the passed element.

Returns

:Ext.Component

The child item which contains the passed element.

getChildItemsToDisable : Ext.Component[]
private pri

Gets a list of child components to enable/disable when the container is enabled/disabled

Returns

:Ext.Component[]

Items to be enabled/disabled

getComponent ( comp ) : Ext.Component

Attempts a default component lookup (see Ext.container.Container#getComponent). If the component is not found in the normal items, the dockedItems are searched and the matched component (if any) returned (see getDockedComponent). Note that docked items will only be matched by component id or itemId -- if you pass a numeric index only non-docked child components will be searched.

Available since: 2.3.0

Parameters

comp :  String / Number

The component id, itemId or position to find

Returns

:Ext.Component

The component (if found)

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

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

Parameters

name :  String (optional)

The name of the config property to get.

peek :  Boolean (optional)

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

Defaults to: false

Returns

:Object

The config property value.

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

see: data

getDockedComponent ( comp ) : Ext.Component

Finds a docked component by id, itemId or position. Also see getDockedItems

Parameters

comp :  String / Number

The id, itemId or position of the docked component (see getComponent for details)

Returns

:Ext.Component

The docked component (if found)

getDockingRefItems ( deep , containerItems )
private pri

Parameters

deep :  Object

containerItems :  Object

getEl : Ext.dom.Element

Retrieves the top level element representing this component.

Available since: 1.1.0

Returns

:Ext.dom.Element

getFocusClsEl : Ext.dom.Element
private pri

Returns the focus styling holder element associated with this Focusable. By default it is the same element as getFocusEl.

Returns

:Ext.dom.Element

The focus styling element.

getFocusEl : Ext.dom.Element
private pri

Returns the focus holder element associated with this Container. By default, this is the Container's target element. Subclasses which use embedded focusable elements (such as Window and Button) should override this for use by the focus method.

Returns

:Ext.dom.Element

the focus holding element.

getFrameInfo : Boolean
private pri

On render, reads an encoded style attribute, "filter" from the style of this Component's element. This information is memoized based upon the CSS class name of this Component's element. Because child Components are rendered as textual HTML as part of the topmost Container, a dummy div is inserted into the document to receive the document element's CSS class name, and therefore style attributes.

Returns

:Boolean

getFrameTpl ( table )
private pri

Parameters

table :  Object

getHeaderCollapsedClasses ( header )
private pri

Parameters

header :  Object

getHtml

see: html

getIcon

see: icon

getId

see: id

getInherited ( [inner] ) : Object

This method returns an object containing the inherited properties for this instance.

Available since: 5.0.0

Parameters

inner :  Boolean (optional)

Pass true to return inheritedStateInner instead of the normal inheritedState object. This is only needed internally and should not be passed by user code.

Defaults to: false

Returns

:Object

The inheritedState object containing inherited properties.

getInheritedConfig ( property , [skipThis] ) : Mixed

This method returns the value of a config property that may be inherited from some ancestor.

In some cases, a config may be explicitly set on a component with the intent of only being presented to its children while that component should act upon the inherited value (see referenceHolder for example). In these cases the skipThis parameter should be specified as true.

Available since: 5.0.0

Parameters

property :  String

The name of the config property to return.

skipThis :  Boolean (optional)

Pass true if the property should be ignored if found on this instance. In other words, true means the property must be inherited and not explicitly set on this instance.

Defaults to: false

Returns

:Mixed

The value of the requested property.

getInitialConfig ( [name] ) : Object / Mixed

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

Parameters

name :  String (optional)

Name of the config option to return.

Returns

:Object / Mixed

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

getInsertPosition ( position ) : HTMLElement

This function takes the position argument passed to onRender and returns a DOM element that you can use in the insertBefore.

Parameters

position :  String / Number / Ext.dom.Element / HTMLElement

Index, element id or element you want to put this component before.

Returns

:HTMLElement

DOM element that you can use in the insertBefore

getLhsMarker
private pri

Gets left hand side marker for header resizing.

getMaskTarget
protected pro

Returns the element which is masked by the mask method, or into which the LoadMask is rendered into.

The default implementation uses the maskElement configuration to access the Component's child element by name. By default, maskElement is null which means that null is returned from this method indicating that the mask needs to be rendered into the document because component structure should not be contaminated by mask elements.

Some subclasses may override this method if they have knowledge about external structures where a mask could usefully be rendered.

For example a Ext.view.Table will request that its owning Ext.panel.Table be masked. The GridPanel will have its own implementation of getMaskTarget which will return the element dicated by its own maskElement Panels use "el" as their maskElement by default, but that could be overridden to be "body" to leave toolbars and the header mouse-accessible.

getMemento ( name )
private pri

Memento Factory method

Parameters

name :  String

Name of the Memento (used as prefix for named Memento) s

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

getOppositeDirection ( d )
private pri

Parameters

d :  Object

getOverflowEl
private pri

Get an el for overflowing, defaults to the target el

getOverflowStyle
private pri

Returns the CSS style object which will set the Component's scroll styles. This must be applied to the target element.

getPlugin ( pluginId ) : Ext.plugin.Abstract

Retrieves a plugin from this component's collection by its pluginId.

Parameters

pluginId :  String

Returns

:Ext.plugin.Abstract

plugin instance.

getPlugins
private

see: plugins

getPosition ( [local] ) : Number[]

Gets the current XY position of the component's underlying element.

Parameters

local :  Boolean (optional)

If true the element's left and top are returned instead of page XY.

Defaults to: false

Returns

:Number[]

The XY position of the element (e.g., [100, 200])

getQueryRoot :
chainable ch private pri

Returns

:

getReExpander ( direction )
private pri

Parameters

direction :  Object

getRefItems ( deep )
private pri

Parameters

deep :  Object

getReferences : Object

Returns an object holding the descendants of this view keyed by their reference. This object should not be held past the scope of the function calling this method. It will not be valid if items are added or removed from this or any sub-container.

The intended usage is shown here (assume there are 3 components with reference values of "foo", "bar" and "baz" at some level below this container):

 onClick: function () {
     var refs = this.getReferences();

     // using "refs" we can access any descendant by its "reference"

     refs.foo.getValue() + refs.bar.getValue() + refs.baz.getValue();
 }

If this component has a reference assigned to it, that is not included in this object. That reference is understood to belong to the ancestor container configured as the referenceHolder.

Available since: 5.0.0

Returns

:Object

An object with each child reference. This will be null if this container has no descendants with a reference specified.

getRhsMarker
private pri

Gets right hand side marker for header resizing.

getRootNode : Ext.data.TreeModel

Returns the root node for this tree.

Returns

:Ext.data.TreeModel

getRowClass ( record , index , rowParams , store )
private pri

Parameters

record :  Object

index :  Object

rowParams :  Object

store :  Object

getScrollX : Number

Returns the "x" scroll position for this component. Only applicable for components that have been configured with autoScroll or overflowX.

Returns

:Number

getScrollY : Number

Returns the "y" scroll position for this component. Only applicable for components that have been configured with autoScroll or overflowY.

Returns

:Number

getSize ( [contentSize] ) : Object

Gets the current size of the component's underlying 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

getSizeModel ( ownerCtSizeModel ) : Object
protected pro

Returns an object that describes how this component's width and height are managed. All of these objects are shared and should not be modified.

Parameters

ownerCtSizeModel :  Object

Returns

:Object

The size model for this component.

width :  Ext.layout.SizeModel

The Ext.layout.SizeModel for the width.

height :  Ext.layout.SizeModel

The Ext.layout.SizeModel for the height.

getStateId
private

see: stateId

getStyleProxy ( cls )
private pri

Returns an offscreen div with the same class name as the element this is being rendered. This is because child item rendering takes place in a detached div which, being not part of the document, has no styling.

Parameters

cls :  Object

getTargetEl
private pri

This is used to determine where to insert the 'html', 'contentEl' and 'items' in this component.

getTdCls
private pri

Needed for when widget is rendered into a grid cell. The class to add to the cell element.

getTdType
private pri

Partner method to getTdCls.

Returns the base type for the component. Defaults to return this.xtype, but All derived classes of Ext.form.field.Text can return the type 'textfield', and all derived classes of Ext.button.Button can return the type 'button'

getTpl
private

see: tpl

getView

see: view

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.

getXType : String

Gets the xtype for this component as registered with Ext.ComponentManager. For a list of all available xtypes, see the Ext.Component header. Example usage:

var t = new Ext.form.field.Text();
alert(t.getXType());  // alerts 'textfield'

Returns

:String

The xtype

getXTypes : String

Returns this Component's xtype hierarchy as a slash-delimited string. For a list of all available xtypes, see the Ext.Component header.

If using your own subclasses, be aware that a Component must register its own xtype to participate in determination of inherited xtypes.

Example usage:

Available since: 2.3.0

Returns

:String

The xtype hierarchy string

ghost ( cls )
private pri

Parameters

cls :  Object

handleFocusEnter ( e )
private pri

Parameters

e :  Object

handler ( field )
private pri

Parameters

field :  Object

hasActiveFx : Ext.fx.Anim / Boolean
deprecated dep

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

Returns

:Ext.fx.Anim / Boolean

Anim if element has active effects, else false

Deprecated since version 4.0
Replaced by #getActiveAnimation

hasCls ( className ) : Boolean

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

Parameters

className :  String

The CSS class to check for.

Returns

:Boolean

true if the class exists, else false.

hasConfig ( config )
private pri

Parameters

config :  Object

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

hasLockedColumns ( columns ) : Boolean
private pri

Parameters

columns :  Object

Returns

:Boolean

hasUICls ( cls )

Checks if there is currently a specified uiCls.

Parameters

cls :  String

The cls to check.

hide ( [animateTarget] , [callback] , [scope] ) : Ext.Component
chainable ch

Hides this Component, setting it to invisible using the configured hideMode.

Parameters

animateTarget :  String / Ext.dom.Element / Ext.Component (optional)

only valid for floating Components such as Ext.window.Windows or Ext.tip.ToolTips, or regular Components which have been configured with floating: true.. The target to which the Component should animate while hiding.

Defaults to: null

callback :  Function (optional)

A callback function to call after the Component is hidden.

scope :  Object (optional)

The scope (this reference) in which the callback is executed. Defaults to this Component.

Returns

:Ext.Component

this

initBindable
private pri

This method triggers the lazy configs and must be called when it is time to fully boot up. The configs that must be initialized are: bind, publishes, session, twoWayBindable and viewModel.

Available since: 5.0.0

initBodyStyles : String
private pri

Parses the bodyStyle config if available to create a style string that will be applied to the body element. This also includes bodyPadding and bodyBorder if available.

Returns

:String

A CSS style string with body styles, padding and border.

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

initEvents
protected pro

Initialize any events on this component

initInheritedState ( inheritedState , inheritedStateInner )
protected pro

Called by getInherited to initialize the inheritedState the first time it is requested.

Parameters

inheritedState :  Object

inheritedStateInner :  Object

initPadding ( targetEl )
private pri

Initializes padding by applying it to the target element, or if the layout manages padding ensures that the padding on the target element is "0".

Parameters

targetEl :  Object

initRenderData : Object
private pri

Initialized the renderData to be used when rendering the renderTpl.

Returns

:Object

Object with keys and values that are going to be applied to the renderTpl

initRenderTpl : Ext.XTemplate
private pri

Initializes the renderTpl.

Returns

:Ext.XTemplate

The renderTpl XTemplate instance.

initSimpleDraggable
private pri

Override Component.initDraggable. Panel (and subclasses) use the header element as the delegate.

initState
private pri

Initializes the state of the object upon construction.

initStyles ( targetEl )
private pri

Applies padding, margin, border, top, left, height, and width configs to the appropriate elements.

Parameters

targetEl :  Object

initTools
private pri

Tools are a Panel-specific capabilty. Panel uses initTools. Subclasses may contribute tools by implementing addTools.

insert ( index , component ) : Ext.Component

Inserts a Component into this Container at a specified index. Fires the beforeadd event before inserting, then fires the add event after the Component has been inserted.

Available since: 2.3.0

Parameters

index :  Number

The index at which the Component will be inserted into the Container's items collection

component :  Ext.Component / Object / Ext.Component[] / Object[]

The child Component or config object to insert.

Ext uses lazy rendering, and will only render the inserted Component should it become necessary.

A Component config object may be passed in order to avoid the overhead of constructing a real Component object if lazy rendering might mean that the inserted Component will not be rendered immediately. To take advantage of this 'lazy instantiation', set the Ext.Component#xtype config property to the registered type of the Component wanted.

You can pass an array of Component instances and config objects.

For a list of all available xtypes, see Ext.enums.Widget.

Returns

:Ext.Component

component The Component (or config object) that was inserted with the Container's default config values applied.

insertDocked ( pos , items )

Inserts docked item(s) to the panel at the indicated position.

Parameters

pos :  Number

The index at which the Component will be inserted

items :  Object / Object[]

The Component or array of components to add. The components must include a 'dock' paramater on each component to indicate where it should be docked ('top', 'right', 'bottom', 'left').

invalidateInheritedState
private pri

This method marks the current inherited state as invalid. The next time a call is made to getInherited the objects will be recreated and initialized.

Available since: 5.0.0

is ( selector ) : Boolean

Tests whether this Component matches a Ext.ComponentQuery selector string.

Parameters

selector :  String

The selector string to test against.

Returns

:Boolean

true if this Component matches the selector.

isAncestor ( possibleDescendant ) : Boolean

Determines whether this Container is an ancestor of the passed Component. This will return true if the passed Component is anywhere within the subtree beneath this Container.

Parameters

possibleDescendant :  Ext.Component

The Component to test for presence within this Container's subtree.

Returns

:Boolean

isDescendantOf ( container ) : Boolean

Determines whether this component is the descendant of a particular container.

Parameters

container :  Ext.container.Container

Returns

:Boolean

true if the component is the descendant of a particular container, otherwise false.

isDisabled : Boolean

Method to determine whether this Component is currently disabled.

Returns

:Boolean

the disabled state of this Component.

isDraggable : Boolean

Method to determine whether this Component is draggable.

Returns

:Boolean

the draggable state of this component.

isDroppable : Boolean

Method to determine whether this Component is droppable.

Returns

:Boolean

the droppable state of this component.

isFloating : Boolean

Method to determine whether this Component is floating.

Returns

:Boolean

the floating state of this component.

isFocusable : Boolean
private pri

Returns

:Boolean

isHidden : Boolean

Method to determine whether this Component is currently set to hidden.

Returns

:Boolean

the hidden state of this Component.

isItemChecked ( rec )
private pri

Parameters

rec :  Object

isLayoutRoot : Boolean
private pri

Returns

:Boolean

isLayoutSuspended : Boolean

Returns true if layout is suspended for this component. This can come from direct suspension of this component's layout activity (Ext.Container#suspendLayout) or if one of this component's containers is suspended.

Returns

:Boolean

true layout of this component is suspended.

isMasked ( [deep] ) : Boolean

Returns masked state for this Component.

Parameters

deep :  Boolean (optional)

True to look up this Component's parent masked state.

Defaults to: false

Returns

:Boolean

True if masked, false otherwise.

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

isVisible ( deep )
private pri

Parameters

deep :  Object

isXType ( xtype , [shallow] ) : Boolean

Tests whether or not this Component is of a specific xtype. This can test whether this Component is descended from the xtype (default) or whether it is directly of the xtype specified (shallow = true).

If using your own subclasses, be aware that a Component must register its own xtype to participate in determination of inherited xtypes.

For a list of all available xtypes, see the Ext.Component header.

Example usage:

Available since: 2.3.0

Parameters

xtype :  String

The xtype to check for this Component

shallow :  Boolean (optional)

true to check whether this Component is directly of the specified xtype, false to check whether this Component is descended from the xtype.

Defaults to: false

Returns

:Boolean

true if this component descends from the specified xtype, false otherwise.

lookupComponent ( comp )
private pri

Parameters

comp :  Object

lookupController ( [skipThis] ) : Ext.app.ViewController

Gets the controller that controls this view. May be a controller that belongs to a view higher in the hierarchy.

Available since: 5.0.1

Parameters

skipThis :  Boolean (optional)

true to not consider the controller directly attached to this view (if it exists).

Defaults to: false

Returns

:Ext.app.ViewController

The controller. null if no controller is found.

lookupReference ( key ) : Ext.Component

Gets a reference to a child specified using the reference configuration.

Parameters

key :  String

The name of the reference.

Returns

:Ext.Component

The referenced component or null if it is not found.

lookupReferenceHolder ( [skipThis] ) : Ext.app.ViewController / Ext.container.Container
private pri

Gets the Controller or Component that is used as the reference holder for this view.

Available since: 5.0.0

Parameters

skipThis :  Boolean (optional)

false to return this as the reference holder if this instance has set referenceHolder. Unlike getInheritedConfig this method defaults to true because it is possible that a reference property set by the owner of a component that is also a referenceHolder itself. In this case, the reference connects not to this component but to the parent referenceHolder.

Defaults to: true

Returns

:Ext.app.ViewController / Ext.container.Container

The reference holder.

lookupSession ( [skipThis] ) : Ext.data.Session

Returns the Ext.data.Session for this instance. This property may come from this instance's session or be inherited from this object's parent.

Available since: 5.0.0

Parameters

skipThis :  Boolean (optional)

Pass true to ignore a session configured on this instance and only consider an inherited session.

Defaults to: false

Returns

:Ext.data.Session

lookupViewModel ( [skipThis] ) : Ext.app.ViewModel

Returns the Ext.app.ViewModel for this instance. This property may come from this this instance's viewModel or be inherited from this object's parent.

Available since: 5.0.0

Parameters

skipThis :  Boolean (optional)

Pass true to ignore a viewModel configured on this instance and only consider an inherited view model.

Defaults to: false

Returns

:Ext.app.ViewModel

makeBindableUpdater ( cfg ) : Function
private pri

Returns an update method for the given Config that will call publishState to ensure two-way bindings (via bind) as well as any publishes are updated. This method is cached on the cfg instance for re-use.

Available since: 5.0.0

Parameters

cfg :  Ext.Config

Returns

:Function

The updater function.

mask ( [msg] , [msgCls] )

Masks this component with a semi-opaque layer and makes the contents unavailable to clicks.

See unmask.

Parameters

msg :  String (optional)

A message to show in the center of the mask layer.

msgCls :  String (optional)

A CSS clas name to use on the message element in the center of the layer.

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

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

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

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

move ( fromIdx , toIdx ) : Ext.Component
deprecated dep

Moves a Component within the Container. This method does not account for things like splitter components added by a layout. To better handle these situations, it is recommended to use moveBefore or moveAfter instead.

Parameters

fromIdx :  Number / Ext.Component

The index/component to move.

toIdx :  Number

The new index for the Component.

Returns

:Ext.Component

component The Component that was moved.

Deprecated since version 5.0
Use `#moveBefore` or `moveAfter` instead.

moveAfter ( item , after ) : Ext.Component

Moves the given item into this container following after. This method will account for layout-generated components like splitters and should be used instead of index based move. If after is null then the item will be the first item in this container.

Available since: 5.0.0

Parameters

item :  Ext.Component

The item to move. May be a component configuration object.

after :  Ext.Component

The reference component. May be null.

Returns

:Ext.Component

The moved item.

moveBefore ( item , before ) : Ext.Component

Moves the given item into this container in front of before. This method will account for layout-generated components like splitters and should be used instead of index based move. If before is null then the item will be the last item in this container.

Available since: 5.0.0

Parameters

item :  Object / Ext.Component

The item to move. May be a component configuration object.

before :  Ext.Component

The reference component. May be null.

Returns

:Ext.Component

The moved item.

moveDocked ( item , side )
private pri

Moves a docked item to a different side.

Parameters

item :  Ext.Component

side :  'top' / 'right' / 'bottom' / 'left'

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.

nextChild ( child , [selector] ) : Ext.Component

A method to find a child component after the passed child parameter. If a selector is also provided, the first child component matching the selector will be returned.

Parameters

child :  Ext.Component

The child to use as a starting point to find the next child.

selector :  String (optional)

A Ext.ComponentQuery selector to find the next child. This will return the next child matching this selector. This parameter is optional.

Returns

:Ext.Component

The next child found, null if no child found.

nextNode ( [selector] ) : Ext.Component

Returns the next node in the Component tree in tree traversal order.

Note that this is not limited to siblings, and if invoked upon a node with no matching siblings, will walk the tree to attempt to find a match. Contrast with nextSibling.

Parameters

selector :  String (optional)

A Ext.ComponentQuery selector to filter the following nodes.

Returns

:Ext.Component

The next node (or the next node which matches the selector). Returns null if there is no matching node.

nextSibling ( [selector] ) : Ext.Component

Returns the next sibling of this Component.

Optionally selects the next sibling which matches the passed Ext.ComponentQuery selector.

May also be referred to as next()

Note that this is limited to siblings, and if no siblings of the item match, null is returned. Contrast with nextNode

Parameters

selector :  String (optional)

A Ext.ComponentQuery selector to filter the following items.

Returns

:Ext.Component

The next sibling (or the next sibling which matches the selector). Returns null if there is no matching sibling.

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

The on method is shorthand for addListener.

Appends an event handler to this object. For example:

myGridPanel.on("mouseover", this.onMouseOver, 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,
    mouseover: this.onMouseOver,
    mouseout: this.onMouseOut,
    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},
    mouseover: {fn: panel.onMouseOver, scope: panel}
});

Names of methods in a specified scope may also be used. Note that scope MUST be specified to use this option:

myGridPanel.on({
    cellClick: {fn: 'onCellClick', scope: this, single: true},
    mouseover: {fn: 'onMouseOver', 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 (optional)

The method the event invokes, or if scope is specified, 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: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler.

This object may contain any of the following properties:

scope :  Object

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

delay :  Number

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

single :  Boolean

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

buffer :  Number

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

onFrame :  Number

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

target :  Ext.util.Observable

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

element :  String

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

This option is useful during Component construction to add DOM event listeners to elements of Ext.Component which will exist only after the Component is rendered. For example, to add a click listener to a Panel's body:

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

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.

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

Combining Options

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

A delayed, one-time listener.

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

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

onAdd ( component , position )
template tpl protected pro

This method is invoked after a new Component has been added. It is passed the Component which has been added. This method may be used to update any internal structure which may depend upon the state of the child items.

Parameters

component :  Ext.Component

position :  Number

This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.

onAdded ( container , pos , instanced )
private pri

Parameters

container :  Object

pos :  Object

instanced :  Object

onBeforeAdd ( item )
template tpl protected pro

This method is invoked before adding a new child Component. It is passed the new Component, and may be used to modify the Component, or prepare the Container in some way. Returning false aborts the add operation.

Parameters

item :  Ext.Component

This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.

onBlur ( e )
private pri

Parameters

e :  Object

onClassExtended ( cls , data )
private pri

Parameters

cls :  Object

data :  Object

onClassMixedIn ( U )
private pri

Parameters

U :  Object

onDisable
template tpl protected pro

Allows addition of behavior to the disable operation. After calling the superclass's onDisable, the Component will be disabled.

This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.

onDockedAdd ( component )
template tpl protected pro

Invoked after a docked item is added to the Panel.

Parameters

component :  Ext.Component

This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.

onDockedRemove ( component )
template tpl protected pro

Invoked after a docked item is removed from the Panel.

Parameters

component :  Ext.Component

This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.

onEnable
template tpl protected pro

Allows addition of behavior to the enable operation. After calling the superclass's onEnable, the Component will be enabled.

This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.

onFocus ( e )
private pri

Parameters

e :  Object

onFocusEnter ( e )
private pri

Parameters

e :  Object

onFocusLeave ( e )
private pri

Parameters

e :  Object

onHeaderHide ( headerCt , header )
private pri

Parameters

headerCt :  Object

header :  Object

onHeaderMove ( headerCt , header , colsToMove , fromIdx , toIdx )
private pri

Parameters

headerCt :  Object

header :  Object

colsToMove :  Object

fromIdx :  Object

toIdx :  Object

onHeaderShow ( headerCt , header )
private pri

Parameters

headerCt :  Object

header :  Object

onHeadersChanged ( headerCt , header )
private pri

Parameters

headerCt :  Object

header :  Object

onHorizontalScroll ( view )
private pri

Parameters

view :  Object

onItemDblclick ( view , rec )
private pri

Parameters

view :  Object

rec :  Object

onItemSelect ( selModel , rec )
private pri

Parameters

selModel :  Object

rec :  Object

onKeyDown ( e )
private pri

Parameters

e :  Object

onMouseDown ( e )
private pri

Parameters

e :  Object

onMouseEnterFloated ( e )
private pri

Parameters

e :  Object

onMouseLeaveFloated ( e )
private pri

Parameters

e :  Object

onPlaceholderResize ( ph , newWidth , newHeight )
private pri

Parameters

ph :  Object

newWidth :  Object

newHeight :  Object

onRemove ( component , isDestroying )
template tpl protected pro

This method is invoked after a new Component has been removed. It is passed the Component which has been removed. This method may be used to update any internal structure which may depend upon the state of the child items.

Parameters

component :  Ext.Component

The removed component

isDestroying :  Boolean

true if the the component is being destroyed in the remove action

This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.

onRemoved ( destroying )
private pri

Parameters

destroying :  Object

onRender ( parentNode , containerIdx )
template tpl protected pro

Template method called when this Component's DOM structure is created.

At this point, this Component's (and all descendants') DOM structure exists but it has not been layed out (positioned and sized).

Subclasses which override this to gain access to the structure at render time should call the parent class's method before attempting to access any child elements of the Component.

Parameters

parentNode :  Ext.dom.Element

The parent Element in which this Component's encapsulating element is contained.

containerIdx :  Number

The index within the parent Container's child collection of this Component.

This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.

onRestoreHorzScroll
private pri

Tracks when things happen to the view and preserves the horizontal scroll position.

onRootChange ( root )
private pri

Parameters

root :  Object

onShowComplete ( [callback] , [scope] )
template tpl protected pro

Invoked after the #afterShow method is complete.

Gets passed the same callback and scope parameters that #afterShow received.

Parameters

callback :  Function (optional)

scope :  Object (optional)

This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.

onStateChange
private pri

This method is called when any of the stateEvents are fired.

onViewReady
private pri

Fires the TablePanel's viewready event when the view declares that its internal DOM is ready

owns ( element )
private pri

Returns true if the passed element is within the container tree of this component.

For example if a menu's submenu contains an Ext.form.field.Date, that top level menu owns the elements of the date picker. Using this method, you can tell if an event took place within a certain component tree.

Parameters

element :  Object

placeholderCollapse ( direction , animate ) :
chainable ch private pri

Parameters

direction :  Object

animate :  Object

Returns

:

placeholderExpand ( animate ) :
chainable ch private pri

Parameters

animate :  Object

Returns

:

prevChild ( child , [selector] ) : Ext.Component

A method to find a child component before the passed child parameter. If a selector is also provided, the first child component matching the selector will be returned.

Parameters

child :  Ext.Component

The child to use as a starting point to find the previous child.

selector :  String (optional)

A Ext.ComponentQuery selector to find the previous child. This will return the first child matching this selector. This parameter is optional.

Returns

:Ext.Component

The previous child found, null if no child found.

previousNode ( [selector] ) : Ext.Component

Returns the previous node in the Component tree in tree traversal order.

Note that this is not limited to siblings, and if invoked upon a node with no matching siblings, will walk the tree in reverse order to attempt to find a match. Contrast with previousSibling.

Parameters

selector :  String (optional)

A Ext.ComponentQuery selector to filter the preceding nodes.

Returns

:Ext.Component

The previous node (or the previous node which matches the selector). Returns null if there is no matching node.

previousSibling ( [selector] ) : Ext.Component

Returns the previous sibling of this Component.

Optionally selects the previous sibling which matches the passed Ext.ComponentQuery selector.

May also be referred to as prev()

Note that this is limited to siblings, and if no siblings of the item match, null is returned. Contrast with previousNode

Parameters

selector :  String (optional)

A Ext.ComponentQuery selector to filter the preceding items.

Returns

:Ext.Component

The previous sibling (or the previous sibling which matches the selector). Returns null if there is no matching sibling.

processEvent ( type , view , cell , recordIndex , cellIndex , e )
private pri

Processes UI events from the view. Propagates them to whatever internal Components need to process them.

Parameters

type :  String

Event type, eg 'click'

view :  Ext.view.Table

TableView Component

cell :  HTMLElement

Cell HTMLElement the event took place within

recordIndex :  Number

Index of the associated Store Model (-1 if none)

cellIndex :  Number

Cell index within the row

e :  Ext.event.Event

Original event

publishState ( [property] , [value] )
protected pro

Publish this components state to the ViewModel. If no arguments are given (or if this is the first call), the entire state is published. This state is determined by the publishes property.

This method is called only by component authors.

Available since: 5.0.0

Parameters

property :  String (optional)

The name of the property to update.

value :  Object (optional)

The value of property. Only needed if property is given.

query ( [selector] ) : Ext.Component[]

Retrieves all descendant components which match the passed selector. Executes an Ext.ComponentQuery.query using this container as its root.

Parameters

selector :  String (optional)

Selector complying to an Ext.ComponentQuery selector. If no selector is specified all items will be returned.

Returns

:Ext.Component[]

Components which matched the selector

queryBy ( fn , [scope] ) : Ext.Component[]

Retrieves all descendant components which match the passed function. The function should return false for components that are to be excluded from the selection.

Parameters

fn :  Function

The matcher function. It will be called with a single argument, the component being tested.

scope :  Object (optional)

The scope in which to run the function. If not specified, it will default to the active component.

Returns

:Ext.Component[]

Components matched by the passed function

queryById ( id ) : Ext.Component

Finds a component at any level under this container matching the id/itemId. This is a shorthand for calling ct.down('#' + id);

Parameters

id :  String

The id to find

Returns

:Ext.Component

The matching id, null if not found

reconfigure ( [store] , [columns] )

Reconfigures the grid / tree with a new store/columns. Either the store or the columns can be omitted if you don't wish to change them.

The enableLocking config should be set to true before the reconfigure method is executed if locked columns are intended to be used.

Parameters

store :  Ext.data.Store (optional)

The new store. You can pass null if no new store.

columns :  Object[] (optional)

An array of column configs

refreshScroll
private pri

Implementation which updates the scroll range of a touch scroller. Subclasses may change implementation.

registerFloatingItem ( cmp )

Called by Component#doAutoRender

Register a Container configured floating: true with this Component's Ext.ZIndexManager.

Components added in this way will not participate in any layout, but will be rendered upon first show in the way that Ext.window.Windows are.

Parameters

cmp :  Object

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

Array of event names to relay.

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

relayHeaderCtEvents ( headerCt )
private pri

Parameters

headerCt :  Object

remove ( component , [autoDestroy] ) : Ext.Component

Removes a component from this container. Fires the beforeremove event before removing, then fires the remove event after the component has been removed.

Available since: 2.3.0

Parameters

component :  Ext.Component / String

The component reference or id to remove.

autoDestroy :  Boolean (optional)

True to automatically invoke the removed Component's Ext.Component#destroy function.

Defaults to the value of this Container's autoDestroy config.

Returns

:Ext.Component

component The Component that was removed.

removeAll ( [autoDestroy] ) : Ext.Component[]

Removes all components from this container.

Available since: 2.3.0

Parameters

autoDestroy :  Boolean (optional)

True to automatically invoke the removed Component's Ext.Component#destroy function. Defaults to the value of this Container's autoDestroy config.

Returns

:Ext.Component[]

Array of the removed components

removeBodyCls ( cls ) : Ext.panel.Panel
chainable ch

Removes a CSS class from the body element.

Parameters

cls :  String

The class to remove

Returns

:Ext.panel.Panel

this

removeClass ( cls ) : Ext.Component
deprecated dep

Removes a CSS class from the top level element representing this component.

Available since: 2.3.0

Parameters

cls :  String / String[]

The CSS class name to remove.

Returns

:Ext.Component

Returns the Component to allow method chaining.

Deprecated since version 4.1
Use #addCls instead.

removeCls ( cls ) : Ext.Component
chainable ch

Removes a CSS class from the top level element representing this component.

Parameters

cls :  String / String[]

The CSS class name to remove.

Returns

:Ext.Component

Returns the Component to allow method chaining.

removeClsWithUI ( cls )

Removes a cls to the uiCls array, which will also call removeUIClsFromElement and removes it from all elements of this component.

Parameters

cls :  String / String[]

A string or an array of strings to remove to the uiCls.

removeDocked ( item , [autoDestroy] )

Removes the docked item from the panel.

Parameters

item :  Ext.Component

The Component to remove.

autoDestroy :  Boolean (optional)

Destroy the component after removal.

removeListener ( eventName , fn , [scope] )

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 Ext.util.Observable#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.

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

Removes listeners that were added by the mon method.

Parameters

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

The item from which to remove a listener/listeners.

ename :  Object / String

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

fn :  Function (optional)

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

scope :  Object (optional)

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

removeManagedListenerItem ( isClear , managedListener )
private pri

Remove a single managed listener item

Parameters

isClear :  Boolean

True if this is being called during a clear

managedListener :  Object

The managed listener item See removeManagedListener for other args

removeMethodListener ( method , fn , scope )
private pri

Parameters

method :  Object

fn :  Object

scope :  Object

removeUIClsFromElement ( cls )
private pri

Parameters

cls :  Object

removeUIFromElement
private pri

Method which removes a specified UI from the components element.

render ( [container] , [position] )

Renders the Component into the passed HTML element.

If you are using a Ext.container.Container object to house this Component, then do not use the render method.

A Container's child Components are rendered by that Container's layout manager when the Container is first rendered.

If the Container is already rendered when a new child Component is added, you may need to call the Container's doLayout to refresh the view which causes any unrendered child Components to be rendered. This is required so that you can add multiple child components if needed while only refreshing the layout once.

When creating complex UIs, it is important to remember that sizing and positioning of child items is the responsibility of the Container's layout manager. If you expect child items to be sized in response to user interactions, you must configure the Container with a layout manager which creates and manages the type of layout you have in mind.

Omitting the Container's layout config means that a basic layout manager is used which does nothing but render child components sequentially into the Container. No sizing or positioning will be performed in this situation.

Parameters

container :  Ext.dom.Element / HTMLElement / String (optional)

The element this Component should be rendered into. If it is being created from existing markup, this should be omitted.

position :  String / Number (optional)

The element ID or DOM node index within the container before which this component will be inserted (defaults to appending to the end of the container)

resolveListenerScope ( [defaultScope] ) : Ext.app.ViewController / Ext.container.Container
protected pro

Gets the Controller or Component that is used as the event root for this view.

Available since: 5.0.0

Parameters

defaultScope :  Object (optional)

The default scope to return if none is found.

Defaults to: this

Returns

:Ext.app.ViewController / Ext.container.Container

The default listener scope.

resolveMethod ( fn , scope )
private pri

Parameters

fn :  Object

scope :  Object

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.

resumeLayouts ( flushOptions )
private pri

Parameters

flushOptions :  Object

savePropToState ( propName , state , [stateName] ) : Boolean

Conditionally saves a single property from this object to the given state object. The idea is to only save state which has changed from the initial state so that current software settings do not override future software settings. Only those values that are user-changed state should be saved.

Parameters

propName :  String

The name of the property to save.

state :  Object

The state object in to which to save the property.

stateName :  String (optional)

The name to use for the property in state.

Returns

:Boolean

True if the property was saved, false if not.

savePropsToState ( propNames , state ) : Object

Gathers additional named properties of the instance and adds their current values to the passed state object.

Parameters

propNames :  String / String[]

The name (or array of names) of the property to save.

state :  Object

The state object in to which to save the property values.

Returns

:Object

state

saveState

Saves the state of the object to the persistence store.

scrollBy ( deltaX , deltaY , animate )

Scrolls this Component by the passed delta values, optionally animating.

All of the following are equivalent:

 comp.scrollBy(10, 10, true);
 comp.scrollBy([10, 10], true);
 comp.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.

scrollByDeltaX ( xDelta , animate )
private pri

Parameters

xDelta :  Object

animate :  Object

scrollByDeltaY ( yDelta , animate )
private pri

Parameters

yDelta :  Object

animate :  Object

scrollTo ( x , y , [animate] )

Scrolls this component to the specified x and y coordinates. Only applicable for components that have been configured with autoScroll or overflowX and overflowY.

Parameters

x :  Number

y :  Number

animate :  Boolean / Object (optional)

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

selectPath ( path , [field] , [separator] , [callback] , [scope] )

Expand the tree to the path of a particular node, then select it.

Parameters

path :  String

The path to select; A string of separated node IDs.

The path should include a leading separator. eg '/root/usermanagement/users'

field :  String (optional)

The field to get the data from. Defaults to the model idProperty.

separator :  String (optional)

A separator to use.

Defaults to: '/'

callback :  Function (optional)

A function to execute when the select finishes. The callback will be called with (bSuccess, oLastNode) where bSuccess is if the select was successful and oLastNode is the last node that was expanded.

scope :  Object (optional)

The scope of the callback function

sequenceFx : Object
chainable ch

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

Returns

:Object

this

set ( value )
private pri

Parameters

value :  Object

setActive ( [active] , [newActive] )
private pri

This method is called internally by Ext.ZIndexManager to signal that a floating Component has either been moved to the top of its zIndex stack, or pushed from the top of its zIndex stack.

If a Window is superceded by another Window, deactivating it hides its shadow.

This method also fires the activate or deactivate event depending on which action occurred.

Parameters

active :  Boolean (optional)

True to activate the Component, false to deactivate it.

Defaults to: false

newActive :  Ext.Component (optional)

If deactivating, the newly active Component which is taking over topmost zIndex position.

setBind

see: bind

setBorder
private

see: border

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

setColumns
private

see: columns

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

setData

see: data

setDock ( dock ) : Ext.Component
chainable ch

Sets the dock position of this component in its parent panel. Note that this only has effect if this item is part of the dockedItems collection of a parent that has a DockLayout (note that any Panel has a DockLayout by default)

Parameters

dock :  Object

The dock position.

Returns

:Ext.Component

this

setDocked ( dock ) : Ext.Component
deprecated dep

Sets the dock position of this component in its parent panel. Note that this only has effect if this item is part of the dockedItems collection of a parent that has a DockLayout (note that any Panel has a DockLayout by default)

Parameters

dock :  Object

The dock position.

Returns

:Ext.Component

this

Deprecated since version 5.0
Use #setDock instead.

setFlex ( flex )
private pri

Sets the flex property of this component. Only applicable when this component is an item of a box layout

Parameters

flex :  Number

setGlyph
private

see: glyph

setHtml
private

see: html

setIcon
private

see: icon

setIconCls
private

see: iconCls

setId

see: id

setLoading ( load ) : Ext.LoadMask

This method allows you to show or hide a LoadMask on top of this component.

The mask will be rendered into the element returned by getMaskTarget which for most Components is the Component's element. See getMaskTarget and maskElement.

Most Components will return null indicating that their LoadMask cannot reside inside their element, but must be rendered into the document body.

Ext.view.Table however will direct a LoadMask to be rendered into the owning Ext.panel.Table.

Parameters

load :  Boolean / Object / String

True to show the default LoadMask, a config object that will be passed to the LoadMask constructor, or a message String to show. False to hide the current LoadMask.

Returns

:Ext.LoadMask

The LoadMask instance that has just been shown.

setLocalX ( x )
private pri

Parameters

x :  Object

setLocalXY ( x , y )
private pri

Parameters

x :  Object

y :  Object

setLocalY ( y )
private pri

Parameters

y :  Object

setMasked ( isMasked ) :
chainable ch private pri

Set masked state for this Component.

Parameters

isMasked :  Boolean

True if masked, false otherwise.

Returns

:

setOverflowXY ( overflowX , overflowY ) : Ext.Component
chainable ch

Sets the overflow x/y on the content element of the component. The x/y overflow values can be any valid CSS overflow (e.g., 'auto' or 'scroll'). By default, the value is 'hidden'. Passing null for one of the values will erase the inline style. Passing undefined will preserve the current value.

Parameters

overflowX :  String

The overflow-x value.

overflowY :  String

The overflow-y value.

Returns

:Ext.Component

this

setPagePosition ( x , [y] , [animate] ) : Ext.Component
chainable ch

Sets the page XY position of the component. To set the left and top instead, use setPosition. This method fires the move event.

Parameters

x :  Number / Number[]

The new x position or an array of [x,y].

y :  Number (optional)

The new y position.

animate :  Boolean / Object (optional)

True to animate the Component into its new position. You may also pass an animation configuration.

Returns

:Ext.Component

this

setPosition ( x , [y] , [animate] ) : Ext.Component
chainable ch

Sets the left and top of the component. To set the page XY position instead, use setPagePosition. This method fires the move event.

Parameters

x :  Number / Number[] / Object

The new left, an array of [x,y], or animation config object containing x and y properties.

y :  Number (optional)

The new top.

animate :  Boolean / Object (optional)

If true, the Component is animated into its new position. You may also pass an animation configuration.

Returns

:Ext.Component

this

setRootNode ( root ) : Ext.data.TreeModel

Sets root node of this tree. All trees always have a root node. It may be hidden.

If the passed node has not already been loaded with child nodes, and has its expanded field set, this triggers the store to load the child nodes of the root.

Parameters

root :  Ext.data.TreeModel / Object

Returns

:Ext.data.TreeModel

The new root

setScrollX ( x )

Sets the "x" scroll position for this component. Only applicable for components that have been configured with autoScroll or overflowX.

Parameters

x :  Number

setScrollY ( y )

Sets the "y" scroll position for this component. Only applicable for components that have been configured with autoScroll or overflowY.

Parameters

y :  Number

setSelection
private

see: selection

setSize ( width , height ) : Ext.Component
chainable ch

Sets the width and height of this Component. This method fires the resize event. This method can accept either width and height as separate arguments, or you can pass a size object like {width:10, height:20}.

Parameters

width :  Number / String / Object

The new width to set. This may be one of:

  • A Number specifying the new width in pixels.
  • A String used to set the CSS width style.
  • A size object in the format {width: widthValue, height: heightValue}.
  • undefined to leave the width unchanged.

height :  Number / String

The new height to set (not required if a size object is passed as the first arg). 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.
  • undefined to leave the height unchanged.

Returns

:Ext.Component

this

setStore
private

see: store

setTitle
private

see: title

setTpl

see: tpl

setUI
private

see: ui

setView

see: view

setVisible ( visible ) : Ext.Component
chainable ch

Convenience function to hide or show this component by Boolean.

Available since: 1.1.0

Parameters

visible :  Boolean

true to show, false to hide.

Returns

:Ext.Component

this

setX ( x , animate )
private pri

Parameters

x :  Object

animate :  Object

setXY ( xy , animate )
private pri

Parameters

xy :  Object

animate :  Object

setY ( y , animate )
private pri

Parameters

y :  Object

animate :  Object

setZIndex ( index )
private pri

Parameters

index :  Object

setupDockingRenderTpl ( renderTpl )
private pri

Parameters

renderTpl :  Object

setupFramingTpl ( frameTpl )
private pri

Inject a reference to the function which applies the render template into the framing template. The framing template wraps the content.

Parameters

frameTpl :  Object

show ( [animateTarget] , [callback] , [scope] ) : Ext.Component
chainable ch

Shows this Component, rendering it first if autoRender or floating are true.

After being shown, a floating Component (such as a Ext.window.Window), is activated it and brought to the front of its z-index stack.

Parameters

animateTarget :  String / Ext.dom.Element (optional)

only valid for floating Components such as Ext.window.Windows or Ext.tip.ToolTips, or regular Components which have been configured with floating: true. The target from which the Component should animate from while opening.

Defaults to: null

callback :  Function (optional)

A callback function to call after the Component is displayed. Only necessary if animation was specified.

scope :  Object (optional)

The scope (this reference) in which the callback is executed. Defaults to this Component.

Returns

:Ext.Component

this

showAt ( x , [y] , [animate] ) : Ext.Component

Displays component at specific xy position. A floating component (like a menu) is positioned relative to its ownerCt if any. Useful for popping up a context menu:

listeners: {
    itemcontextmenu: function(view, record, item, index, event, options) {
        Ext.create('Ext.menu.Menu', {
            width: 100,
            height: 100,
            margin: '0 0 10 0',
            items: [{
                text: 'regular item 1'
            },{
                text: 'regular item 2'
            },{
                text: 'regular item 3'
            }]
        }).showAt(event.getXY());
    }
}

Parameters

x :  Number / Number[]

The new x position or array of [x,y].

y :  Number (optional)

The new y position

animate :  Boolean / Object (optional)

True to animate the Component into its new position. You may also pass an animation configuration.

Returns

:Ext.Component

this

showBindingsTip ( view , record , item , index , e )
private pri

Parameters

view :  Object

record :  Object

item :  Object

index :  Object

e :  Object

showBy ( component , [position] , [offsets] ) : Ext.Component
chainable ch

Shows this component by the specified Ext.Component or Ext.dom.Element. Used when this component is floating.

Parameters

component :  Ext.Component / Ext.dom.Element

The Ext.Component or Ext.dom.Element to show the component by.

position :  String (optional)

Alignment position as used by Ext.util.Positionable#getAlignToXY. Defaults to defaultAlign. See alignTo for possible values.

offsets :  Number[] (optional)

Alignment offsets as used by Ext.util.Positionable#getAlignToXY. See alignTo for possible values.

Returns

:Ext.Component

this

slideOutFloatedPanelBegin
private pri

This method begins the slide out of the floated panel.

slideOutFloatedPanelEnd ( suppressEvents )
private pri

This method cleans up after the slide out of the floated panel.

Parameters

suppressEvents :  Object

srcVMIndicator ( v , meta , rec )
private pri

Parameters

v :  Object

meta :  Object

rec :  Object

statics : Ext.Class
protected pro

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

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

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

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

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

        statics.totalCreated++;
    },

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

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

        return cloned;
    }
});


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

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

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

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

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

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

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

Returns

:Ext.Class

stopAnimation : Ext.dom.Element
chainable ch

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

Returns

:Ext.dom.Element

The Element

stopFx : Ext.dom.Element
deprecated dep

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

Returns

:Ext.dom.Element

The Element

Deprecated since version 4.0
Replaced by #stopAnimation

suspendEvent ( eventName )

Suspends firing of the named event(s).

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

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

Parameters

eventName :  String...

Multiple event names to suspend.

suspendEvents ( queueSuspended )

Suspends the firing of all events. (see resumeEvents)

Parameters

queueSuspended :  Boolean

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

syncFx : Object
chainable ch

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

Returns

:Object

this

syncHidden
private pri

synchronizes the hidden state of this component with the state of its hierarchy

syncHorizontalScroll ( target , setBody )
private pri

Parameters

target :  Object

setBody :  Object

toBack : Ext.Component
chainable ch

Sends this Component to the back of (lower z-index than) any other visible windows

Returns

:Ext.Component

this

toFront ( [preventFocus] ) : Ext.Component
chainable ch

Brings this floating Component to the front of any other visible, floating Components managed by the same Ext.ZIndexManager

If this Component is modal, inserts the modal mask just below this Component in the z-index stack.

Parameters

preventFocus :  Boolean (optional)

Specify true to prevent the Component from being focused.

Defaults to: false

Returns

:Ext.Component

this

toggleCollapse : Ext.panel.Panel

Shortcut for performing an expand or collapse based on the current state of the panel.

Returns

:Ext.panel.Panel

this

toggleEventLogging ( toggle )
private pri

Parameters

toggle :  Object

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 Ext.util.Observable#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.

unghost ( show , matchPosition , focus )
private pri

Parameters

show :  Object

matchPosition :  Object

focus :  Object

unitizeBox ( box )
private pri

Parameters

box :  Object

unmask

Removes the mask applied by mask

unregisterFloatingItem ( cmp )
private pri

Parameters

cmp :  Object

up ( [selector] , [limit] ) : Ext.container.Container

Navigates up the ownership hierarchy searching for an ancestor Container which matches any passed selector or component.

Important. There is not a universal upwards navigation pointer. There are several upwards relationships such as the Ext.button.Button which activates a menu, or the Ext.menu.Item which activated a submenu, or the Ext.grid.column.Column which activated the column menu.

These differences are abstracted away by this method.

Example:

var owningTabPanel = grid.up('tabpanel');

Parameters

selector :  String / Ext.Component (optional)

The selector component or actual component to test. If not passed the immediate owner/activater is returned.

limit :  String / Number / Ext.Component (optional)

This may be a selector upon which to stop the upward scan, or a limit of the number of steps, or Component reference to stop on.

Returns

:Ext.container.Container

The matching ancestor Container (or undefined if no match was found).

update ( htmlOrData , [loadScripts] , [callback] )

Update the content area of a component.

Available since: 3.4.0

Parameters

htmlOrData :  String / Object

If this component has been configured with a template via the tpl config then it will use this argument as data to populate the template. If this component was not configured with a template, the components content area will be updated via Ext.Element update.

loadScripts :  Boolean (optional)

Only legitimate when using the html configuration.

Defaults to: false

callback :  Function (optional)

Only legitimate when using the html configuration. Callback to execute when scripts have finished loading.

updateActiveCounter ( activeCounter )
private pri

Parameters

activeCounter :  Object

updateAlwaysOnTop ( alwaysOnTop )
private pri

Parameters

alwaysOnTop :  Object

updateBindSelection ( selModel , selection )
private pri

Parameters

selModel :  Object

selection :  Object

updateBox ( box ) : Ext.Component
chainable ch

Sets the current box measurements of the component's underlying element.

Parameters

box :  Object

An object in the format {x, y, width, height}

Returns

:Ext.Component

this

updateFrame
private pri

Updates the frame elements to match new framing. The current frameBody is preserved by transplanting it into the new frame. All other frame childEls are destroyed and recreated if needed by the new frame. This method cannot transition from framed to non-framed or vise-versa or between table and div based framing.

updateHeader ( force )
private pri

Create, hide, or show the header component as appropriate based on the current config.

Parameters

force :  Boolean

True to force the header to be created

updateHeaderPosition ( position )
private pri

Parameters

position :  Object

updateIconAlign ( align )
private pri

Parameters

align :  Object

updateLayout

Updates this component's layout. If this update affects this components ownerCt, that component's updateLayout method will be called to perform the layout instead. Otherwise, just this component (and its child items) will layout.

updateMaxHeight ( maxHeight , oldMaxHeight )
private pri

Parameters

maxHeight :  Object

oldMaxHeight :  Object

updateMaxWidth ( maxWidth , oldMaxWidth )
private pri

Parameters

maxWidth :  Object

oldMaxWidth :  Object

updateMinHeight ( minHeight , oldMinHeight )
private pri

Parameters

minHeight :  Object

oldMinHeight :  Object

updateMinWidth ( minWidth , oldMinWidth )
private pri

Parameters

minWidth :  Object

oldMinWidth :  Object

updateSelection ( selection )
private pri

Parameters

selection :  Object

updateSession ( session )
private pri

Updates the session config.

Available since: 5.0.0

Parameters

session :  Ext.data.Session

updateTitleAlign ( align )
private pri

Parameters

align :  Object

updateTitleRotation ( rotation )
private pri

Parameters

rotation :  Object

updateViewModel ( viewModel )
private pri

Updates the viewModel config.

Available since: 5.0.0

Parameters

viewModel :  Ext.app.ViewModel

visitPostOrder ( selector , fn , [scope] , [extraArgs] )

Traverses the tree rooted at this node in post-order mode, calling the passed function on the nodes at each level. That is the function is called upon each node after being called on its children).

This method is used at each level down the cascade. Currently Ext.Components and Ext.data.TreeModels are queryable.

If you have tree-structured data, you can make your nodes queryable, and use ComponentQuery on them.

Parameters

selector :  Object

A ComponentQuery selector used to filter candidate nodes before calling the function. An empty string matches any node.

fn :  Function

The function to call. Return false to aborl the traverse.

node :  Object

The node being visited.

scope :  Object (optional)

The context (this reference) in which the function is executed.

extraArgs :  Array (optional)

A set of arguments to be appended to the function's argument list to pass down extra data known to the caller after the node being visited.

visitPreOrder ( selector , fn , [scope] , [extraArgs] )

Traverses the tree rooted at this node in pre-order mode, calling the passed function on the nodes at each level. That is the function is called upon each node before being called on its children).

This method is used at each level down the cascade. Currently Ext.Components and Ext.data.TreeModels are queryable.

If you have tree-structured data, you can make your nodes queryable, and use ComponentQuery on them.

Parameters

selector :  Object

A ComponentQuery selector used to filter candidate nodes before calling the function. An empty string matches any node.

fn :  Function

The function to call. Return false to aborl the traverse.

node :  Object

The node being visited.

scope :  Object (optional)

The context (this reference) in which the function is executed.

extraArgs :  Array (optional)

A set of arguments to be appended to the function's argument list to pass down extra data known to the caller after the node being visited.

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

The mixin class if the configs are from a mixin.

addInheritableStatics ( members ) :
chainable ch static sta private pri

Parameters

members :  Object

Returns

:

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

Parameters

name :  Object

member :  Object

Returns

:

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

Add methods / properties to the prototype of this class.

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

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

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

Parameters

members :  Object

The members to add to this class.

isStatic :  Boolean (optional)

Pass true if the members are static.

Defaults to: false

privacy :  Boolean (optional)

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

Defaults to: false

Returns

:

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

Add / override static properties of this class.

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

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

Parameters

members :  Object

Returns

:Ext.Base

this

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 : Object
static sta

Create a new instance of this Class.

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

My.cool.Class.create({
    someConfig: true
});

All parameters are passed to the constructor of the class.

Returns

:Object

the created instance.

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

getConfigurator : Ext.Configurator
static sta private pri

Returns the Ext.Configurator for this class.

Returns

:Ext.Configurator

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

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

Used internally by the mixins pre-processor

Parameters

name :  Object

mixinClass :  Object

Returns

:

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

Parameters

fn :  Object

scope :  Object

Returns

:

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

Override members of this class. Overridden methods can be invoked via Ext.Base#callParent.

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

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

        this.callParent(arguments);

        alert("Meeeeoooowwww");
    }
});

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

Direct use of this method should be rare. Use Ext.define instead:

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

        this.callParent(arguments);

        alert("Meeeeoooowwww");
    }
});

The above accomplishes the same result but can be managed by the Ext.Loader which can properly order the override and its target class and the build process can determine whether the override is needed based on the required state of the target class (My.Cat).

Parameters

members :  Object

The properties to add to this class. This should be specified as an object literal containing one or more properties.

Returns

:Ext.Base

this class

triggerExtended
static sta private pri

events

activate ( this , eOpts )

Fires after a Component has been visually activated.

Note This event is only fired if this Component is a child of a Ext.container.Container that uses Ext.layout.container.Card as it's layout or this Component is a floating Component.

Parameters

this :  Ext.Component

eOpts : Object

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

add ( this , component , index , eOpts )

Fires after any Ext.Component is added or inserted into the container.

This event bubbles: 'add' will also be fired when Component is added to any of the child containers or their childern or ...

Available since: 2.3.0

Parameters

component :  Ext.Component

The component that was added

index :  Number

The index at which the component was added to the container's items collection

eOpts : Object

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

added ( this , container , pos , eOpts )

Fires after a Component had been added to a Container.

Available since: 3.4.0

Parameters

this :  Ext.Component

container :  Ext.container.Container

Parent Container

pos :  Number

position of Component

eOpts : Object

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

afteritemcollapse ( node , index , item , eOpts )

Fires after an item has been visually collapsed and is no longer visible in the tree.

Parameters

node :  Ext.data.NodeInterface

The node that was collapsed

index :  Number

The index of the node

item :  HTMLElement

The HTML element for the node that was collapsed

eOpts : Object

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

afteritemexpand ( node , index , item , eOpts )

Fires after an item has been visually expanded and is visible in the tree.

Parameters

node :  Ext.data.NodeInterface

The node that was expanded

index :  Number

The index of the node

item :  HTMLElement

The HTML element for the node that was expanded

eOpts : Object

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

afterlayout ( this , layout , eOpts )

Fires when the components in this container are arranged by the associated layout manager.

Available since: 2.3.0

Parameters

layout :  Ext.layout.container.Container

The ContainerLayout implementation for this container

eOpts : Object

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

afterrender ( this , eOpts )

Fires after the component rendering is finished.

The afterrender event is fired after this Component has been rendered, been postprocessed by any afterRender method defined for the Component.

Available since: 3.4.0

Parameters

this :  Ext.Component

eOpts : Object

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

beforeactivate ( this , eOpts )

Fires before a Component has been visually activated. Returning false from an event listener can prevent the activate from occurring.

Note This event is only fired if this Component is a child of a Ext.container.Container that uses Ext.layout.container.Card as it's layout.

Parameters

this :  Ext.Component

eOpts : Object

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

beforeadd ( this , component , index , eOpts )

Fires before any Ext.Component is added or inserted into the container. A handler can return false to cancel the add.

Available since: 2.3.0

Parameters

component :  Ext.Component

The component being added

index :  Number

The index at which the component will be added to the container's items collection

eOpts : Object

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

beforecellclick ( this , td , cellIndex , record , tr , rowIndex , e , eOpts )

Fired before the cell click is processed. Return false to cancel the default action.

Parameters

this :  Ext.view.Table

td :  HTMLElement

The TD element for the cell.

cellIndex :  Number

record :  Ext.data.Model

tr :  HTMLElement

The TR element for the cell.

rowIndex :  Number

eOpts : Object

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

beforecellcontextmenu ( this , td , cellIndex , record , tr , rowIndex , e , eOpts )

Fired before the cell right click is processed. Return false to cancel the default action.

Parameters

this :  Ext.view.Table

td :  HTMLElement

The TD element for the cell.

cellIndex :  Number

record :  Ext.data.Model

tr :  HTMLElement

The TR element for the cell.

rowIndex :  Number

eOpts : Object

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

beforecelldblclick ( this , td , cellIndex , record , tr , rowIndex , e , eOpts )

Fired before the cell double click is processed. Return false to cancel the default action.

Parameters

this :  Ext.view.Table

td :  HTMLElement

The TD element for the cell.

cellIndex :  Number

record :  Ext.data.Model

tr :  HTMLElement

The TR element for the cell.

rowIndex :  Number

eOpts : Object

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

beforecellkeydown ( this , td , cellIndex , record , tr , rowIndex , e , eOpts )

Fired before the cell key down is processed. Return false to cancel the default action.

Parameters

this :  Ext.view.Table

td :  HTMLElement

The TD element for the cell.

cellIndex :  Number

record :  Ext.data.Model

tr :  HTMLElement

The TR element for the cell.

rowIndex :  Number

eOpts : Object

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

beforecellmousedown ( this , td , cellIndex , record , tr , rowIndex , e , eOpts )

Fired before the cell mouse down is processed. Return false to cancel the default action.

Parameters

this :  Ext.view.Table

td :  HTMLElement

The TD element for the cell.

cellIndex :  Number

record :  Ext.data.Model

tr :  HTMLElement

The TR element for the cell.

rowIndex :  Number

eOpts : Object

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

beforecellmouseup ( this , td , cellIndex , record , tr , rowIndex , e , eOpts )

Fired before the cell mouse up is processed. Return false to cancel the default action.

Parameters

this :  Ext.view.Table

td :  HTMLElement

The TD element for the cell.

cellIndex :  Number

record :  Ext.data.Model

tr :  HTMLElement

The TR element for the cell.

rowIndex :  Number

eOpts : Object

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

beforeclose ( panel , eOpts )

Fires before the user closes the panel. Return false from any listener to stop the close event being fired

Parameters

panel :  Ext.panel.Panel

The Panel object

eOpts : Object

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

beforecollapse ( p , direction , animate , eOpts )

Fires before this panel is collapsed. Return false to prevent the collapse.

Parameters

p :  Ext.panel.Panel

The Panel being collapsed.

direction :  String

. The direction of the collapse. One of

  • Ext.Component.DIRECTION_TOP
  • Ext.Component.DIRECTION_RIGHT
  • Ext.Component.DIRECTION_BOTTOM
  • Ext.Component.DIRECTION_LEFT

animate :  Boolean

True if the collapse is animated, else false.

eOpts : Object

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

beforecontainerclick ( this , e , eOpts )

Fires before the click event on the container is processed. Returns false to cancel the default action.

Parameters

this :  Ext.view.View

e :  Ext.event.Event

The raw event object

eOpts : Object

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

beforecontainercontextmenu ( this , e , eOpts )

Fires before the contextmenu event on the container is processed. Returns false to cancel the default action.

Parameters

this :  Ext.view.View

e :  Ext.event.Event

The raw event object

eOpts : Object

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

beforecontainerdblclick ( this , e , eOpts )

Fires before the dblclick event on the container is processed. Returns false to cancel the default action.

Parameters

this :  Ext.view.View

e :  Ext.event.Event

The raw event object

eOpts : Object

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

beforecontainerkeydown ( this , e , eOpts )

Fires before the keydown event on the container is processed. Returns false to cancel the default action.

Parameters

this :  Ext.view.View

e :  Ext.event.Event

The raw event object. Use getKey() to retrieve the key that was pressed.

eOpts : Object

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

beforecontainermousedown ( this , e , eOpts )

Fires before the mousedown event on the container is processed. Returns false to cancel the default action.

Parameters

this :  Ext.view.View

e :  Ext.event.Event

The raw event object

eOpts : Object

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

beforecontainermouseout ( this , e , eOpts )

Fires before the mouseout event on the container is processed. Returns false to cancel the default action.

Parameters

this :  Ext.view.View

e :  Ext.event.Event

The raw event object

eOpts : Object

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

beforecontainermouseover ( this , e , eOpts )

Fires before the mouseover event on the container is processed. Returns false to cancel the default action.

Parameters

this :  Ext.view.View

e :  Ext.event.Event

The raw event object

eOpts : Object

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

beforecontainermouseup ( this , e , eOpts )

Fires before the mouseup event on the container is processed. Returns false to cancel the default action.

Parameters

this :  Ext.view.View

e :  Ext.event.Event

The raw event object

eOpts : Object

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

beforedeactivate ( this , eOpts )

Fires before a Component has been visually deactivated. Returning false from an event listener can prevent the deactivate from occurring.

Note This event is only fired if this Component is a child of a Ext.container.Container that uses Ext.layout.container.Card as it's layout.

Parameters

this :  Ext.Component

eOpts : Object

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

beforedeselect ( this , record , index , eOpts )

Fired before a record is deselected. If any listener returns false, the deselection is cancelled.

Parameters

record :  Ext.data.Model

The deselected record

index :  Number

The row index deselected

eOpts : Object

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

beforedestroy ( this , eOpts )

Fires before the component is destroyed. Return false from an event handler to stop the destroy.

Available since: 1.1.0

Parameters

this :  Ext.Component

eOpts : Object

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

beforeexpand ( p , animate , eOpts )

Fires before this panel is expanded. Return false to prevent the expand.

Parameters

p :  Ext.panel.Panel

The Panel being expanded.

animate :  Boolean

True if the expand is animated, else false.

eOpts : Object

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

beforehide ( this , eOpts )

Fires before the component is hidden when calling the hide method. Return false from an event handler to stop the hide.

Available since: 1.1.0

Parameters

this :  Ext.Component

eOpts : Object

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

beforeitemappend ( this , node , eOpts )

Fires before a new child is appended, return false to cancel the append.

Parameters

this :  Ext.data.NodeInterface

This node

node :  Ext.data.NodeInterface

The child node to be appended

eOpts : Object

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

beforeitemclick ( this , record , item , index , e , eOpts )

Fires before the click event on an item is processed. Returns false to cancel the default action.

Parameters

this :  Ext.view.View

record :  Ext.data.Model

The record that belongs to the item

item :  HTMLElement

The item's element

index :  Number

The item's index

e :  Ext.event.Event

The raw event object

eOpts : Object

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

beforeitemcollapse ( this , eOpts )

Fires before this node is collapsed.

Parameters

this :  Ext.data.NodeInterface

The collapsing node

eOpts : Object

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

beforeitemcontextmenu ( this , record , item , index , e , eOpts )

Fires before the contextmenu event on an item is processed. Returns false to cancel the default action.

Parameters

this :  Ext.view.View

record :  Ext.data.Model

The record that belongs to the item

item :  HTMLElement

The item's element

index :  Number

The item's index

e :  Ext.event.Event

The raw event object

eOpts : Object

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

beforeitemdblclick ( this , record , item , index , e , eOpts )

Fires before the dblclick event on an item is processed. Returns false to cancel the default action.

Parameters

this :  Ext.view.View

record :  Ext.data.Model

The record that belongs to the item

item :  HTMLElement

The item's element

index :  Number

The item's index

e :  Ext.event.Event

The raw event object

eOpts : Object

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

beforeitemexpand ( this , eOpts )

Fires before this node is expanded.

Parameters

this :  Ext.data.NodeInterface

The expanding node

eOpts : Object

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

beforeiteminsert ( this , node , refNode , eOpts )

Fires before a new child is inserted, return false to cancel the insert.

Parameters

this :  Ext.data.NodeInterface

This node

node :  Ext.data.NodeInterface

The child node to be inserted

refNode :  Ext.data.NodeInterface

The child node the node is being inserted before

eOpts : Object

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

beforeitemkeydown ( this , record , item , index , e , eOpts )

Fires before the keydown event on an item is processed. Returns false to cancel the default action.

Parameters

this :  Ext.view.View

record :  Ext.data.Model

The record that belongs to the item

item :  HTMLElement

The item's element

index :  Number

The item's index

e :  Ext.event.Event

The raw event object. Use getKey() to retrieve the key that was pressed.

eOpts : Object

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

beforeitemmousedown ( this , record , item , index , e , eOpts )

Fires before the mousedown event on an item is processed. Returns false to cancel the default action.

Parameters

this :  Ext.view.View

record :  Ext.data.Model

The record that belongs to the item

item :  HTMLElement

The item's element

index :  Number

The item's index

e :  Ext.event.Event

The raw event object

eOpts : Object

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

beforeitemmouseenter ( this , record , item , index , e , eOpts )

Fires before the mouseenter event on an item is processed. Returns false to cancel the default action.

Parameters

this :  Ext.view.View

record :  Ext.data.Model

The record that belongs to the item

item :  HTMLElement

The item's element

index :  Number

The item's index

e :  Ext.event.Event

The raw event object

eOpts : Object

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

beforeitemmouseleave ( this , record , item , index , e , eOpts )

Fires before the mouseleave event on an item is processed. Returns false to cancel the default action.

Parameters

this :  Ext.view.View

record :  Ext.data.Model

The record that belongs to the item

item :  HTMLElement

The item's element

index :  Number

The item's index

e :  Ext.event.Event

The raw event object

eOpts : Object

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

beforeitemmouseup ( this , record , item , index , e , eOpts )

Fires before the mouseup event on an item is processed. Returns false to cancel the default action.

Parameters

this :  Ext.view.View

record :  Ext.data.Model

The record that belongs to the item

item :  HTMLElement

The item's element

index :  Number

The item's index

e :  Ext.event.Event

The raw event object

eOpts : Object

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

beforeitemmove ( this , oldParent , newParent , index , eOpts )

Fires before this node is moved to a new location in the tree. Return false to cancel the move.

Parameters

this :  Ext.data.NodeInterface

This node

oldParent :  Ext.data.NodeInterface

The parent of this node

newParent :  Ext.data.NodeInterface

The new parent this node is moving to

index :  Number

The index it is being moved to

eOpts : Object

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

beforeitemremove ( this , node , isMove , eOpts )

Fires before a child is removed, return false to cancel the remove.

Parameters

this :  Ext.data.NodeInterface

This node

node :  Ext.data.NodeInterface

The child node to be removed

isMove :  Boolean

true if the child node is being removed so it can be moved to another position in the tree. (a side effect of calling appendChild or insertBefore with a node that already has a parentNode)

eOpts : Object

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

beforeload ( store , operation , eOpts )

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

Parameters

store :  Ext.data.Store

This Store

operation :  Ext.data.operation.Operation

The Ext.data.operation.Operation object that will be passed to the Proxy to load the Store

eOpts : Object

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

beforeremove ( this , component , eOpts )

Fires before any Ext.Component is removed from the container. A handler can return false to cancel the remove.

Available since: 2.3.0

Parameters

component :  Ext.Component

The component being removed

eOpts : Object

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

beforerender ( this , eOpts )

Fires before the component is rendered. Return false from an event handler to stop the render.

Available since: 1.1.0

Parameters

this :  Ext.Component

eOpts : Object

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

beforeselect ( this , record , index , eOpts )

Fired before a record is selected. If any listener returns false, the selection is cancelled.

Parameters

record :  Ext.data.Model

The selected record

index :  Number

The row index selected

eOpts : Object

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

beforeshow ( this , eOpts )

Fires before the component is shown when calling the show method. Return false from an event handler to stop the show.

Available since: 1.1.0

Parameters

this :  Ext.Component

eOpts : Object

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

beforestaterestore ( this , state , eOpts )

Fires before the state of the object is restored. Return false from an event handler to stop the restore.

Parameters

state :  Object

The hash of state values returned from the StateProvider. If this event is not vetoed, then the state object is passed to applyState. By default, that simply copies property values into this object. The method maybe overriden to provide custom state restoration.

eOpts : Object

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

beforestatesave ( this , state , eOpts )

Fires before the state of the object is saved to the configured state provider. Return false to stop the save.

Parameters

state :  Object

The hash of state values. This is determined by calling getState() on the object. This method must be provided by the developer to return whatever representation of state is required, by default, Ext.state.Stateful has a null implementation.

eOpts : Object

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

blur ( this , event , eOpts )

Fires when this Component loses focus.

Parameters

this :  Ext.Component

event :  Ext.event.Event

The blur event.

eOpts : Object

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

boxready ( this , width , height , eOpts )

Fires one time - after the component has been laid out for the first time at its initial size.

Parameters

this :  Ext.Component

width :  Number

The initial width.

height :  Number

The initial height.

eOpts : Object

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

cellclick ( this , td , cellIndex , record , tr , rowIndex , e , eOpts )

Fired when table cell is clicked.

Parameters

this :  Ext.view.Table

td :  HTMLElement

The TD element for the cell.

cellIndex :  Number

record :  Ext.data.Model

tr :  HTMLElement

The TR element for the cell.

rowIndex :  Number

eOpts : Object

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

cellcontextmenu ( this , td , cellIndex , record , tr , rowIndex , e , eOpts )

Fired when table cell is right clicked.

Parameters

this :  Ext.view.Table

td :  HTMLElement

The TD element for the cell.

cellIndex :  Number

record :  Ext.data.Model

tr :  HTMLElement

The TR element for the cell.

rowIndex :  Number

eOpts : Object

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

celldblclick ( this , td , cellIndex , record , tr , rowIndex , e , eOpts )

Fired when table cell is double clicked.

Parameters

this :  Ext.view.Table

td :  HTMLElement

The TD element for the cell.

cellIndex :  Number

record :  Ext.data.Model

tr :  HTMLElement

The TR element for the cell.

rowIndex :  Number

eOpts : Object

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

cellkeydown ( this , td , cellIndex , record , tr , rowIndex , e , eOpts )

Fired when the keydown event is captured on the cell.

Parameters

this :  Ext.view.Table

td :  HTMLElement

The TD element for the cell.

cellIndex :  Number

record :  Ext.data.Model

tr :  HTMLElement

The TR element for the cell.

rowIndex :  Number

eOpts : Object

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

cellmousedown ( this , td , cellIndex , record , tr , rowIndex , e , eOpts )

Fired when the mousedown event is captured on the cell.

Parameters

this :  Ext.view.Table

td :  HTMLElement

The TD element for the cell.

cellIndex :  Number

record :  Ext.data.Model

tr :  HTMLElement

The TR element for the cell.

rowIndex :  Number

eOpts : Object

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

cellmouseup ( this , td , cellIndex , record , tr , rowIndex , e , eOpts )

Fired when the mouseup event is captured on the cell.

Parameters

this :  Ext.view.Table

td :  HTMLElement

The TD element for the cell.

cellIndex :  Number

record :  Ext.data.Model

tr :  HTMLElement

The TR element for the cell.

rowIndex :  Number

eOpts : Object

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

checkchange ( node , checked , eOpts )

Fires when a node with a checkbox's checked property changes

Parameters

node :  Ext.data.TreeModel

The node who's checked property was changed

checked :  Boolean

The node's new checked state

eOpts : Object

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

close ( panel , eOpts )

Fires when the user closes the panel.

Parameters

panel :  Ext.panel.Panel

The Panel object

eOpts : Object

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

collapse ( p , eOpts )

Fires after this Panel has collapsed.

Parameters

p :  Ext.panel.Panel

The Panel that has been collapsed.

eOpts : Object

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

columnhide ( ct , column , eOpts )

Parameters

ct :  Ext.grid.header.Container

The grid's header Container which encapsulates all column headers.

column :  Ext.grid.column.Column

The Column header Component which provides the column definition

eOpts : Object

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

columnmove ( ct , column , fromIdx , toIdx , eOpts )

Parameters

ct :  Ext.grid.header.Container

The grid's header Container which encapsulates all column headers.

column :  Ext.grid.column.Column

The Column header Component which provides the column definition

fromIdx :  Number

toIdx :  Number

eOpts : Object

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

columnresize ( ct , column , width , eOpts )

Parameters

ct :  Ext.grid.header.Container

The grid's header Container which encapsulates all column headers.

column :  Ext.grid.column.Column

The Column header Component which provides the column definition

width :  Number

eOpts : Object

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

columnschanged ( ct , eOpts )

Fired after the columns change in any way, when a column has been hidden or shown, or when a column is added to or removed from this header container.

Parameters

ct :  Ext.grid.header.Container

The grid's header Container which encapsulates all column headers.

eOpts : Object

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

columnshow ( ct , column , eOpts )

Parameters

ct :  Ext.grid.header.Container

The grid's header Container which encapsulates all column headers.

column :  Ext.grid.column.Column

The Column header Component which provides the column definition

eOpts : Object

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

containerclick ( this , e , eOpts )

Fires when the container is clicked.

Parameters

this :  Ext.view.View

e :  Ext.event.Event

The raw event object

eOpts : Object

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

containercontextmenu ( this , e , eOpts )

Fires when the container is right clicked.

Parameters

this :  Ext.view.View

e :  Ext.event.Event

The raw event object

eOpts : Object

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

containerdblclick ( this , e , eOpts )

Fires when the container is double clicked.

Parameters

this :  Ext.view.View

e :  Ext.event.Event

The raw event object

eOpts : Object

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

containerkeydown ( this , e , eOpts )

Fires when a key is pressed while the container is focused, and no item is currently selected.

Parameters

this :  Ext.view.View

e :  Ext.event.Event

The raw event object. Use getKey() to retrieve the key that was pressed.

eOpts : Object

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

containermousedown ( this , e , eOpts )

Fires when there is a mousedown on the container

Parameters

this :  Ext.view.View

e :  Ext.event.Event

The raw event object

eOpts : Object

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

containermouseout ( this , e , eOpts )

Fires when you move the mouse out of the container.

Parameters

this :  Ext.view.View

e :  Ext.event.Event

The raw event object

eOpts : Object

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

containermouseover ( this , e , eOpts )

Fires when you move the mouse over the container.

Parameters

this :  Ext.view.View

e :  Ext.event.Event

The raw event object

eOpts : Object

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

containermouseup ( this , e , eOpts )

Fires when there is a mouseup on the container

Parameters

this :  Ext.view.View

e :  Ext.event.Event

The raw event object

eOpts : Object

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

deactivate ( this , eOpts )

Fires after a Component has been visually deactivated.

Note This event is only fired if this Component is a child of a Ext.container.Container that uses Ext.layout.container.Card as it's layout or this Component is a floating Component.

Parameters

this :  Ext.Component

eOpts : Object

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

deselect ( this , record , index , eOpts )

Fired after a record is deselected

Parameters

record :  Ext.data.Model

The deselected record

index :  Number

The row index deselected

eOpts : Object

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

destroy ( this , eOpts )

Fires after the component is destroyed.

Available since: 1.1.0

Parameters

this :  Ext.Component

eOpts : Object

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

disable ( this , eOpts )

Fires after the component is disabled.

Available since: 1.1.0

Parameters

this :  Ext.Component

eOpts : Object

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

dockedadd ( this , component , index , eOpts )

Fires when any Ext.Component is added or inserted as a docked item.

Parameters

this :  Ext.panel.Panel

component :  Ext.Component

The component being added

index :  Number

The index at which the component will be added docked items collection

eOpts : Object

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

dockedremove ( this , component , eOpts )

Fires when any Ext.Component is removed from the docked items.

Parameters

this :  Ext.panel.Panel

component :  Ext.Component

The component being removed

eOpts : Object

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

enable ( this , eOpts )

Fires after the component is enabled.

Available since: 1.1.0

Parameters

this :  Ext.Component

eOpts : Object

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

expand ( p , eOpts )

Fires after this Panel has expanded.

Parameters

p :  Ext.panel.Panel

The Panel that has been expanded.

eOpts : Object

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

filterchange ( store , filters , eOpts )

Fired whenever the filter set changes.

Parameters

store :  Ext.data.Store

The store.

filters :  Ext.util.Filter[]

The array of Filter objects.

eOpts : Object

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

float

Fires after a collapsed Panel has been "floated" by clicking on it's header. Only applicable when the Panel is an item in a Ext.layout.container.Border.

focus ( this , event , eOpts )

Fires when this Component receives focus.

Parameters

this :  Ext.Component

event :  Ext.event.Event

The focus event.

eOpts : Object

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

glyphchange ( this , newGlyph , oldGlyph , eOpts )

Fired when the Panel glyph has been changed by the setGlyph method.

Parameters

this :  Ext.panel.Panel

newGlyph :  Number / String

oldGlyph :  Number / String

eOpts : Object

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

groupchange ( store , grouper , eOpts )

Fired whenever the grouping in the grid changes.

Parameters

store :  Ext.data.Store

The store.

grouper :  Ext.util.Grouper

The grouper object.

eOpts : Object

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

headerclick ( ct , column , e , t , eOpts )

Parameters

ct :  Ext.grid.header.Container

The grid's header Container which encapsulates all column headers.

column :  Ext.grid.column.Column

The Column header Component which provides the column definition

t :  HTMLElement

eOpts : Object

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

headercontextmenu ( ct , column , e , t , eOpts )

Parameters

ct :  Ext.grid.header.Container

The grid's header Container which encapsulates all column headers.

column :  Ext.grid.column.Column

The Column header Component which provides the column definition

t :  HTMLElement

eOpts : Object

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

headertriggerclick ( ct , column , e , t , eOpts )

Parameters

ct :  Ext.grid.header.Container

The grid's header Container which encapsulates all column headers.

column :  Ext.grid.column.Column

The Column header Component which provides the column definition

t :  HTMLElement

eOpts : Object

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

hide ( this , eOpts )

Fires after the component is hidden. Fires after the component is hidden when calling the hide method.

Available since: 1.1.0

Parameters

this :  Ext.Component

eOpts : Object

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

iconchange ( p , newIcon , oldIcon , eOpts )

Fires after the Panel icon has been set or changed.

Parameters

p :  Ext.panel.Panel

The Panel which has the icon changed.

newIcon :  String

The path to the new icon image.

oldIcon :  String

The path to the previous panel icon image.

eOpts : Object

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

iconclschange ( p , newIconCls , oldIconCls , eOpts )

Fires after the Panel iconCls has been set or changed.

Parameters

p :  Ext.panel.Panel

The Panel which has the iconCls changed.

newIconCls :  String

The new iconCls.

oldIconCls :  String

The previous panel iconCls.

eOpts : Object

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

itemappend ( this , node , index , eOpts )

Fires when a new child node is appended

Parameters

this :  Ext.data.NodeInterface

This node

node :  Ext.data.NodeInterface

The newly appended node

index :  Number

The index of the newly appended node

eOpts : Object

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

itemclick ( this , record , item , index , e , eOpts )

Fires when an item is clicked.

Parameters

this :  Ext.view.View

record :  Ext.data.Model

The record that belongs to the item

item :  HTMLElement

The item's element

index :  Number

The item's index

e :  Ext.event.Event

The raw event object

eOpts : Object

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

itemcollapse ( this , eOpts )

Fires when this node is collapsed.

Parameters

this :  Ext.data.NodeInterface

The collapsing node

eOpts : Object

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

itemcontextmenu ( this , record , item , index , e , eOpts )

Fires when an item is right clicked.

Parameters

this :  Ext.view.View

record :  Ext.data.Model

The record that belongs to the item

item :  HTMLElement

The item's element

index :  Number

The item's index

e :  Ext.event.Event

The raw event object

eOpts : Object

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

itemdblclick ( this , record , item , index , e , eOpts )

Fires when an item is double clicked.

Parameters

this :  Ext.view.View

record :  Ext.data.Model

The record that belongs to the item

item :  HTMLElement

The item's element

index :  Number

The item's index

e :  Ext.event.Event

The raw event object

eOpts : Object

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

itemexpand ( this , eOpts )

Fires when this node is expanded.

Parameters

this :  Ext.data.NodeInterface

The expanding node

eOpts : Object

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

iteminsert ( this , node , refNode , eOpts )

Fires when a new child node is inserted.

Parameters

this :  Ext.data.NodeInterface

This node

node :  Ext.data.NodeInterface

The child node inserted

refNode :  Ext.data.NodeInterface

The child node the node was inserted before

eOpts : Object

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

itemkeydown ( this , record , item , index , e , eOpts )

Fires when a key is pressed while an item is currently selected.

Parameters

this :  Ext.view.View

record :  Ext.data.Model

The record that belongs to the item

item :  HTMLElement

The item's element

index :  Number

The item's index

e :  Ext.event.Event

The raw event object. Use getKey() to retrieve the key that was pressed.

eOpts : Object

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

itemmousedown ( this , record , item , index , e , eOpts )

Fires when there is a mouse down on an item

Parameters

this :  Ext.view.View

record :  Ext.data.Model

The record that belongs to the item

item :  HTMLElement

The item's element

index :  Number

The item's index

e :  Ext.event.Event

The raw event object

eOpts : Object

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

itemmouseenter ( this , record , item , index , e , eOpts )

Fires when the mouse enters an item.

Parameters

this :  Ext.view.View

record :  Ext.data.Model

The record that belongs to the item

item :  HTMLElement

The item's element

index :  Number

The item's index

e :  Ext.event.Event

The raw event object

eOpts : Object

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

itemmouseleave ( this , record , item , index , e , eOpts )

Fires when the mouse leaves an item.

Parameters

this :  Ext.view.View

record :  Ext.data.Model

The record that belongs to the item

item :  HTMLElement

The item's element

index :  Number

The item's index

e :  Ext.event.Event

The raw event object

eOpts : Object

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

itemmouseup ( this , record , item , index , e , eOpts )

Fires when there is a mouse up on an item

Parameters

this :  Ext.view.View

record :  Ext.data.Model

The record that belongs to the item

item :  HTMLElement

The item's element

index :  Number

The item's index

e :  Ext.event.Event

The raw event object

eOpts : Object

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

itemmove ( this , oldParent , newParent , index , eOpts )

Fires when this node is moved to a new location in the tree

Parameters

this :  Ext.data.NodeInterface

This node

oldParent :  Ext.data.NodeInterface

The old parent of this node

newParent :  Ext.data.NodeInterface

The new parent of this node

index :  Number

The index it was moved to

eOpts : Object

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

itemremove ( this , node , isMove , eOpts )

Fires when a child node is removed

Parameters

this :  Ext.data.NodeInterface

This node

node :  Ext.data.NodeInterface

The removed node

isMove :  Boolean

true if the child node is being removed so it can be moved to another position in the tree. (a side effect of calling appendChild or insertBefore with a node that already has a parentNode)

eOpts : Object

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

load ( this , records , successful , operation , node , eOpts )

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

Parameters

records :  Ext.data.TreeModel[]

An array of records.

successful :  Boolean

True if the operation was successful.

operation :  Ext.data.operation.Operation

The operation that triggered this load.

node :  Ext.data.NodeInterface

The node that was loaded.

eOpts : Object

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

move ( this , component , prevIndex , newIndex , eOpts )

Fires after any Ext.Component has changed its ordinal position within the container.

This event bubbles: 'move' will also be fired when Component is removed from any of the child containers or their children or ...

Parameters

component :  Ext.Component

The component that was moved

prevIndex :  Ext.Component

The previous ordinal position of the Component

newIndex :  Ext.Component

The new ordinal position of the Component

eOpts : Object

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

remove ( this , component , eOpts )

Fires after any Ext.Component is removed from the container.

This event bubbles: 'remove' will also be fired when Component is removed from any of the child containers or their children or ...

Available since: 2.3.0

Parameters

component :  Ext.Component

The component that was removed

eOpts : Object

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

removed ( this , ownerCt , eOpts )

Fires when a component is removed from an Ext.container.Container

Available since: 3.4.0

Parameters

this :  Ext.Component

ownerCt :  Ext.container.Container

Container which holds the component

eOpts : Object

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

render ( this , eOpts )

Fires after the component markup is rendered.

Available since: 1.1.0

Parameters

this :  Ext.Component

eOpts : Object

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

resize ( this , width , height , oldWidth , oldHeight , eOpts )

Fires after the component is resized. Note that this does not fire when the component is first laid out at its initial size. To hook that point in the life cycle, use the boxready event.

Parameters

this :  Ext.Component

width :  Number

The new width that was set.

height :  Number

The new height that was set.

oldWidth :  Number

The previous width.

oldHeight :  Number

The previous height.

eOpts : Object

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

rowclick ( this , record , element , rowIndex , e , eOpts )

Fired when a table row is clicked.

Parameters

this :  Ext.view.Table

record :  Ext.data.Model

element :  HTMLElement

The TR element for the row.

rowIndex :  Number

eOpts : Object

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

rowcontextmenu ( this , record , element , rowIndex , e , eOpts )

Fired when a table row is right clicked.

Parameters

this :  Ext.view.Table

record :  Ext.data.Model

element :  HTMLElement

The TR element for the row.

rowIndex :  Number

eOpts : Object

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

rowdblclick ( this , record , element , rowIndex , e , eOpts )

Fired when a table row is double clicked.

Parameters

this :  Ext.view.Table

record :  Ext.data.Model

element :  HTMLElement

The TR element for the row.

rowIndex :  Number

eOpts : Object

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

rowkeydown ( this , record , element , rowIndex , e , eOpts )

Fired when the keydown event is captured on the row.

Parameters

this :  Ext.view.Table

record :  Ext.data.Model

element :  HTMLElement

The TR element for the row.

rowIndex :  Number

eOpts : Object

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

rowmousedown ( this , record , element , rowIndex , e , eOpts )

Fired when the mousedown event is captured on the row.

Parameters

this :  Ext.view.Table

record :  Ext.data.Model

element :  HTMLElement

The TR element for the row.

rowIndex :  Number

eOpts : Object

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

rowmouseup ( this , record , element , rowIndex , e , eOpts )

Fired when the mouseup event is captured on the row.

Parameters

this :  Ext.view.Table

record :  Ext.data.Model

element :  HTMLElement

The TR element for the row.

rowIndex :  Number

eOpts : Object

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

select ( this , record , index , eOpts )

Fired after a record is selected

Parameters

record :  Ext.data.Model

The selected record

index :  Number

The row index selected

eOpts : Object

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

selectionchange ( this , selected , eOpts )

Fired after a selection change has occurred

Parameters

selected :  Ext.data.Model[]

The selected records

eOpts : Object

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

show ( this , eOpts )

Fires after the component is shown when calling the show method.

Available since: 1.1.0

Parameters

this :  Ext.Component

eOpts : Object

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

sortchange ( ct , column , direction , eOpts )

Parameters

ct :  Ext.grid.header.Container

The grid's header Container which encapsulates all column headers.

column :  Ext.grid.column.Column

The Column header Component which provides the column definition

direction :  String

eOpts : Object

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

staterestore ( this , state , eOpts )

Fires after the state of the object is restored.

Parameters

state :  Object

The hash of state values returned from the StateProvider. This is passed to applyState. By default, that simply copies property values into this object. The method maybe overridden to provide custom state restoration.

eOpts : Object

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

statesave ( this , state , eOpts )

Fires after the state of the object is saved to the configured state provider.

Parameters

state :  Object

The hash of state values. This is determined by calling getState() on the object. This method must be provided by the developer to return whatever representation of state is required, by default, Ext.state.Stateful has a null implementation.

eOpts : Object

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

titlechange ( p , newTitle , oldTitle , eOpts )

Fires after the Panel title has been set or changed.

Parameters

p :  Ext.panel.Panel

the Panel which has been resized.

newTitle :  String

The new title.

oldTitle :  String

The previous panel title.

eOpts : Object

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

unfloat

Fires after a "floated" Panel has returned to it's collapsed state as a result of the mouse leaving the Panel. Only applicable when the Panel is an item in a Ext.layout.container.Border.

viewready ( this , eOpts )

Fires when the grid view is available (use this for selecting a default row).

Parameters

this :  Ext.panel.Table

eOpts : Object

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

theme variables

$border-width-threshold : Number

The maximum width a Panel's border can be before resizer handles are embedded into the borders using negative absolute positions.

This defaults to 2, so that in the classic theme which uses 1 pixel borders, resize handles are in the content area within the border as they always have been.

In the Neptune theme, the handles are embedded into the 5 pixel wide borders of any framed panel.

Defaults to: 2

$include-panel-default-framed-ui : Boolean

True to include the "default-framed" panel UI

Defaults to: $include-default-uis

$include-panel-default-ui : Boolean

True to include the "default" panel UI

Defaults to: $include-default-uis

$include-panel-light-framed-ui : Boolean

True to include the "light-framed" panel UI

Defaults to: $include-default-uis

$include-panel-light-ui : Boolean

True to include the "light" panel UI

Defaults to: $include-default-uis

$panel-background-stretch-bottom : String

The direction to strech the background-gradient of bottom docked Headers when slicing images for IE using Sencha Cmd

Defaults to: top

$panel-background-stretch-left : String

The direction to strech the background-gradient of left docked Headers when slicing images for IE using Sencha Cmd

Defaults to: right

$panel-background-stretch-right : String

The direction to strech the background-gradient of right docked Headers when slicing images for IE using Sencha Cmd

Defaults to: left

$panel-background-stretch-top : String

The direction to strech the background-gradient of top docked Headers when slicing images for IE using Sencha Cmd

Defaults to: bottom

$panel-base-color : color

The base color of Panels

Defaults to: $base-color

$panel-body-background-color : color

The default body background-color of Panels

Defaults to: #fff

$panel-body-border-color : color

The default border-color of the Panel body

Defaults to: $panel-border-color

$panel-body-border-style : String

The default border-style of Panels

Defaults to: solid

$panel-body-border-width : Number

The default border-width of the Panel body

Defaults to: 1px

$panel-body-color : color

The default color of text inside a Panel's body

Defaults to: #000

$panel-body-font-family : String

The default font-family of the Panel body

Defaults to: $font-family

$panel-body-font-size : Number

The default font-size of the Panel body

Defaults to: $font-size

$panel-body-font-weight : String

The default font-weight of the Panel body

Defaults to: $font-weight

$panel-border-color : color

The default border-color of Panels

Defaults to: $panel-base-color

$panel-border-width : Number

The default border-width of Panels

Defaults to: 1px

$panel-frame-background-color : color

The background-color of framed Panels

Defaults to: #fff

$panel-frame-base-color : color

The base color of the framed Panels

Defaults to: $panel-base-color

$panel-frame-body-border-width : Number

The border-width of the body element of framed Panels

Defaults to: 1px

$panel-frame-border-color : color

The border-color of framed Panels

Defaults to: $panel-border-color

$panel-frame-border-radius : Number

The border-radius of framed Panels

Defaults to: 4px

$panel-frame-border-style : String

The border-style of framed Panels

Defaults to: solid

$panel-frame-border-width : Number

The border-width of framed Panels

Defaults to: 1px

$panel-frame-header-border-width : Number

The border-width of framed Panel Headers

Defaults to: $panel-header-border-width

$panel-frame-header-inner-border-color : color

The inner border-color of framed Panel Headers

Defaults to: #fff

$panel-frame-header-inner-border-width : Number

The inner border-width of framed Panel Headers

Defaults to: 0

$panel-frame-header-padding : Number / list

The padding of framed Panel Headers

Defaults to: $panel-header-padding

$panel-frame-padding : Number

The padding of framed Panels

Defaults to: 4px

$panel-ghost-opacity : Number

The opacity of ghost Panels while dragging

Defaults to: 0.50

$panel-header-background-color : color

The background-color of the Panel Header

Defaults to: $panel-base-color

$panel-header-background-gradient : String / list

The background-gradient of the Panel Header. Can be either the name of a predefined gradient or a list of color stops. Used as the $type parameter for Global_CSS#background-gradient.

Defaults to: 'none'

$panel-header-border-color : color

The border-color of the Panel Header

Defaults to: $panel-border-color

$panel-header-border-style : String

The border-style of Panel Headers

Defaults to: solid

$panel-header-border-width : Number

The border-width of Panel Headers

Defaults to: $panel-border-width

$panel-header-color : color

The text color of the Panel Header

Defaults to: $color

$panel-header-font-family : String

The font-family of Panel Headers

Defaults to: $font-family

$panel-header-font-size : Number

The font-size of Panel Headers

Defaults to: $font-size

$panel-header-font-weight : String

The font-weight of Panel Headers

Defaults to: $font-weight-bold

$panel-header-glyph-color : color

The color of the Panel Header glyph icon

Defaults to: $panel-header-color

$panel-header-glyph-opacity : Number

The opacity of the Panel Header glyph icon

Defaults to: .5

$panel-header-icon-background-position : list

The background-position of the Panel Header icon

Defaults to: center center

$panel-header-icon-height : Number

The height of the Panel Header icon

Defaults to: 16px

$panel-header-icon-spacing : Number

The space between the Panel Header icon and text

Defaults to: 4px

$panel-header-icon-width : Number

The width of the Panel Header icon

Defaults to: 16px

$panel-header-inner-border-color : color

The inner border-color of the Panel Header

Defaults to: #fff

$panel-header-inner-border-width : Number

The inner border-width of the Panel Header

Defaults to: 0

$panel-header-line-height : Number

The line-height of Panel Headers

Defaults to: 16px

$panel-header-noborder-adjust : Boolean

True to adjust the padding of borderless panel headers so that their height is the same as the height of bordered panels. This is helpful when borderless and bordered panels are used side-by-side, as it maintains a consistent vertical alignment.

Defaults to: true

$panel-header-padding : Number / list

The padding of Panel Headers

Defaults to: 5px

$panel-header-text-margin : Number / list

The margin of the Panel Header's text element

Defaults to: 0

$panel-header-text-padding : Number / list

The padding of the Panel Header's text element

Defaults to: 0

$panel-header-text-transform : String

The text-transform of Panel Headers

Defaults to: none

$panel-ignore-frame-padding : Boolean

True to ignore the frame padding. By default, the frame mixin adds extra padding when border radius is larger than border width. This is intended to prevent the content from colliding with the rounded corners of the frame. Set this to true to prevent the panel frame from adding this extra padding.

Defaults to: false

$panel-include-border-management-rules : Boolean

True to include neptune style border management rules.

Defaults to: false

$panel-tool-background-image : String

The background sprite to use for Panel Ext.panel.Tool

Defaults to: 'tools/tool-sprites'

$panel-tool-spacing : Number

The space between the Panel Ext.panel.Tool

Defaults to: 4px

$panel-wrap-border-color : color

The color to apply to the border that wraps the body and docked items in a framed panel. The presence of the wrap border in a framed panel is controlled by the border config. Only applicable when $panel-include-border-management-rules is true.

Defaults to: $panel-border-color

$panel-wrap-border-width : Number

The width to apply to the border that wraps the body and docked items in a framed panel. The presence of the wrap border in a framed panel is controlled by the border config. Only applicable when $panel-include-border-management-rules is true.

Defaults to: 1px

$scroll-indicator-background-color : color

The background color of scroll indicators when touch scrolling is enabled

Defaults to: #000

$scroll-indicator-border-radius : Number

The border-radius of scroll indicators when touch scrolling is enabled

Defaults to: 3px

$scroll-indicator-margin : Number

The space between scroll indicators and the edge of their container

Defaults to: 2px

$scroll-indicator-opacity : Number

The opacity of scroll indicators when touch scrolling is enabled

Defaults to: .5

$scroll-indicator-size : color

The background color of scroll indicators when touch scrolling is enabled

Defaults to: 6px

theme mixins

extjs-panel-ui ( ...list... )

Creates a visual theme for a Panel

Parameters

$ui :  String

The name of the UI being created. Can not included spaces or special punctuation (used in CSS class names).

$ui-border-color :  color (optional)

The border-color of the Panel

Defaults to: $panel-border-color

$ui-border-radius :  Number (optional)

The border-radius of the Panel

Defaults to: $panel-border-radius

$ui-border-width :  Number (optional)

The border-width of the Panel

Defaults to: $panel-border-width

$ui-padding :  Number (optional)

The padding of the Panel

Defaults to: $panel-padding

$ui-header-color :  color (optional)

The text color of the Header

Defaults to: $panel-header-color

$ui-header-font-family :  String (optional)

The font-family of the Header

Defaults to: $panel-header-font-family

$ui-header-font-size :  Number (optional)

The font-size of the Header

Defaults to: $panel-header-font-size

$ui-header-font-weight :  String (optional)

The font-weight of the Header

Defaults to: $panel-header-font-weight

$ui-header-line-height :  Number (optional)

The line-height of the Header

Defaults to: $panel-header-line-height

$ui-header-border-color :  color (optional)

The border-color of the Header

Defaults to: $panel-header-border-color

$ui-header-border-width :  Number (optional)

The border-width of the Header

Defaults to: $panel-header-border-width

$ui-header-border-style :  String (optional)

The border-style of the Header

Defaults to: $panel-header-border-style

$ui-header-background-color :  color (optional)

The background-color of the Header

Defaults to: $panel-header-background-color

$ui-header-background-gradient :  String / list (optional)

The background-gradient of the Header. Can be either the name of a predefined gradient or a list of color stops. Used as the $type parameter for Global_CSS#background-gradient.

Defaults to: $panel-header-background-gradient

$ui-header-inner-border-color :  color (optional)

The inner border-color of the Header

Defaults to: $panel-header-inner-border-color

$ui-header-inner-border-width :  Number (optional)

The inner border-width of the Header

Defaults to: $panel-header-inner-border-width

$ui-header-text-padding :  Number / list (optional)

The padding of the Header's text element

Defaults to: $panel-header-text-padding

$ui-header-text-margin :  Number / list (optional)

The margin of the Header's text element

Defaults to: $panel-header-text-margin

$ui-header-text-transform :  String (optional)

The text-transform of the Header

Defaults to: $panel-header-text-transform

$ui-header-padding :  Number / list (optional)

The padding of the Header

Defaults to: $panel-header-padding

$ui-header-icon-width :  Number (optional)

The width of the Header icon

Defaults to: $panel-header-icon-width

$ui-header-icon-height :  Number (optional)

The height of the Header icon

Defaults to: $panel-header-icon-height

$ui-header-icon-spacing :  Number (optional)

The space between the Header icon and text

Defaults to: $panel-header-icon-spacing

$ui-header-icon-background-position :  list (optional)

The background-position of the Header icon

Defaults to: $panel-header-icon-background-position

$ui-header-glyph-color :  color (optional)

The color of the Header glyph icon

Defaults to: $panel-header-glyph-color

$ui-header-glyph-opacity :  Number (optional)

The opacity of the Header glyph icon

Defaults to: $panel-header-glyph-opacity

$ui-header-noborder-adjust :  Number (optional)

True to adjust the padding of borderless panel headers so that their height is the same as the height of bordered panels. This is helpful when borderless and bordered panels are used side-by-side, as it maintains a consistent vertical alignment.

Defaults to: $panel-header-noborder-adjust

$ui-tool-spacing :  Number (optional)

The space between the Panel Ext.panel.Tool

Defaults to: $panel-tool-spacing

$ui-tool-background-image :  String (optional)

The background sprite to use for Panel Ext.panel.Tool

Defaults to: $panel-tool-background-image

$ui-body-color :  color (optional)

The color of text inside the Panel body

Defaults to: $panel-body-color

$ui-body-border-color :  color (optional)

The border-color of the Panel body

Defaults to: $panel-body-border-color

$ui-body-border-width :  Number (optional)

The border-width of the Panel body

Defaults to: $panel-body-border-width

$ui-body-border-style :  String (optional)

The border-style of the Panel body

Defaults to: $panel-body-border-style

$ui-body-background-color :  color (optional)

The background-color of the Panel body

Defaults to: $panel-body-background-color

$ui-body-font-size :  Number (optional)

The font-size of the Panel body

Defaults to: $panel-body-font-size

$ui-body-font-weight :  String (optional)

The font-weight of the Panel body

Defaults to: $panel-body-font-weight

$ui-background-stretch-top :  String (optional)

The direction to strech the background-gradient of top docked Headers when slicing images for IE using Sencha Cmd

Defaults to: $panel-background-stretch-top

$ui-background-stretch-bottom :  String (optional)

The direction to strech the background-gradient of bottom docked Headers when slicing images for IE using Sencha Cmd

Defaults to: $panel-background-stretch-bottom

$ui-background-stretch-right :  String (optional)

The direction to strech the background-gradient of right docked Headers when slicing images for IE using Sencha Cmd

Defaults to: $panel-background-stretch-right

$ui-background-stretch-left :  String (optional)

The direction to strech the background-gradient of left docked Headers when slicing images for IE using Sencha Cmd

Defaults to: $panel-background-stretch-left

$ui-include-border-management-rules :  Boolean (optional)

True to include neptune style border management rules.

Defaults to: $panel-include-border-management-rules

$ui-wrap-border-color :  color (optional)

The color to apply to the border that wraps the body and docked items in a framed panel. The presence of the wrap border in a framed panel is controlled by the border config. Only applicable when $ui-include-border-management-rules is true.

Defaults to: $panel-wrap-border-color

$ui-wrap-border-width :  color (optional)

The width to apply to the border that wraps the body and docked items in a framed panel. The presence of the wrap border in a framed panel is controlled by the border config. Only applicable when $ui-include-border-management-rules is true.

Defaults to: $panel-wrap-border-width

$ui-ignore-frame-padding :  Boolean (optional)

True to ignore the frame padding. By default, the frame mixin adds extra padding when border radius is larger than border width. This is intended to prevent the content from colliding with the rounded corners of the frame. Set this to true to prevent the panel frame from adding this extra padding.

Defaults to: $panel-ignore-frame-padding

Ext JS 5.0.1

Ext JS
Sencha Test
Cmd
Sencha Themer
GXT
IDE Plugins
Sencha Inspector
Architect
Sencha Fiddle
Touch
Offline Documentation

Sencha Test

2.0.1 2.0.0 1.0.3

Cmd

Cmd

Sencha Themer

1.1.0 1.0.2

GXT

4.x 3.x

IDE Plugins

IDE Plugins

Sencha Inspector

Sencha Inspector

Sencha Fiddle

Sencha Fiddle

Offline Documentation

Offline Documentation