Many classes have shortcut names used when creating (instantiating) a class with a
configuration object. The shortcut name is referred to as an alias
(or xtype
if the
class extends Ext.Component). The alias/xtype is listed next to the class name of
applicable classes for quick reference.
Framework classes or their members may be specified as private
or protected
. Else,
the class / member is public
. Public
, protected
, and private
are access
descriptors used to convey how and when the class or class member should be used.
Public classes and class members are available for use by any other class or application code and may be relied upon as a stable and persistent within major product versions. Public classes and members may safely be extended via a subclass.
Protected class members are stable public
members intended to be used by the
owning class or its subclasses. Protected members may safely be extended via a subclass.
Private classes and class members are used internally by the framework and are not intended to be used by application developers. Private classes and members may change or be omitted from the framework at any time without notice and should not be relied upon in application logic.
static
label next to the
method name. *See Static below.Below is an example class member that we can disect to show the syntax of a class member (the lookupComponent method as viewed from the Ext.button.Button class in this case).
Let's look at each part of the member row:
lookupComponent
in this example)( item )
in this example)Ext.Component
in this case). This may be omitted for methods that do not
return anything other than undefined
or may display as multiple possible values
separated by a forward slash /
signifying that what is returned may depend on the
results of the method call (i.e. a method may return a Component if a get method calls is
successful or false
if unsuccessful which would be displayed as
Ext.Component/Boolean
).PROTECTED
in
this example - see the Flags section below)Ext.container.Container
in this example). The source
class will be displayed as a blue link if the member originates from the current class
and gray if it is inherited from an ancestor or mixed-in class.view source
in the example)item : Object
in the example).undefined
a "Returns" section
will note the type of class or object returned and a description (Ext.Component
in the
example)Available since 3.4.0
- not pictured in
the example) just after the member descriptionDefaults to: false
)The API documentation uses a number of flags to further commnicate the class member's function and intent. The label may be represented by a text label, an abbreviation, or an icon.
classInstance.method1().method2().etc();
false
is returned from
an event handler- Indicates a framework class
- A singleton framework class. *See the singleton flag for more information
- A component-type framework class (any class within the Ext JS framework that extends Ext.Component)
- Indicates that the class, member, or guide is new in the currently viewed version
- Indicates a class member of type config
- Indicates a class member of type property
- Indicates a class member of type
method
- Indicates a class member of type event
- Indicates a class member of type
theme variable
- Indicates a class member of type
theme mixin
- Indicates that the class, member, or guide is new in the currently viewed version
Just below the class name on an API doc page is a row of buttons corresponding to the types of members owned by the current class. Each button shows a count of members by type (this count is updated as filters are applied). Clicking the button will navigate you to that member section. Hovering over the member-type button will reveal a popup menu of all members of that type for quick navigation.
Getting and setter methods that correlate to a class config option will show up in the methods section as well as in the configs section of both the API doc and the member-type menus just beneath the config they work with. The getter and setter method documentation will be found in the config row for easy reference.
Your page history is kept in localstorage and displayed (using the available real estate) just below the top title bar. By default, the only search results shown are the pages matching the product / version you're currently viewing. You can expand what is displayed by clicking on the button on the right-hand side of the history bar and choosing the "All" radio option. This will show all recent pages in the history bar for all products / versions.
Within the history config menu you will also see a listing of your recent page visits. The results are filtered by the "Current Product / Version" and "All" radio options. Clicking on the button will clear the history bar as well as the history kept in local storage.
If "All" is selected in the history config menu the checkbox option for "Show product details in the history bar" will be enabled. When checked, the product/version for each historic page will show alongside the page name in the history bar. Hovering the cursor over the page names in the history bar will also show the product/version as a tooltip.
Both API docs and guides can be searched for using the search field at the top of the page.
On API doc pages there is also a filter input field that filters the member rows using the filter string. In addition to filtering by string you can filter the class members by access level, inheritance, and read only. This is done using the checkboxes at the top of the page.
The checkbox at the bottom of the API class navigation tree filters the class list to include or exclude private classes.
Clicking on an empty search field will show your last 10 searches for quick navigation.
Each API doc page (with the exception of Javascript primitives pages) has a menu view of metadata relating to that class. This metadata view will have one or more of the following:
Ext.button.Button
class has an alternate class name of Ext.Button
). Alternate class
names are commonly maintained for backward compatibility.Runnable examples (Fiddles) are expanded on a page by default. You can collapse and expand example code blocks individually using the arrow on the top-left of the code block. You can also toggle the collapse state of all examples using the toggle button on the top-right of the page. The toggle-all state will be remembered between page loads.
Class members are collapsed on a page by default. You can expand and collapse members using the arrow icon on the left of the member row or globally using the expand / collapse all toggle button top-right.
Viewing the docs on narrower screens or browsers will result in a view optimized for a smaller form factor. The primary differences between the desktop and "mobile" view are:
The class source can be viewed by clicking on the class name at the top of an API doc page. The source for class members can be viewed by clicking on the "view source" link on the right-hand side of the member row.
Ext.Mixin
Ext.container.DockingContainer
Ext.grid.locking.Lockable
Ext.mixin.Accessible
Ext.mixin.Bindable
Ext.mixin.ComponentDelegation
Ext.mixin.Container
Ext.mixin.Identifiable
Ext.mixin.Inheritable
Ext.mixin.Keyboard
Ext.mixin.Observable
Ext.mixin.Queryable
Ext.state.Stateful
Ext.util.Animate
Ext.util.ElementContainer
Ext.util.Floating
Ext.util.Focusable
Ext.util.Observable
Ext.util.Positionable
Ext.util.Renderable
A specialized grid implementation intended to mimic the traditional property grid as typically seen in development IDEs. Each row in the grid represents a property of some object, and the data is stored as a set of name/value pairs in Ext.grid.property.Property. By default, the editors shown are inferred from the data in the cell. More control over this can be specified by using the sourceConfig option. Example usage:
An object containing properties which define named Ext.Action for this container and any descendant components.
An Action encapsulates a shareable, reusable set of properties which define a "clickable" UI component such as a Ext.button.Button or Ext.menu.Item, or panel header tool, or an Ext.grid.column.Action
An Action, or more conveniently, the name of an action prefixed with '@'
may be used as a config object for creating child components which use a handler
config property to reference a Controller method to invoke when the component is
clicked.
The property name is the action name, which may then be used as a child item configuration in an items configuration in any descendant component such as a toolbar or a menu, or in a tools configuration of a Panel.
The property value is a configuration object for any clickable component.
See the Ext.Action class for an example of reusable Actions.
Defaults to:
null
Available since: 6.2.0
An incrementing numeric counter indicating activation index for use by the zIndexManager to sort its stack.
Defaults to:
0
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
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);
the activated component or false when nothing activated. False is returned also when trying to activate an already active item.
By default, when the alignTo method is called, a floating component will scroll to keep aligned with the anchoring element if the anchoring element is part of the scroll.
If this is not necessary, and the alignTo
is a one-off operation then set this config to false
.
Defaults to:
true
A Component or Element by which to position this component according to the defaultAlign. Defaults to the owning Container.
Only applicable if this component is cfg-floating
Used upon first show.
Defaults to:
null
True to allow deselecting a record. This config is forwarded to Ext.selection.Model#allowDeselect.
Defaults to:
false
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
This configuration option is to be applied to child items
of a container managed
by an Ext.layout.container.Anchor.
This value is what tells the layout how an item should be anchored to the container. items
added to an AnchorLayout accept an anchoring-specific config property of anchor which is a string
containing two values: the horizontal anchor value and the vertical anchor value (for example, '100% 50%').
The following types of anchor values are supported:
Percentage : Any value between 1 and 100, expressed as a percentage.
The first anchor is the percentage width that the item should take up within the container, and the second is the percentage height. For example:
// two values specified
anchor: '100% 50%' // render item complete width of the container and
// 1/2 height of the container
// one value specified
anchor: '100%' // the width value; the height will default to auto
Offsets : Any positive or negative integer value.
This is a raw adjustment where the first anchor is the offset from the right edge of the container, and the second is the offset from the bottom edge. For example:
// two values specified
anchor: '-50 -100' // render item the complete width of the container
// minus 50 pixels and
// the complete height minus 100 pixels.
// one value specified
anchor: '-50' // anchor value is assumed to be the right offset value
// bottom offset will default to 0
Sides : Valid values are right
(or r
) and bottom
(or b
).
Either the container must have a fixed size or an anchorSize config value defined at render time in order for these to have any effect.
Mixed :
Anchor values can also be mixed as needed. For example, to render the width offset from the container right edge by 50 pixels and 75% of the container's height use:
anchor: '-50 75%'
Defines the anchoring size of container.
Either a number to define the width of the container or an object with width
and height
fields.
true
to animate the shadow along with the component while the component is animating.
By default the shadow is hidden while the component is animating
Defaults to:
false
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
An object containing ARIA attributes to be set
on this Component's ARIA element. Use this to set the attributes that cannot be
determined by the Component's state, such as aria-live
, aria-flowto
, etc.
Note that this config is only meaningful at the Component rendering time, and setting it after that will do nothing.
Defaults to:
null
Sets the value of ariaAttributes
ariaAttributes : Object
DOM selector for a child element that is to be used
as description for this Component, set in aria-describedby
attribute.
The selector works the same way as ariaLabelledBy.
ARIA label for this Component. It is best to use
ariaLabelledBy option instead, because screen readers prefer
aria-labelledby
attribute to aria-label
. ariaLabel and
ariaLabelledBy config options are mutually exclusive.
DOM selector for a child element that is to be used
as label for this Component, set in aria-labelledby
attribute.
If the selector is by id
, the label element can be any existing element,
not necessarily a child of the main Component element.
ariaLabelledBy and ariaLabel config options are
mutually exclusive, and ariaLabelledBy
has the higher precedence.
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
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 cfg-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
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
This config is intended mainly for non-cfg-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 cfg-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
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
Deprecated since version 5.1.0
Use scrollable instead
true
to automatically show the component upon creation. This config option may only be used for
cfg-floating components or components that use autoRender.
Defaults to:
false
Available since: 2.3.0
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'
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
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#property-defaultBindProperty for the binding.
Defaults to:
null
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
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']
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.
Defaults to:
undefined
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
Sets the body style according to the passed 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.
this
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.
Note: is ignored when frame is set to true.
Defaults to:
true
An array of events that, when fired, should be bubbled to any parent container. See Ext.util.Observable#enableBubble.
Available since: 3.4.0
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
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#method-select.selectNode
: A selector that will be passed to Ext.dom.Element#method-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:
Note: childEl
s in the renderTpl
must be referenced in a data-ref attribute. Notice in the above example
that the "title" childEl
is set in the renderTpl
using
data-ref="title".
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:
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' } }
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 method-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
The action to take when the close header tool is clicked:
'method-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 method-show method.
'method-hide'
:
method-hide the window by setting visibility to hidden and applying negative offsets. The window will be available to be redisplayed via the method-show method.
Note: This behavior has changed! setting does affect the method-close method which will invoke the appropriate closeAction.
Defaults to:
'destroy'
Text to be announced by screen readers when the close Ext.panel.Tool is focused. Will also be set as the close tool's tooltip text.
Note: Applicable when the panel is closable: true
Defaults to:
'Close panel'
An optional extra CSS class that will be added to this component's Element. The value can be a string, a list of strings separated by spaces, or an array of strings. 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
true
to render the panel collapsed, false
to render it expanded.
Defaults to:
false
Returns the current collapsed state of the panel.
False when not collapsed, otherwise the value of collapseDirection.
Collapses or expands the panel.
collapsed : Boolean
true
to collapse the panel, false
to expand it.
A CSS class to add to the panel's element after it has been collapsed.
Defaults to:
'collapsed'
The direction to collapse the Panel when the toggle button is clicked.
Defaults to the cfg-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'
.
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
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.
Text to be announced by screen readers when collapse Ext.panel.Tool is focused. Will also be set as the collapse tool's tooltip text.
Note: Applicable when the panel is collapsible: true
Defaults to:
'Collapse panel'
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
Defaults to:
undefined
Returns an array of all columns which exist in the grid's View, visible or not. This goes down to the leaf column header level, and does not return grouped headers which contain sub headers.
It includes hidden headers even though they are not rendered. This is for collection of menu items for the column hide/show menu.
Headers which have a hidden ancestor have a hiddenAncestor: true
property
injected so that descendants are known to be hidden without interrogating that
header's ownerCt axis for a hidden ancestor.
See also Ext.grid.header.Container#getVisibleGridColumns
inResult : Object
Object
:columns An array of columns. Returns an empty array if no columns are found.
Defines the column width inside Ext.layout.container.Column.
The columnWidth property is always evaluated as a percentage and must be a decimal value greater than 0 and less than 1 (e.g., .25). See the description at the top of Ext.layout.container.Column for additional usage details when combining width and columnWidth configs within the layout.
CSS Class to be added to a components root level element to give distinction to it via styling.
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'
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
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
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
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.
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 event-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
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
Returns the Ext.app.ViewController instance associated with this component via the controller config or setController method.
Returns this component's ViewController or null if one was not configured
Sets the value of controller
controller : String / Object / Ext.app.ViewController
An object containing name/value pairs of custom editor type definitions that allow the grid to support additional types of editable fields. By default, the grid supports strongly-typed editing of strings, dates, numbers and booleans using built-in form editors, but any custom type can be supported and associated with a custom input control by specifying a custom editor. The name of the editor type should correspond with the name of the property that will use the editor. Example usage:
var grid = new Ext.grid.property.Grid({
// Custom editors for certain property names
customEditors: {
evtStart: Ext.create('Ext.form.TimeField', {selectOnFocus: true})
},
// Displayed name for property names in the source
propertyNames: {
evtStart: 'Start Time'
},
// Data object containing properties to edit
source: {
evtStart: '10:00 AM'
}
});
Deprecated
See sourceConfig editor
An object containing name/value pairs of custom renderer type definitions that allow the grid to support custom rendering of fields. By default, the grid supports strongly-typed rendering of strings, dates, numbers and booleans using built-in form editors, but any custom type can be supported and associated with the type of the value. The name of the renderer type should correspond with the name of the property that it will render. Example usage:
var grid = Ext.create('Ext.grid.property.Grid', {
customRenderers: {
Available: function(v){
if (v) {
return '<span style="color: green;">Yes</span>';
} else {
return '<span style="color: red;">No</span>';
}
}
},
source: {
Available: true
}
});
Deprecated
See sourceConfig renderer
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
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 cfg-floating
Used upon first show.
Defaults to:
"c-c"
Reference name of the component to act as the default button for this Panel. Default button is activated by pressing Enter key while focus is contained within the Panel's defaultButtonTarget.
The most obvious use for defaultButton
is submitting a form:
var loginWindow = new Ext.window.Window({
autoShow: true,
width: 300,
layout: 'form',
title: 'Enter login information',
referenceHolder: true,
defaultFocus: 'textfield',
defaultButton: 'okButton',
items: [{
xtype: 'textfield',
fieldLabel: 'User name'
}, {
xtype: 'textfield',
fieldLabel: 'Password'
}],
buttons: [{
reference: 'okButton',
text: 'Login',
handler: function() {
Ext.Msg.alert('Submit', 'Your login is being processed');
}
}]
});
Name of the element that will be the target of
defaultButton keydown listener. The default element is Panel body, which
means that pressing Enter key while focus is on docked items will not fire defaultButton
action.
If you want defaultButton
action to fire in docked items, set this config to "el"
.
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 } }
Specifies a child Component to receive focus when this Container's method-focus method is called. Should be a valid Ext.ComponentQuery selector.
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
Sets the value of defaultListenerScope
defaultListenerScope : Boolean
This option is a means of applying default settings to all added items whether added through the cfg-items config or via the method-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
scrollable: true
},
items: [
// default will not be applied here, panel1 will be scrollable: false
{
xtype: 'panel',
id: 'panel1',
scrollable: false
},
// this component will have scrollable: true
new Ext.panel.Panel({
id: 'panel2'
})
]
Available since: 2.3.0
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
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
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 method-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
true
to disable the component.
Defaults to:
false
Available since: 2.3.0
Enable or disable the component.
disabled : Boolean
true
to disable.
CSS class to add when the Component is disabled.
Defaults to:
'x-item-disabled'
The side of the Ext.panel.Panel where this component is to be docked when specified in the panel's dockedItems config.
Possible values are:
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)
dock : Object
The dock position.
this
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
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"]');
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.
The array of docked components meeting the specified criteria.
Specify as true to make a cfg-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();
NOTE: The private Ext.panel.DD class is used instead of ComponentDragger when simpleDrag is false (default). In this case you may pass a config for Ext.dd.DragSource.
See also dd.
Defaults to:
false
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.
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) gridIf 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
Text to be announced by screen readers when expand Ext.panel.Tool is focused. Will also be set as the expand tool's tooltip text.
Note: Applicable when the panel is collapsible: true
Defaults to:
'Expand panel'
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: 200
},
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
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.
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
Flex may be applied to child items of a box layout (Ext.layout.container.VBox or
Ext.layout.container.HBox). Each child item with a flex property will
fill space (horizontally in hbox
, vertically in vbox
) according to that item's
relative flex value compared to the sum of all items with a flex value specified.
Any child items that have either a flex
of 0
or undefined
will not be 'flexed' (the initial size will not be changed).
Sets the flex property of this component. Only applicable when this component is an item of a box layout
flex : Number
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
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 programmatically rendered will register themselves with the global Ext.WindowManager
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 method-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
CSS class that will be added to focused Component, and removed when Component blurs.
Defaults to:
'x-focus'
Specifies whether the floated component should be automatically focused when it is brought to the front.
Defaults to:
true
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.
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
True to apply a frame to the panel.
Note: frame: true
overrides border:false
Defaults to:
false
True to apply a frame to the panel panels header (if 'frame' is true).
Defaults to:
true
A numeric unicode character code to use as the icon. The default font-family
for glyphs can be set globally using
glyphFontFamily application
config or the Ext.setGlyphFontFamily() method.
It is initially set to 'Pictos'
.
The following shows how to set the glyph using the font icons provided in the SDK (assuming the font-family has been configured globally):
// assumes the glyphFontFamily is "Pictos"
glyph: 'x48' // the "home" icon (H character)
// assumes the glyphFontFamily is "Pictos"
glyph: 72 // The "home" icon (H character)
// assumes the glyphFontFamily is "Pictos"
glyph: 'H' // the "home" icon
Alternatively, this config option accepts a string with the charCode and
font-family separated by the @
symbol.
// using Font Awesome
glyph: 'xf015@FontAwesome' // the "home" icon
// using Pictos
glyph: 'H@Pictos' // the "home" icon
Depending on the theme you're using, you may need include the font icon packages in your application in order to use the icons included in the SDK. For more information see:
Defaults to:
null
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
...
});
To show no borders around grid headers, configure this as false
.
Defaults to:
`true`
Specify as 'top'
, 'bottom'
, 'left'
or 'right'
.
Defaults to:
'top'
Returns the value of headerPosition
'top' / 'bottom' / 'left' / 'right'
Sets the value of headerPosition
headerPosition : 'top' / 'bottom' / 'left' / 'right'
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.
Sets the height of the component. This method fires the resize event.
height : Number
The new height to set. This may be one of:
undefined
to leave the height unchanged.null
to clear the height.this
true
to hide the expand/collapse toggle button when collapsible == true
, false
to display it.
Defaults to:
false
By default, visibility of headers is managed automatically based upon whether there is textual content to display. This configuration is only necessary if you want to disable automatic header visibility management.
If no columns have a text config (for example in the case of a Ext.tree.Panel with no columns specified), and no columns have child columns then headers are hidden.
If this status changes - if the column set ever goes from none having text, to one having text or vice versa), then the visibility of headers will be recalculated.
Configure as true
to hide column headers. Configure as false
to show
column headers even if none of them have text.
Defaults to:
null
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
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 event-render event is fired. This content is inserted into the body before any configured contentEl is appended.
Defaults to:
''
Available since: 3.4.0
Update the content area of a component.
Available since: 3.4.0
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. Causes embedded script tags to be executed. Inline source will be executed
with this Component as the scope (this
reference).
Defaults to: false
callback : Function (optional)
Only legitimate when using the html
configuration.
Callback to execute when scripts have finished loading.
scriptScope : Object (optional)
The scope (this
reference) in which to
execute inline script elements content. Scripts with a src
attribute cannot
be executed with this scope.
Defaults to: `this`
Path to an image to use as an icon.
For instructions on how you can use icon fonts including those distributed in the SDK see iconCls.
Defaults to:
null
The side of the title to render the icon.
Defaults to:
'left'
Returns the value of iconAlign
'top' / 'right' / 'bottom' / 'left'
Sets the value of iconAlign
iconAlign : 'top' / 'right' / 'bottom' / 'left'
One or more space separated CSS classes to be applied to the icon element. The CSS rule(s) applied should specify a background image to be used as the icon.
An example of specifying a custom icon class would be something like:
// specify the property in the config for the class:
iconCls: 'my-home-icon'
// css rule specifying the background image to be used as the icon image:
.my-home-icon {
background-image: url(../images/my-home-icon.gif) !important;
}
In addition to specifying your own classes, you can use the font icons provided in the SDK using the following syntax:
// using Font Awesome
iconCls: 'x-fa fa-home'
// using Pictos
iconCls: 'pictos pictos-home'
Depending on the theme you're using, you may need include the font icon packages in your application in order to use the icons included in the SDK. For more information see:
Defaults to:
null
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
True to automatically infer the type based on the initial value passed for each field. This ensures the editor remains the correct type even if the value is blanked and becomes empty.
Defaults to:
true
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 itemId
's or id's. Since itemId
's 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({ //
height: 300,
renderTo: document.body,
layout: 'auto',
items: [{
itemId: 'p1',
title: 'Panel 1',
height: 150
},{
itemId: 'p2',
title: 'Panel 2',
height: 150
}]
});
p1 = c.getComponent('p1'); // not the same as Ext.getCmp()
console.log(p1);
p2 = p1.ownerCt.getComponent('p2'); // reference via a sibling
console.log(p2);
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
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
cfg-defaultType for the Container is used, which by default is usually panel
.
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 method-updateLayout call.
Do not specify contentEl or
html with items
.
Defaults to:
undefined
Available since: 2.3.0
An object containing handlers for keyboard events. The property names of this object are the key name and any modifiers. The values of the properties are the descriptors of how to handle each event.
The handler descriptor can be simply the handler function (either the literal function or the method name), or it can be an object with these properties:
handler
: The function or its name to call to handle the event.scope
: The this pointer context (can be "this" or "controller").event
: An optional override of the key event to which to listen.Important: Calls to setKeyMap
do not replace the entire keyMap
but
instead update the provided mappings. That is, unless null
is passed as the
value of the keyMap
which will clear the keyMap
of all entries.
Defaults to:
null
scope : String
The default scope to apply to key handlers
which do not specify a scope. This is processed the same way as the scope of
cfg-listeners. It defaults to the "controller"
, but using 'this'
means that an instance method will be used.
Enables or disables processing keys in the keyMap
. This value starts as
null
and if it is null
when initKeyMap
is called, it will automatically
be set to true
. Since initKeyMap
is called by Ext.Component
at the
proper time, this is not something application code normally handles.
Defaults to:
null
The name of the member that should be used to listen for keydown/keypress events. This is intended to be controlled at the class level not per instance.
Defaults to:
'el'
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 cfg-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:
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.
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.
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
Returns the Ext.layout.container.Container instance currently associated with this Container. If a layout has not been instantiated yet, that is done first
The layout
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.
configuration : Object
object for the layout
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
TableViews are buffer rendered in 5.x and above 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
Components that achieve their internal layout results using solely CSS with no JS
intervention must set this to true. This allows the component to opt out of the
layout run when used inside certain container layouts such as Ext.layout.container.Form and Ext.layout.container.Auto
resulting in a performance gain. The following components currently use liquid
layout (liquidLayout: true
):
It is important to keep in mind that components using liquidLayout do not fire the following events:
In addition liquidLayout components do not call the following template methods:
Any component that needs to fire these events or to have these methods called during
its life cycle needs to set liquidLayout
to false
. The following example
demonstrates how to enable the resize event for a
Ext.form.field.TextArea:
Use caution when setting liquidLayout
to false
as it carries a performance penalty
since it means the layout system must perform expensive DOM reads to determine the
Component's size.
Defaults to:
false
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.View's 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'); }
}
}
});
An alias for addListener. In versions prior to 5.1, listeners had a generated setter which could be called to add listeners. In 5.1 the listeners config is not processed using the config system and has no generated setter, so this method is provided for backward compatibility. The preferred way of adding listeners is to use the on method.
listeners : Object
The listeners
True to drag the component itself. Else a lightweight version of the component will be shown (using the component's ghost() method).
Note: This config is only relevant when used with dragging implemented via Ext.util.ComponentDragger.
Defaults to:
false
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()
});
Gets the Ext.ComponentLoader for this Component.
The loader instance, null if it doesn't exist.
A view configuration to be applied to the locked side of the grid. Any conflicting configurations between lockedViewConfig and viewConfig will be overwritten by the lockedViewConfig.
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
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).
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"
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
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
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
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
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
True to make the floated component modal and mask everything behind it when displayed, false to display it without restricting access to other UI elements.
Defaults to:
false
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.
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
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.
Specify the width for the name column. The value column will take any remaining space.
Defaults to:
115
The name of the field from the property store to use as the property field name. This may be useful if you do not configure the property Grid from an object, but use your own store configuration.
Defaults to:
'name'
A view configuration to be applied to the normal/unlocked side of the grid. Any conflicting configurations between normalViewConfig and viewConfig will be overwritten by the normalViewConfig.
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
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
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.
Deprecated since version 5.1.0
Use scrollable instead
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.
Deprecated since version 5.1.0
Use scrollable instead
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.
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).
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.
The mode for hiding collapsed panels when using collapseMode "placeholder".
Defaults to:
Ext.Element.VISIBILITY
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
Defaults to:
false
Deprecated since version 4.1.0
Use header instead.
Prevent a Header from being created and shown.
An object containing custom property name/display name pairs. If specified, the display name will be shown in the name column instead of the property name.
Deprecated
See sourceConfig displayName
One or more names of config properties that this component should publish to its ViewModel. Generally speaking, only properties defined in a class config block (including ancestor config blocks and mixins) are eligible for publishing to the viewModel. Some components override this and publish their most useful configs by default.
Note: We'll discuss publishing properties not found in the config block below.
Values determined to be invalid by component (often form fields and model validations) will not be published to the ViewModel.
This config uses the cfg-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 cfg-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
}
}
In some cases, users may want to publish a property to the viewModel that is not found in a class config block. In these situations, you may utilize publishState if the property has a setter method. Let's use setFieldLabel as an example:
setFieldLabel: function(fieldLabel) {
this.callParent(arguments);
this.publishState('fieldLabel', fieldLabel);
}
With the above chunk of code, fieldLabel may now be published to the viewModel.
Defaults to:
null
Available since: 5.0.0
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
The focused cell, model or index. Typically used with binding.
If bound to a record (such as a selection), the first cell will be focused.
Defaults to:
null
Sets the value of record
record : Ext.grid.CellContext / Ext.data.Model / Number
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
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.
Defaults to:
false
Sets the value of referenceHolder
referenceHolder : Boolean
Defines the region inside Ext.layout.container.Border.
Possible values:
region: "center"
in every border layout.Defaults to:
undefined
Returns a region object that defines the area of this element.
contentBox : Boolean (optional)
If true a box for the content of the element is returned.
A Region containing "top, left, bottom, right" properties.
renderConfig wraps configs that do not get applied until after the component is rendered. Unlike normal config system properties, renderConfigs use a special setter method to store values on the instance instead of running the apply and update methods if it is called before the component is rendered. Then, after the component has been rendered, these values are processed by the normal apply and update method for the config.
This means that calling the get method for the config prior to render will return whatever raw value has been set, while calling the getter after render will return the value after processing by the config's apply method. If this distinction needs to be made, it is the caller's responsibility to check for the rendered state and handle such intermediate config values.
The data used by cfg-renderTpl in addition to the following property values of the component:
See renderSelectors and cfg-childEls for usage examples.
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 cfg-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 cfg-childEls instead.
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.Container's layout manager to render and manage its child items.
When using this config, a call to render()
is not required.
See also: method-render.
Available since: 2.3.0
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
classes with complex DOM structures 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 cfg-childEls options.
Defaults to:
'{%this.renderContent(out,values)%}'
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
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
A valid Ext.resizer.Resizer handles config string. Only applies when resizable = true.
Defaults to:
'all'
The type or a config object specifying the type of the ViewModel to instantiate when creating ViewModels for records to which Ext.grid.column.Widget, and widgets in a Ext.grid.plugin.RowWidget row bind.
A buffer to be applied if many state events are fired within a short period.
Defaults to:
100
Scrollers configuration. Valid values are 'both', 'horizontal' or 'vertical'. True implies 'both'. False implies 'none'.
Deprecated since version 5.1.0
Use scrollable instead
Configuration options to make this Component scrollable. Acceptable values are:
true
to enable auto scrolling.false
(or null
) to disable scrolling - this is the default.x
or horizontal
to enable horizontal scrolling onlyy
or vertical
to enable vertical scrolling onlyAlso accepts a configuration object for a Ext.scroll.Scroller
if
if advanced configuration is needed.
The getter for this config returns the Ext.scroll.Scroller instance. You can use the Scroller API to read or manipulate the scroll position:
// scrolls the component to 5 on the x axis and 10 on the y axis
component.getScrollable().scrollTo(5, 10);
Defaults to:
null
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
The selected model. Typically used with binding.
Defaults to:
null
Returns the grid's selection. See Ext.selection.Model#getSelection
.
Returns an array of the currently selected records.
The selected records
A Ext.selection.Model instance or config object, or the selection model class's alias string.
In latter case its type
property determines to which type of selection model this config is applied.
Defaults to:
rowmodel
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.
Deprecated since version 5.1.0
Use the selModels `type` property. Or, if no other
configs are required, use the string form of selModel.
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
Sets the value of session
session : Boolean / Object / Ext.data.Session
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'
true
to enable an iframe shim for this Component to keep
windowed objects from showing through.
The possible values for shrinkWrap are:
false
): Neither width nor height depend on content.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.
By default, when a panel is configured to shrink wrap in a given dimension, only the panel's "content" (items and html content inside the panel body) contributes to its size, and the content of docked items is ignored. Optionally you can use the shrinkWrapDock config to allow docked items to contribute to the panel's size as well. For example, if shrinkWrap and shrinkWrapDock are both set to true, the width of the panel would be the width of the panel's content and the panel's header text.
Defaults to:
2
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.Panel#shrinkWrap for an explanation of the configuration options.
Defaults to:
false
When cfg-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
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.
False to disable column sorting via clicking the header and via the Sorting menu items.
Defaults to:
true
A data object to use as the data source of the grid (see setSource for details).
Gets the source data object containing the property data. See setSource for details regarding the format of the data object.
The data object.
Sets the source data object containing the property data. The data object can contain one or more name/value pairs representing all of the properties of an object to display in the grid, and this data will automatically be loaded into the grid's store. The values should be supplied in the proper data type if needed, otherwise string type will be assumed. If the grid already contains data, this method will replace any existing data. See also the source config value. Example usage:
grid.setSource({
"(name)": "My Object",
"Created": Ext.Date.parse('10/15/2006', 'm/d/Y'), // date type
"Available": false, // boolean type
"Version": .01, // decimal type
"Description": "A test object"
});
source : Object
The data object.
sourceConfig : Object (optional)
A new object. If this argument is not passed
the current configuration will be re-used. To reset the config, pass null
or an empty object literal.
This option allows various configurations to be set for each field in the property grid. None of these configurations are required
A custom name to appear as label for this field. If specified, the display name will be shown in the name column instead of the property name. Example usage:
new Ext.grid.property.Grid({
source: {
clientIsAvailable: true
},
sourceConfig: {
clientIsAvailable: {
// Custom name different to the field
displayName: 'Available'
}
}
});
A function used to transform the underlying value before it is displayed in the grid. By default, the grid supports strongly-typed rendering of strings, dates, numbers and booleans using built-in form editors, but any custom type can be supported and associated with the type of the value. Example usage:
new Ext.grid.property.Grid({
source: {
clientIsAvailable: true
},
sourceConfig: {
clientIsAvailable: {
// Custom renderer to change the color based on the value
renderer: function(v){
var color = v ? 'green' : 'red';
return '<span style="color: ' + color + ';">' + v + '</span>';
}
}
}
});
Used to explicitly specify the editor type for a particular value. By default, the type is automatically inferred from the value. See inferTypes. Accepted values are:
For more advanced control an editor configuration can be passed (see the next section). Example usage:
new Ext.grid.property.Grid({
source: {
attending: null
},
sourceConfig: {
attending: {
// Force the type to be a numberfield, a null value would otherwise default to a textfield
type: 'number'
}
}
});
Allows the grid to support additional types of editable fields. By default, the grid supports strongly-typed editing of strings, dates, numbers and booleans using built-in form editors, but any custom type can be supported and associated with a custom input control by specifying a custom editor. Example usage
new Ext.grid.property.Grid({
// Data object containing properties to edit
source: {
evtStart: '10:00 AM'
},
sourceConfig: {
evtStart: {
editor: Ext.create('Ext.form.field.Time', {selectOnFocus: true}),
displayName: 'Start Time'
}
}
});
Configure as true
to place a resizing Ext.resizer.Splitter between the locked
and unlocked columns. May also be a configuration object for the Splitter.
Defaults to:
false
An array of events that, when fired, should trigger this object to
save its state. stateEvents
defaults to the stateEvents
associated with the
component you are using. Any events you statically set will be appended to that list.
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.
By default the following stateEvents are added:
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. In some simple cases,
passing an object for the stateful
config may suffice. If an object is
provided, the properties of that object are used to include or exclude stateful
properties returned by getState
. For example:
stateful: {
height: false, // never persist the height
width: true // always persist the width
}
The above is roughly equivalent to the following:
getState: function () {
var state = this.callParent();
delete state.height;
state.width = this.width;
return state;
}
Defaults to:
false
The unique id for this object to use for state management purposes.
See stateful for an explanation of saving and restoring state.
Gets the state id for this object.
The 'stateId' or the implicit 'id' specified by component configuration.
Returns the store associated with this Panel.
The store
A convenience method that fires event-reconfigure with the store param. To set the store AND change columns, use the reconfigure method.
store : Ext.data.Store (optional)
The new store.
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
Sets the style for this Component's primary element.
Styles should be a valid DOM element style property. Valid style property names (along with the supported CSS version for each)
var name = Ext.create({
xtype: 'component',
renderTo: Ext.getBody(),
html: 'Phineas Flynn'
});
// two-param syntax
name.setStyle('color', 'white');
// single-param syntax
name.setStyle({
fontWeight: 'bold',
backgroundColor: 'gray',
padding: '10px'
});
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.
this
The xtype of the subgrid to specify. If this is not specified lockable will determine the subgrid xtype to create by the following rule. Use the superclasses xtype if the superclass is NOT tablepanel, otherwise use the xtype itself.
If true, suspend calls to updateLayout. Useful when batching multiple adds to a container and not passing them as multiple arguments or an array.
Defaults to:
false
Synchronize rowHeight between the normal and locked grid view. This is turned on by default. If your grid is guaranteed to have rows of all the same height, you should set this to false to optimize performance.
Defaults to:
true
When set to true
, two elements are added to the container's element. These are the
tabGuardBeforeEl
and tabGuardAfterEl
.
Available since: 6.0.0
DOM tabIndex attribute for this Focusable's focusEl.
Return the actual tabIndex for this Focusable.
tabIndex attribute value
Set the tabIndex property for this Focusable. If the focusEl is available, set tabIndex attribute on it, too.
newTabIndex : Number
new tabIndex to set
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
The title text or config object for the Ext.panel.Title component.
When a title
is specified, the Ext.panel.Header will
automatically be created and displayed unless header is set to false
.
Defaults to:
null
The alignment of the title text within the available space between the icon and the tools.
Defaults to:
'left'
Returns the value of titleAlign
'left' / 'center' / 'right'
Sets the value of titleAlign
titleAlign : 'left' / 'center' / 'right'
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.
Defaults to:
undefined
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 header0
- no rotation1
- rotate 90deg clockwise2
- rotate 90deg counter-clockwiseThe default behavior of this config depends on the dock position of the header:
'top'
or 'bottom'
- 0
'right'
- 1
'left'
- 1
Defaults to:
'default'
Returns the value of titleRotation
'default' / 0 / 1 / 2
Sets the value of titleRotation
titleRotation : 'default' / 0 / 1 / 2
True to automatically call toFront when the method-show method is called on an already visible, floating component.
Defaults to:
true
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.
Emulates the behavior of the CSS href="https://www.w3.org/TR/pointerevents/#the-touch-action-css-property" class="external-link" target="_blank">https://www.w3.org/TR/pointerevents/#the-touch-action-css-property touch-action property in a cross-browser compatible manner.
Keys in this object are touch action names, and values are false
to disable
a touch action or true
to enable it. Accepted keys are:
panX
panY
pinchZoom
doubleTapZoom
All touch actions are enabled (true
) by default, so it is usually only necessary
to specify which touch actions to disable. For example, the following disables
only horizontal scrolling and pinch-to-zoom on the component's main element:
touchAction: {
panX: false,
pinchZoom: false
}
Touch actions can be specified on child elements using the child element name, for example:
// disables horizontal scrolling on the main element, and double-tap-zoom
// on the child element named "body"
touchAction: {
panY: false
body: {
doubleTapZoom: false
}
}
The primary motivation for setting the touch-action of an element is to prevent the browser's default handling of a gesture such as pinch-to-zoom, or drag-to-scroll, so that the application can implement its own handling of that gesture on the element. Suppose, for example, a component has a custom drag handler on its element and wishes to prevent horizontal scrolling of its container while it is being dragged:
Ext.create('Ext.Component', {
touchAction: {
panX: false
},
listeners: {
drag: function(e) {
// implement drag logic
}
}
});
Defaults to:
null
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
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
TableViews are buffer rendered in 5.x and above 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
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
A UI style for a component.
Defaults to:
'default'
An array of of classNames
which are currently applied to this component.
Defaults to:
[]
One or more CSS classes to add to the component's primary element. This config is intended solely for use by the component instantiator (the "user"), not by derived classes.
For example:
items: [{
xtype: 'button',
userCls: 'my-button'
...
}]
Defaults to:
null
The name of the field from the property store to use as the value field name. This may be useful if you do not configure the property Grid from an object, but use your own store configuration.
Defaults to:
'value'
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.
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).
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.
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
Sets the value of viewModel
viewModel : String / Object / Ext.app.ViewModel
An xtype of view to use. This is automatically set to 'tableview' by Ext.grid.Panel and to 'treeview' by Ext.tree.Panel.
Defaults to:
null
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.Panel's 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
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.
Sets the width of the component. This method fires the resize event.
width : Number
The new width to set. This may be one of:
undefined
to leave the width unchanged.null
to clear the width.this
Note: Only applies to Ext.Component derived classes when used as a config in Ext.define.
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
The value true
causes config
values to be stored on instances using a
property name prefixed with an underscore ("_") character. A value of false
stores config
values as properties using their exact name (no prefix).
Defaults to:
true
Available since: 5.0.0
The value true
instructs the initConfig
method to only honor values for
properties declared in the config
block of a class. When false
, properties
that are not declared in a config
block will be placed on the instance.
Defaults to:
true
Available since: 5.0.0
Matches options property names within a listeners specification object - property names which are never used as event names.
Defaults to:
{ scope: 1, delay: 1, buffer: 1, onFrame: 1, single: 1, args: 1, destroyable: 1, priority: 1, order: 1 }
We don't want the base destructor to clear the prototype because our destroyObservable handler must be called the very last. It will take care of the prototype after completing Observable destruction sequence.
Defaults to:
true
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
This property holds one of the following values during the render process:
beforeRender
process and is about to
call onRender
. This is when rendering
is set to true
.onRender
. This is when rendered
is set
to true
.Defaults to:
0
Available since: 5.0.0
An array of objects which register themselves with a grid panel using registerActionable which are consulted upon entry into actionable mode.
These must implement the following methods:
true
if it
ascertains that the cell is actionable, and that it now contains focusable elements which may be tabbed to.Defaults to:
topGrid ? topGrid.actionables : []
The name of the Component property that holds a reference to the Element that serves as that Component's ARIA element. This property will be replaced with the actual Element reference after rendering.
Most of the simple Components will have their main element as ariaEl.
Defaults to:
'el'
Available since: 6.0.0
Instance specific ARIA attributes to render into Component's ariaEl. This object is only used during rendering, and is discarded afterwards.
ARIA role for this Component, defaults to no role. With no role, no other ARIA attributes are set.
true
indicates an id
was auto-generated rather than provided by configuration.
Defaults to:
false
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.
Setting this property to false
will prevent nulling object references
on a Class instance after destruction. Setting this to "async"
will delay
the clearing for approx 50ms.
Defaults to:
true
Available since: 6.2.0
Setting this property to true
will result in setting the object's
prototype to null
after the destruction sequence is fully completed.
After that, most attempts at calling methods on the object instance
will result in "method not defined" exception. This can be very helpful
with tracking down otherwise hard to find bugs like runaway Ajax requests,
timed functions not cleared on destruction, etc.
Note that this option can only work in browsers that support Object.setPrototypeOf
method, and is only available in debugging mode.
Defaults to:
false
Available since: 6.2.0
The number of component layout calls made on this object.
Defaults to:
0
The name of the padding property that is used by the layout to manage padding. See managePadding
Defaults to:
'bodyPadding'
Only present if this Panel has been configured with cfg-draggable true
.
If this Panel is configured cfg-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.
By default, this property in a cfg-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 also cfg-draggable.
Defaults to:
new Ext.panel.DD(me, Ext.isBoolean(me.draggable) ? null : me.draggable)
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
This property is set to true
after the destroy
method is called.
Defaults to:
false
Values to decide which side of the body element docked items must go This overides any weight. A left/top will always sort before a right/bottom regardless of any weight value. Weights sort at either side of the "body" dividing point.
Defaults to:
{ top: -1, left: -1, right: 1, bottom: 1 }
Initial suspended call count. Incremented when suspendEvents is called, decremented when resumeEvents is called.
Defaults to:
0
The MixedCollection containing all the floating child items of this container.
Will be undefined
if there are no floating child items.
Available since: 4.1.0
Only present for cfg-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 programmatically rendered will not have a floatParent
property.
See cfg-floating and zIndexManager
true
for interactive Components, false
for static Components.
For Containers, this property reflects interactiveness of the
Container itself, not its children. See isFocusable.
Note: Plain components are static, so not focusable.
Defaults to:
false
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
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
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);
}
The config object passed to the constructor during Component creation.
Defaults to:
config
true
in this class to identify an object as an instantiated Component, or subclass thereof.
Defaults to:
true
This property is set to true
during the call to initConfig
.
Defaults to:
false
Available since: 5.0.0
true
in this class to identify an object as an instantiated Container, or subclass thereof.
Defaults to:
true
This property is set to true
if this instance is the first of its class.
Defaults to:
false
Available since: 5.0.0
This value is true
and is used to identify plain objects from instances of
a defined class.
Defaults to:
true
true
in this class to identify an object as an instantiated Observable, or subclass thereof.
Defaults to:
true
true
in this class to identify an object as an instantiated Panel, or subclass thereof.
Defaults to:
true
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
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.
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
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
Indicates whether or not the component has been rendered.
Defaults to:
false
Available since: 1.1.0
Used to determine where to go down to find views this is here to support locking.
Defaults to:
true
An object property which provides unified information as to which dimensions are scrollable based upon the scrollable 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. Use scrollable if you need to access these flags.
This object has the following properties:
Defaults to:
{ auto: { // x:auto, y:auto auto: { overflowX: 'auto', overflowY: 'auto', x: true, y: true, both: true }, // x:auto, y:false 'false': { overflowX: 'auto', overflowY: 'hidden', x: true, y: false, both: false }, // x:auto, y:scroll scroll: { overflowX: 'auto', overflowY: 'scroll', x: true, y: true, both: true } }, 'false': { // x:false, y:auto auto: { overflowX: 'hidden', overflowY: 'auto', x: false, y: true, both: false }, // x:false, y:false 'false': { overflowX: 'hidden', overflowY: 'hidden', x: false, y: false, both: false }, // x:false, y:scroll scroll: { overflowX: 'hidden', overflowY: 'scroll', x: false, y: true, both: false } }, scroll: { // x:scroll, y:auto auto: { overflowX: 'scroll', overflowY: 'auto', x: true, y: true, both: true }, // x:scroll, y:false 'false': { overflowX: 'scroll', overflowY: 'hidden', x: true, y: false, both: false }, // x:scroll, y:scroll scroll: { overflowX: 'scroll', overflowY: 'scroll', x: true, y: true, both: true } }, none: { overflowX: '', overflowY: '', x: false, y: false, both: false } }
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 ''
.
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
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
This element reference is generated when tabGuard
is true
. This element
is generated after all dockedItems
in the DOM.
Available since: 6.0.0
The tabIndex attribute value to assign
to the "after" tab guard element. Default is undefined
for automatic detection
from the DOM.
Available since: 6.2.0
This element reference is generated when tabGuard
is true
. This element
is generated before all dockedItems
in the DOM.
Available since: 6.0.0
The tabIndex attribute value to assign
to the "before" tab guard element. Default is undefined
for automatic detection
from the DOM.
Available since: 6.2.0
Read only object containing property names for tab guard elements, keyed by position.
Defaults to:
{ before: 'tabGuardBeforeEl', after: 'tabGuardAfterEl' }
Available since: 6.2.0
This template is used to generate the tabGuard
elements. It is used once per
element (see tabGuardBeforeEl
and tabGuardAfterEl
).
Defaults to:
// We use span instead of div because of IE bug/misfeature: it will focus // block elements upon clicking or calling node.focus() regardless of // tabIndex attribute. It doesn't do that with inline elements, hence span. '<span id="{id}-{tabGuardEl}" data-ref="{tabGuardEl}" aria-hidden="true"' + ' class="' + Ext.baseCSSPrefix + 'tab-guard ' + Ext.baseCSSPrefix + 'tab-guard-{tabGuardPosition}"' + ' style="width:0px;height:0px;">' + '</span>'
Available since: 6.0.0
Regular expression used for validating reference
values.
Defaults to:
/^[a-z_][a-z0-9_]*$/i
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 that are added to a Container, the ZIndexManager is acquired from the first ancestor Container found that is floating. If no floating ancestor is found, the global Ext.WindowManager is used.
Only present for Ext.Component#cfg-floating Components which were inserted as child items of Containers, and which have a floating Container in their containment ancestry.
For Ext.Component#cfg-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 programmatically 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.
Adds declarative listeners as nested arrays of listener objects.
listeners : Array
true
if any listeners were added
Adds Ext.Component(s) to this Container.
defaults
for details).event-add
event after the component has been added.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 Ext.toolbar.Toolbar({
renderTo: document.body
}); // toolbar is rendered
// add multiple items.
// default type for Toolbar is 'button')
tb.add([{text:'Button 1'}, {text:'Button 2'}]);
To inject components between existing ones, use the insert method.
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
component : Ext.Component[]/Object[]/Ext.Component.../Object...
Either one or more Components to add or an Array of Components to add.
See cfg-items
for additional information.
The Components that were added.
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
property : String
The name of the config property.
Adds a CSS class to the body element. If not rendered, the class will be added when the panel is rendered.
cls : String/String[]
The class to add
this
Add a childEl specific to this instance. This must be called before render.
Available since: 6.0.0
childEl : Object
Adds a CSS class to the top level element representing this component.
Available since: 2.3.0
cls : String/String[]
The CSS class name to add.
Returns the Component to allow method chaining.
Deprecated since version 4.1
Use addCls instead.
Adds a CSS class to the top level element representing this component.
cls : String/String[]
The CSS class name to add.
Returns the Component to allow method chaining.
Adds a cls
to the uiCls
array, which will also call addUIClsToElement and adds to all elements of this
component.
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).
Adds a listeners with the "delegate" event option. Users should not invoke this method directly. Use the "delegate" event option of addListener instead.
eventName : Object
fn : Object
scope : Object
options : Object
order : Object
caller : Object
manager : Object
This method applies a versioned, deprecation declaration to this class. This
is typically called by the deprecated
config.
deprecations : Object
Adds docked item(s) to the container.
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
The added components.
The on method is shorthand for addListener.
Appends an event handler to this object. For example:
myGridPanel.on("itemclick", this.onItemClick, this);
The method also allows for a single argument to be passed which is a config object containing properties which specify multiple events. For example:
myGridPanel.on({
cellclick: this.onCellClick,
select: this.onSelect,
viewready: this.onViewReady,
scope: this // Important. Ensure "this" is correct during handler execution
});
One can also specify options for each event handler separately:
myGridPanel.on({
cellclick: {fn: this.onCellClick, scope: this, single: true},
viewready: {fn: panel.onViewReady, scope: panel}
});
Names of methods in a specified scope may also be used:
myGridPanel.on({
cellclick: {fn: 'onCellClick', scope: this, single: true},
viewready: {fn: 'onViewReady', scope: panel}
});
eventName : String/Object
The name of the event to listen for. May also be an object who's property names are event names.
fn : Function/String (optional)
The method the event invokes or the name of
the method within the specified scope
. Will be called with arguments
given to Ext.util.Observable#fireEvent plus the options
parameter described
below.
scope : Object (optional)
The scope (this
reference) in which the handler function is
executed. If omitted, defaults to the object which fired the event.
options : Object (optional)
An object containing handler configuration.
Note: The options object will also be passed as the last argument to every event handler.
This object may contain any of the following properties:
scope : Object
The scope (this
reference) in which the handler function is executed. If omitted,
defaults to the object which fired the event.
delay : Number
The number of milliseconds to delay the invocation of the handler after the event fires.
single : Boolean
True to add a handler to handle just the next firing of the event, and then remove itself.
buffer : Number
Causes the handler to be scheduled to run in an Ext.util.DelayedTask delayed by the specified number of milliseconds. If the event fires again within that time, the original handler is not invoked, but the new handler is scheduled in its place.
onFrame : Number
Causes the handler to be scheduled to run at the next animation frame event. If the event fires again before that time, the handler is not rescheduled - the handler will only be called once when the next animation frame is fired, with the last set of arguments passed.
target : Ext.util.Observable
Only call the handler if the event was fired on the target Observable, not if the event was bubbled up from a child Observable.
element : String
This option is only valid for listeners bound to Ext.Component. The name of a Component property which references an Ext.dom.Element to add a listener to.
This option is useful during Component construction to add DOM event listeners to elements of Ext.Component which will exist only after the Component is rendered.
For example, to add a click listener to a Panel's body:
var panel = new Ext.panel.Panel({
title: 'The title',
listeners: {
click: this.handlePanelClick,
element: 'body'
}
});
In order to remove listeners attached using the element, you'll need to reference the element itself as seen below.
panel.body.un(...)
delegate : String (optional)
A simple selector to filter the event target or look for a descendant of the target.
The "delegate" option is only available on Ext.dom.Element instances (or when attaching a listener to a Ext.dom.Element via a Component using the element option).
See the delegate example below.
capture : Boolean (optional)
When set to true
, the listener is fired in the capture phase of the event propagation
sequence, instead of the default bubble phase.
The capture
option is only available on Ext.dom.Element instances (or
when attaching a listener to a Ext.dom.Element via a Component using the
element option).
stopPropagation : Boolean (optional)
This option is only valid for listeners bound to Ext.dom.Element.
true
to call stopPropagation on the event object
before firing the handler.
preventDefault : Boolean (optional)
This option is only valid for listeners bound to Ext.dom.Element.
true
to call preventDefault on the event object
before firing the handler.
stopEvent : Boolean (optional)
This option is only valid for listeners bound to Ext.dom.Element.
true
to call stopEvent on the event object
before firing the handler.
args : Array (optional)
Optional set of arguments to pass to the handler function before the actual
fired event arguments. For example, if args
is set to ['foo', 42]
,
the event handler function will be called with an arguments list like this:
handler('foo', 42, <actual event arguments>...);
destroyable : Boolean (optional)
When specified as true
, the function returns a destroyable
object. An object
which implements the destroy
method which removes all listeners added in this call.
This syntax can be a helpful shortcut to using un; particularly when
removing multiple listeners. NOTE - not compatible when using the element
option. See un for the proper syntax for removing listeners added using the
element config.
Defaults to:
false
priority : Number (optional)
An optional numeric priority that determines the order in which event handlers are run. Event handlers with no priority will be run as if they had a priority of 0. Handlers with a higher priority will be prioritized to run sooner than those with a lower priority. Negative numbers can be used to set a priority lower than the default. Internally, the framework uses a range of 1000 or greater, and -1000 or lesser for handlers that are intended to run before or after all others, so it is recommended to stay within the range of -999 to 999 when setting the priority of event handlers in application-level code. A priority must be an integer to be valid. Fractional values are reserved for internal framework use.
order : String (optional)
A legacy option that is provided for backward compatibility.
It is recommended to use the priority
option instead. Available options are:
'before'
: equal to a priority of 100
'current'
: equal to a priority of 0
or default priority'after'
: equal to a priority of -100
Defaults to:
'current'
order : String (optional)
A shortcut for the order
event option. Provided for backward compatibility.
Please use the priority
event option instead.
Combining Options
Using the options argument, it is possible to combine different types of listeners:
A delayed, one-time listener.
myPanel.on('hide', this.handleClick, this, {
single: true,
delay: 100
});
Attaching multiple handlers in 1 call
The method also allows for a single argument to be passed which is a config object containing properties which specify multiple handlers and handler configs.
grid.on({
itemclick: 'onItemClick',
itemcontextmenu: grid.onItemContextmenu,
destroy: {
fn: function () {
// function called within the 'altCmp' scope instead of grid
},
scope: altCmp // unique scope for the destroy handler
},
scope: grid // default scope - provided for example clarity
});
Delegate
This is a configuration option that you can pass along when registering a handler for an event to assist with event delegation. By setting this configuration option to a simple selector, the target element will be filtered to look for a descendant of the target. For example:
var panel = Ext.create({
xtype: 'panel',
renderTo: document.body,
title: 'Delegate Handler Example',
frame: true,
height: 220,
width: 220,
html: '<h1 class="myTitle">BODY TITLE</h1>Body content'
});
// The click handler will only be called when the click occurs on the
// delegate: h1.myTitle ("h1" tag with class "myTitle")
panel.on({
click: function (e) {
console.log(e.getTarget().innerHTML);
},
element: 'body',
delegate: 'h1.myTitle'
});
Defaults to: 'current'
Only when the destroyable
option is specified.
A Destroyable
object. An object which implements the destroy
method which removes
all listeners added in this call. For example:
this.btnListeners = = myButton.on({
destroyable: true
mouseover: function() { console.log('mouseover'); },
mouseout: function() { console.log('mouseout'); },
click: function() { console.log('click'); }
});
And when those listeners need to be removed:
Ext.destroy(this.btnListeners);
or
this.btnListeners.destroy();
The addManagedListener method is used when some object (call it "A") is listening to an event on another observable object ("B") and you want to remove that listener from "B" when "A" is destroyed. This is not an issue when "B" is destroyed because all of its listeners will be removed at that time.
Example:
Ext.define('Foo', {
extend: 'Ext.Component',
initComponent: function () {
this.addManagedListener(MyApp.SomeGlobalSharedMenu, 'show', this.doSomething);
this.callParent();
}
});
As you can see, when an instance of Foo is destroyed, it ensures that the 'show'
listener on the menu (MyApp.SomeGlobalSharedMenu
) is also removed.
As of version 5.1 it is no longer necessary to use this method in most cases because
listeners are automatically managed if the scope object provided to
addListener is an Observable instance.
However, if the observable instance and scope are not the same object you
still need to use mon
or addManagedListener
if you want the listener to be
managed.
item : Ext.util.Observable/Ext.dom.Element
The item to which to add a listener/listeners.
ename : Object/String
The event name, or an object containing event name properties.
fn : Function/String (optional)
If the ename
parameter was an event
name, this is the handler function or the name of a method on the specified
scope
.
scope : Object (optional)
If the ename
parameter was an event name, this is the scope (this
reference)
in which the handler function is executed.
options : Object (optional)
If the ename
parameter was an event name, this is the
addListener options.
Only when the destroyable
option is specified.
A Destroyable
object. An object which implements the destroy
method which removes all listeners added in this call. For example:
this.btnListeners = myButton.mon({
destroyable: true
mouseover: function() { console.log('mouseover'); },
mouseout: function() { console.log('mouseout'); },
click: function() { console.log('click'); }
});
And when those listeners need to be removed:
Ext.destroy(this.btnListeners);
or
this.btnListeners.destroy();
Adds a plugin. May be called at any time in the component's life cycle.
plugin : Object
Save a property to the given state object if it is not its default or configured value.
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]
).
The state object or a new object if state was null
and the property
was saved.
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.
events : String/String[]
The event name or an array of event names.
Add tools to this panel
tools : Object[]/Ext.panel.Tool[]
The tools to add.
By default the tools will be accessible via keyboard, with the exception of automatically added collapse/expand and close tools.
If you implement keyboard equivalents of your tools' actions elsewhere and do not want the tools to participate in keyboard navigation, you can make them presentational instead:
panel.addTool({
type: 'mytool',
focusable: false,
ariaRole: 'presentation',
...
});
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.
Method which adds a specified UI + uiCls
to the components element. Can be overridden
to add the UI to more than just the component's element.
cls : Object
Called after the mixin is applied. We need to see if childEls
were used by
the targetClass
and apply them to the config.
targetClass : Ext.Class
Invoked after the Panel is Collapsed.
animated : Boolean
This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.
Called by the layout system after the Component has been laid out.
This method is not called on components that use cfg-liquidLayout, such as Ext.button.Button and Ext.form.field.Base.
width : Number
The width that was set
height : Number
The height that was set
oldWidth : Number/undefined
The old width, or undefined
if this was the initial layout.
oldHeight : Number/undefined
The old height, or undefined
if this was the initial layout.
This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.
Invoked after the Panel is Expanded.
animated : Boolean
This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.
Invoked after the Component has been hidden.
Gets passed the same callback
and scope
parameters that #onHide received.
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.
Invoked after the Container has laid out (and rendered if necessary) its child Components.
layout : Ext.layout.container.Container
This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.
Allows additional behavior after rendering is complete. At this stage, the Ext.Component 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 configured enable state.
Note: If the Component has a ViewController and the controller has an afterRender method it will be called passing the Component as the single param.
This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.
Template method called after a Component has been positioned.
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.
Invoked after the Component is shown (after #onShow is called).
Gets passed the same parameters as #show.
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.
Aligns the element with another element relative to the specified anchor points. If the other element is the document it aligns it to the viewport. The position parameter is optional, and can be specified in any one of the following formats:
t
/r
/b
/l
) followed by a percentage along that side. This describes a
point to align with a similar point in the target. So 't0-b0'
would be
the same as 'tl-bl'
, 'l0-r50'
would place the top left corner of this item
halfway down the right edge of the target item. This allows more flexibility
and also describes which two edges are considered adjacent when positioning an anchor.In addition to the anchor points, the position parameter also supports the "?" character. If "?" is passed at the end of the position string, the element will attempt to align as specified, but the position will be adjusted to constrain to the viewport if necessary. Note that the element being aligned might be swapped to align to a different position than that specified in order to enforce the viewport constraints. Following are all of the supported anchor positions:
Value Description
----- -----------------------------
tl The top left corner
t The center of the top edge
tr The top right corner
l The center of the left edge
c The center
r The center of the right edge
bl The bottom left corner
b The center of the bottom edge
br The bottom right corner
Example Usage:
// align el to other-el using the default positioning
// ("tl-bl", non-constrained)
el.alignTo("other-el");
// align the top left corner of el with the top right corner of other-el
// (constrained to viewport)
el.alignTo("other-el", "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]);
element : Ext.util.Positionable/HTMLElement/String
The Positionable, HTMLElement, or id of the element to align to.
position : String (optional)
The position to align to
Defaults to: "tl-bl?"
offsets : Number[] (optional)
Offset the positioning by [x, y] Element animation config object
this
Anchors an element to another element and realigns it when the window is resized.
anchorToEl : Ext.util.Positionable/HTMLElement/String
The Positionable, HTMLElement, or id of the element to align to.
alignment : String (optional)
The position to align to
Defaults to: "tl-bl?"
offsets : Number[] (optional)
Offset the positioning by [x, y]
animate : Boolean/Object (optional)
true for the default animation or a standard Element animation config object
monitorScroll : Boolean/Number (optional)
True to monitor body scroll and reposition. If this parameter is a number, it is used as the buffer delay in milliseconds.
Defaults to: 50
callback : Function (optional)
The function to call after the animation finishes
this
Performs custom animation on this object.
This method is applicable to both the Ext.Component class and the Ext.draw.sprite.Sprite class. It performs animated transitions of certain properties of this object over a specified timeline.
When animating a Component, the following properties may be specified in from
, to
, and keyframe
objects:
x
- The Component's page X position in pixels.
y
- The Component's page Y position in pixels
left
- The Component's left
value in pixels.
top
- The Component's top
value in pixels.
width
- The Component's width
value in pixels.
height
- The Component's height
value in pixels.
The following property may be set on the animation config root:
dynamic
- Specify as true to update the Component's layout (if it is a Container) at every frame of the animation.
Use sparingly as laying out on every intermediate size change is an expensive operation.For example, to animate a Window to a new size, ensuring that its internal layout and any shadow is correct:
myWindow = Ext.create('Ext.window.Window', {
title: 'Test Component animation',
width: 500,
height: 300,
layout: {
type: 'hbox',
align: 'stretch'
},
items: [{
title: 'Left: 33%',
margin: '5 0 5 5',
flex: 1
}, {
title: 'Left: 66%',
margin: '5 5 5 5',
flex: 2
}]
});
myWindow.show();
myWindow.header.el.on('click', function() {
myWindow.animate({
to: {
width: (myWindow.getWidth() == 500) ? 700 : 500,
height: (myWindow.getHeight() == 300) ? 400 : 300
}
});
});
For performance reasons, by default, the internal layout is only updated when the Window reaches its final "to"
size. If dynamic updating of the Window's child Components is required, then configure the animation with
dynamic: true
and the two child items will maintain their proportions during the animation.
config : Object
Configuration for Ext.fx.Anim. Note that the to config is required.
this
Available since: 5.0.0
binds : String/Object
currentBindings : Object
Sets references to elements inside the component. This applies renderSelectors as well as childEls.
Transforms a Session config to a proper instance.
Available since: 5.0.0
session : Object
Applies the state to the object. This should be overridden in subclasses to do more complex state operations. By default it applies the state properties onto the current object.
state : Object
The state
Transforms a ViewModel config to a proper instance.
Available since: 5.0.0
viewModel : String/Object/Ext.app.ViewModel
Sets references to elements inside the component.
el : Object
owner : Object
Sets up a component reference.
component : Ext.Component
The component to reference.
Template method to do any pre-blur processing.
e : Ext.event.Event
The event object
Invoked before the Component is destroyed. This method is deprecated, override onDestroy instead.
Deprecated since version 6.2.0
Please override onDestroy instead
This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.
Template method to do any pre-focus processing.
e : Ext.event.Event
The event object
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.
Allows additional behavior before rendering.
Note: If the Component has a ViewController and the controller has a beforeRender method it will be called passing the Component as the single param.
This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.
Template method called before a Component is positioned.
Ensures that the position is adjusted so that the Component is constrained if so configured.
x : Object
y : Object
animate : Object
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.
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 laid out Panel may be collapsed. It basically saves configs which need to be clobbered for the duration of the collapsed state.
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.
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.
this
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.
el : Object
Calculates x,y coordinates specified by the anchor position on the element, adding extraX and extraY values.
anchor : String (optional)
The specified anchor position. See alignTo for details on supported anchor positions.
Defaults to: 'tl'
extraX : Number (optional)
value to be added to the x coordinate
extraY : Number (optional)
value to be added to the y coordinate
size : Object (optional)
An object containing the size to use for calculating anchor position {width: (target width), height: (target height)} (defaults to the element's current size)
[x, y] An array containing the element's x and y coordinates
Override of Positionable method to calculate constrained position based upon possibly only constraining our header.
constrainTo : Object
proposedPosition : Object
local : Object
proposedSize : Object
Call the original method that was previously overridden with Ext.Base#override
Ext.define('My.Cat', {
constructor: function() {
alert("I'm a cat!");
}
});
My.Cat.override({
constructor: function() {
alert("I'm going to be a cat!");
this.callOverridden();
alert("Meeeeoooowwww");
}
});
var kitty = new My.Cat(); // alerts "I'm going to be a cat!"
// alerts "I'm a cat!"
// alerts "Meeeeoooowwww"
args : Array/Arguments
The arguments, either an array or the arguments
object
from the current method, for example: this.callOverridden(arguments)
Returns the result of calling the overridden method
Deprecated since version 4.1.0
Use method-callParent instead.
Call the "parent" method of the current method. That is the method previously overridden by derivation or by an override (see Ext#define).
Ext.define('My.Base', {
constructor: function (x) {
this.x = x;
},
statics: {
method: function (x) {
return x;
}
}
});
Ext.define('My.Derived', {
extend: 'My.Base',
constructor: function () {
this.callParent([21]);
}
});
var obj = new My.Derived();
alert(obj.x); // alerts 21
This can be used with an override as follows:
Ext.define('My.DerivedOverride', {
override: 'My.Derived',
constructor: function (x) {
this.callParent([x*2]); // calls original My.Derived constructor
}
});
var obj = new My.Derived();
alert(obj.x); // now alerts 42
This also works with static and private methods.
Ext.define('My.Derived2', {
extend: 'My.Base',
// privates: {
statics: {
method: function (x) {
return this.callParent([x*2]); // calls My.Base.method
}
}
});
alert(My.Base.method(10)); // alerts 10
alert(My.Derived2.method(10)); // alerts 20
Lastly, it also works with overridden static methods.
Ext.define('My.Derived2Override', {
override: 'My.Derived2',
// privates: {
statics: {
method: function (x) {
return this.callParent([x*2]); // calls My.Derived2.method
}
}
});
alert(My.Derived2.method(10); // now alerts 40
To override a method and replace it and also call the superclass method, use method-callSuper. This is often done to patch a method to fix a bug.
args : Array/Arguments
The arguments, either an array or the arguments
object
from the current method, for example: this.callParent(arguments)
Returns the result of calling the parent method
This method is used by an override to call the superclass method but bypass any overridden method. This is often done to "patch" a method that contains a bug but for whatever reason cannot be fixed directly.
Consider:
Ext.define('Ext.some.Class', {
method: function () {
console.log('Good');
}
});
Ext.define('Ext.some.DerivedClass', {
extend: 'Ext.some.Class',
method: function () {
console.log('Bad');
// ... logic but with a bug ...
this.callParent();
}
});
To patch the bug in Ext.some.DerivedClass.method
, the typical solution is to create an
override:
Ext.define('App.patches.DerivedClass', {
override: 'Ext.some.DerivedClass',
method: function () {
console.log('Fixed');
// ... logic but with bug fixed ...
this.callSuper();
}
});
The patch method cannot use method-callParent to call the superclass
method
since that would call the overridden method containing the bug. In
other words, the above patch would only produce "Fixed" then "Good" in the
console log, whereas, using callParent
would produce "Fixed" then "Bad"
then "Good".
args : Array/Arguments
The arguments, either an array or the arguments
object
from the current method, for example: this.callSuper(arguments)
Returns the result of calling the superclass method
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
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.
this
newValue : Object
oldValue : Object
constrainMethod : Object
styleName : Object
sizeName : Object
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.
selector : String/Ext.Component (optional)
An Ext.ComponentQuery selector. If no selector is specified, the first child will be returned.
The matching child Ext.Component (or null
if no match was found).
Clears all listeners that were attached using the "delegate" event option. Users should not invoke this method directly. It is called automatically as part of normal clearListeners processing.
Clear a component reference.
component : Ext.Component
The component to remove.
Invalidates the references collection. Typically called when removing a container from this container, since it's difficult to know what references got removed.
Clips this Component/Element to fit within the passed element's or component's view area
clippingEl : Ext.Component/Ext.dom.Element/Ext.util.Region
The Component or element or Region which should clip this element even if this element is outside the bounds of that region.
sides : Number
The sides to clip 1=top, 2=right, 4=bottom, 8=left.
This is to support components being clipped to their logical owner, such as a grid row editor when the row being edited scrolls out of sight. The editor should be clipped at the edge of the scrolling element.
Clips this floating element to the scrolling element in line with how its topmost anchoring element is clipped.
scroller : Object
Clone the current component using the original config values passed into this instance by default.
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.
clone The cloned copy of this component
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 method-destroy and method-hide methods.
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.
direction : String (optional)
The direction to collapse towards. Must be one of
Defaults to collapseDirection.
animate : Boolean/Number (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.
this
plugin : 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.
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.
Creates new Component.
config : Ext.dom.Element/String/Object
The configuration options may be specified as either:
Determines whether the passed Component is either an immediate child of this Container, or whether it is a descendant.
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
true
if the passed Component is contained at the specified level.
converts a collapsdDir into an anchor argument for Element.slideIn overridden in rtl mode to switch "l" and "r"
collapseDir : Object
This function converts a legacy alignment string such as 't-b' into a pair of edge, offset objects which describe the alignment points of the two regions.
So tl-br becomes {myEdge:'t', offset:0}, {otherEdge:'b', offset:100}
This not only allows more flexibility in the alignment possibilities, but it also resolves any ambiguity as to chich two edges are desired to be adjacent if an anchor pointer is required.
posSpec : Object
Creates an event handling function which re-fires the event from this object as the passed event name.
newName : String
The name under which to re-fire the passed parameters.
beginEnd : Array (optional)
The caller can specify on which indices to slice.
Destroys the Component. This method must not be overridden because Component
destruction sequence is conditional; if a beforedestroy
handler returns false
we must abort destruction.
To add extra functionality to destruction time in a subclass, override the doDestroy method.
Available since: 1.1.0
Disables all child input fields and buttons.
silent : Object
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.
out : Object
values : Object
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
This method needs to be called whenever you change something on this component that requires the Component's layout to be recalculated.
this
Deprecated since version 4.1
Use Ext.Component#method-updateLayout instead.
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.
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.
Perform the actual destruction sequence.
As a rule of thumb, subclasses should destroy their child Components and/or other objects before calling parent method. Any object references will be nulled after this method has finished, to prevent the possibility of memory leaks.
Available since: 6.2.0
Fires a delegated event. Users should not invoke this method directly. It is called automatically by the framework as needed (see the "delegate" event option of addListener for more details.
eventName : Object
args : Object
Continue to fire event.
eventName : String
args : Array
bubbles : Boolean
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.
selector : String/Ext.Component (optional)
An Ext.ComponentQuery selector or Ext.Component. If no selector is specified, the first child will be returned.
The matching descendant Ext.Component (or null
if no match was found).
Enables all child input fields and buttons.
silent : Object
Enables events fired by this Observable to bubble up an owner hierarchy by calling this.getBubbleTarget()
if
present. There is no implementation in the Observable base class.
This is commonly used by Ext.Components to bubble events to owner Containers. See Ext.Component#getBubbleTarget. The default implementation in Ext.Component returns the Component's immediate owner. But if a known target is required, this can be overridden to access the required target more quickly.
Example:
Ext.define('Ext.overrides.form.field.Base', {
override: 'Ext.form.field.Base',
// Add functionality to Field's initComponent to enable the change event to bubble
initComponent: function () {
this.callParent();
this.enableBubble('change');
}
});
var myForm = Ext.create('Ext.form.Panel', {
title: 'User Details',
items: [{
...
}],
listeners: {
change: function() {
// Title goes red if form has been modified.
myForm.header.setStyle('color', 'red');
}
}
});
eventNames : String/String[]
The event name to bubble, or an Array of event names.
Enables interaction with, and unmasks this grid's column headers after a call to {#disableColumnHeaders}.
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.
runLayout : Boolean (optional)
True to run the component's layout.
Defaults to: false
Scrolls the specified record into view.
record : Number/String/Ext.data.Model
The record, record id, or the zero-based position in the dataset to scroll to.
options : Object (optional)
An object containing options to modify the operation.
animate : Boolean (optional)
Pass true
to animate the row into view.
highlight : Boolean (optional)
Pass true
to highlight the row with a glow animation when it is in view.
select : Boolean (optional)
Pass as true
to select the specified row.
focus : Boolean (optional)
Pass as true
to focus the specified row.
callback : Function (optional)
A function to execute when the record is in view. This may be necessary if the first parameter is a record index and the view is backed by a Ext.data.BufferedStore which does not contain that record.
success : Boolean
true
if acquiring the record's view node was successful.
record : Ext.data.Model
If successful, the target record.
node : HTMLElement
If successful, the record's view node.
scope : Object (optional)
The scope (this
reference) in which the callback function is executed.
Expands the panel body so that it becomes visible. Fires the beforeexpand event which will cancel the expand action if it returns false.
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.
this
Finds an alternate Component to focus if this Component is disabled while focused, or focused while disabled, or otherwise unable to focus.
In both cases, focus must not be lost to document.body, but must move to an intuitively connectible Component, either a sibling, or uncle or nephew.
This is both for the convenience of keyboard users, and also for when focus is tracked within a Component tree such as for ComboBoxes and their dropdowns.
For example, a ComboBox with a PagingToolbar in is BoundList. If the "Next Page" button is hit, the LoadMask shows and focuses, the next page is the last page, so the "Next Page" button is disabled. When the LoadMask hides, it attempt to focus the last focused Component which is the disabled "Next Page" button. In this situation, focus should move to a sibling within the PagingToolbar.
A closely related focusable Component to which focus can move.
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.
fn : Function
The custom function to call with the arguments (container, this component).
The first Container for which the custom function returns true
Find a container above this component at any level by xtype or class
See also the up method.
xtype : String/Ext.Class
The xtype string for a component, or the class of the component directly
The first Container which matches the given xtype or class
Retrieves plugin from this component's collection by its ptype
.
var grid = Ext.create('Ext.grid.Panel', {
store: {
fields: ['name'],
data: [{
name: 'Scott Pilgrim'
}]
},
columns: [{
header: 'Name',
dataIndex: 'name',
editor: 'textfield',
flex: 1
}],
selType: 'cellmodel',
plugins: {
ptype: 'cellediting',
clicksToEdit: 1,
id: 'myplugin'
},
height: 200,
width: 400,
renderTo: Ext.getBody()
});
grid.findPlugin('cellediting'); // the cellediting plugin
Note: See also getPlugin
ptype : String
The Plugin's ptype
as specified by the class's
alias configuration.
plugin instance or undefined
if not found
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.
containerIdx : Number
The index into the Container items of this Component.
Fires the specified event with the passed parameters and executes a function (action).
By default, the action function will be executed after any "before" event handlers
(as specified using the order
option of
addListener
), but before any other
handlers are fired. This gives the "before" handlers an opportunity to
cancel the event by returning false
, and prevent the action function from
being called.
The action can also be configured to run after normal handlers, but before any "after"
handlers (as specified using the order
event option) by passing 'after'
as the order
parameter. This configuration gives any event handlers except
for "after" handlers the opportunity to cancel the event and prevent the action
function from being called.
eventName : String
The name of the event to fire.
args : Array
Arguments to pass to handlers and to the action function.
fn : Function
The action function.
scope : Object (optional)
The scope (this
reference) in which the handler function is
executed. If omitted, defaults to the object which fired the event.
options : Object (optional)
Event options for the action function. Accepts any
of the options of addListener
order : String (optional)
The order to call the action function relative
too the event handlers ('before'
or 'after'
). Note that this option is
simply used to sort the action function relative to the event handlers by "priority".
An order of 'before'
is equivalent to a priority of 99.5
, while an order of
'after'
is equivalent to a priority of -99.5
. See the priority
option
of addListener
for more details.
Defaults to: 'before'
Deprecated since version 5.5
Use fireEventedAction instead.
Fires the specified event with the passed parameters (minus the event name, plus the options
object passed
to addListener).
An event may be set to bubble up an Observable parent hierarchy (See Ext.Component#getBubbleTarget) by calling enableBubble.
eventName : String
The name of the event to fire.
args : Object...
Variable number of parameters are passed to handlers.
returns false if any of the handlers return false otherwise it returns true.
Fires the specified event with the passed parameter list.
An event may be set to bubble up an Observable parent hierarchy (See Ext.Component#getBubbleTarget) by calling enableBubble.
eventName : String
The name of the event to fire.
args : Object[]
An array of parameters which are passed to handlers.
returns false if any of the handlers return false otherwise it returns true.
Fires the specified event with the passed parameters and executes a function (action). Evented Actions will automatically dispatch a 'before' event passing. This event will be given a special controller that allows for pausing/resuming of the event flow.
By pausing the controller the updater and events will not run until resumed. Pausing, however, will not stop the processing of any other before events.
eventName : String
The name of the event to fire.
args : Array
Arguments to pass to handlers and to the action function.
fn : Function/String
The action function.
scope : Object (optional)
The scope (this
reference) in which the handler function is
executed. If omitted, defaults to the object which fired the event.
fnArgs : Array/Boolean (optional)
Optional arguments for the action fn
. If not
given, the normal args
will be used to call fn
. If false
is passed, the
args
are used but if the first argument is this instance it will be removed
from the args passed to the action function.
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
eventName : String
The event name.
Try to focus this component.
If this component is disabled, a close relation will be targeted for focus instead to keep focus localized for keyboard users.
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.
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. If this component is disabled, a closely
related component will be focused and that will be returned.
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.
options : Object (optional)
An object with layout options.
Deprecated since version 4.1
Use Ext.Component#method-updateLayout instead.
Retrieves the named Ext.Action from this view or any ancestor which has that named Action. See actions
name : Object
Returns the current animation if this object has any effects actively running or queued, else returns false.
Anim if element has active effects, else false
Gets the x,y coordinates to align this element with another element. See alignTo for more info on the supported position values.
alignToEl : Ext.util.Positionable/HTMLElement/String
The Positionable, HTMLElement, or id of the element to align to.
position : String (optional)
The position to align to
Defaults to: "tl-bl?"
offsets : Number[] (optional)
Offset the positioning by [x, y]
[x, y]
Gets the x,y coordinates of an element specified by the anchor position on the element.
el : Ext.dom.Element
The element
anchor : String (optional)
The specified anchor position. See alignTo for details on supported anchor positions.
Defaults to: 'tl'
local : Boolean (optional)
True to get the local (element top/left-relative) anchor position instead of page coordinates
size : Object (optional)
An object containing the size to use for calculating anchor position {width: (target width), height: (target height)} (defaults to the element's current size)
[x, y] An array containing the element's x and y coordinates
Gets the x,y coordinates specified by the anchor position on the element.
anchor : String (optional)
The specified anchor position. See alignTo for details on supported anchor positions.
Defaults to: 'tl'
local : Boolean (optional)
True to get the local (element top/left-relative) anchor position instead of page coordinates
size : Object (optional)
An object containing the size to use for calculating anchor position {width: (target width), height: (target height)} (defaults to the element's current size)
[x, y] An array containing the element's x and y coordinates
Find component(s) that label or describe this component, and return the id(s) of their ariaEl elements.
reference : Function/String/String[] (optional)
Component reference, or array of component references, or a function that should return the proper attribute string. The function will be called in the context of the labelled component.
Element id string, or null
Returns the size of the element's borders and padding.
an object with the following numeric properties
Return an object defining the area of this Element which can be passed to setBox to set another Element's size/location to match this element.
contentBox : Boolean (optional)
If true a box for the content of the element is returned.
local : Boolean (optional)
If true the element's left and top relative to its
offsetParent
are returned instead of page x/y.
An object in the format
Gets the bubbling parent for an Observable
The bubble parent. null is returned if no bubble target exists
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.
Returns the correct editor type for the property type, or a custom one keyed by the property name
record : Object
column : Object
Return the immediate child Component in which the passed element is located.
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.
The child item which contains the passed element.
Gets a list of child components to enable/disable when the container is enabled/disabled
Items to be enabled/disabled
Returns a region object that defines the client area of this element.
That is, the area within any scrollbars.
A Region containing "top, left, bottom, right" properties.
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
comp : String/Number
The component id, itemId or position to find
The component (if found)
Returns a specified config property value. If the name parameter is not passed, all current configuration options will be returned as key value pairs.
name : String (optional)
The name of the config property to get.
peek : Boolean (optional)
true
to peek at the raw value without calling the getter.
Defaults to: false
The config property value.
Returns the content region of this element for purposes of constraining or clipping floating children. That is the region within the borders and scrollbars, but not within the padding.
A Region containing "top, left, bottom, right" properties.
Returns the [X, Y]
vector by which this Positionable's element must be translated to make a best
attempt to constrain within the passed constraint. Returns false
if the element
does not need to be moved.
Priority is given to constraining the top and left within the constraint.
The constraint may either be an existing element into which the element is to be constrained, or a Ext.util.Region into which this element is to be constrained.
By default, any extra shadow around the element is not included in the constrain calculations - the edges
of the element are used as the element bounds. To constrain the shadow within the constrain region, set the
constrainShadow
property on this element to true
.
constrainTo : Ext.util.Positionable/HTMLElement/String/Ext.util.Region (optional)
The Positionable, HTMLElement, element id, or Region into which the element is to be constrained.
proposedPosition : Number[] (optional)
A proposed [X, Y]
position to test for validity
and to produce a vector for instead of using the element's current position
proposedSize : Number[] (optional)
A proposed [width, height]
size to constrain
instead of using the element's current size
If the element needs to be translated, an [X, Y]
vector by which this element must be translated. Otherwise, false
.
Finds a docked component by id, itemId or position. Also see getDockedItems
comp : String/Number
The id, itemId or position of the docked component (see getComponent for details)
The docked component (if found)
Retrieves the top level element representing this component.
Available since: 1.1.0
Returns the focus styling holder element associated with this Focusable. By default it is the same element as getFocusEl.
The focus styling element.
Returns the focus holder element associated with this Container. By default, this is the Container's target element; however if defaultFocus is defined, the child component referenced by that property will be found and returned instead.
the focus holding element.
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.
Create the class array to add to the Header when collapsed.
header : Object
Gets the Ext.grid.header.Container for this grid / tree.
headercontainer
Note: While a locked grid / tree will return an instance of Ext.grid.locking.HeaderContainer you will code to the Ext.grid.header.Container API.
This method returns an object containing the inherited properties for this instance.
Available since: 5.0.0
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
The inheritedState
object containing inherited properties.
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
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
The value of the requested property
.
Returns the initial configuration passed to the constructor when instantiating this class.
Given this example Ext.button.Button definition and instance:
Ext.define('MyApp.view.Button', {
extend: 'Ext.button.Button',
xtype: 'mybutton',
scale: 'large',
enableToggle: true
});
var btn = Ext.create({
xtype: 'mybutton',
renderTo: Ext.getBody(),
text: 'Test Button'
});
Calling btn.getInitialConfig()
would return an object including the config
options passed to the create
method:
xtype: 'mybutton',
renderTo: // The document body itself
text: 'Test Button'
Calling btn.getInitialConfig('text')
returns 'Test Button'.
name : String (optional)
Name of the config option to return.
The full config object or a single config value
when name
parameter specified.
This function takes the position argument passed to onRender and returns a DOM element that you can use in the insertBefore.
position : String/Number/Ext.dom.Element/HTMLElement
Index, element id or element you want to put this component before.
DOM element that you can use in the insertBefore
Returns the x coordinate of this element reletive to its offsetParent
.
The local x coordinate
Returns the x and y coordinates of this element relative to its offsetParent
.
The local XY position of the element
Returns the y coordinate of this element reletive to its offsetParent
.
The local y coordinate
Returns 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 dictated 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.
Memento Factory method
name : String
Name of the Memento (used as prefix for named Memento)
Returns the offsets of this element from the passed element. The element must both be part of the DOM tree and not have display:none to have page coordinates.
offsetsTo : Ext.util.Positionable/HTMLElement/String
The Positionable, HTMLElement, or element id to get get the offsets from.
The XY page offsets (e.g. [100, -200]
)
Retrieves a plugin from this component's collection by its id
.
var grid = Ext.create('Ext.grid.Panel', {
store: {
fields: ['name'],
data: [{
name: 'Scott Pilgrim'
}]
},
columns: [{
header: 'Name',
dataIndex: 'name',
editor: 'textfield',
flex: 1
}],
selType: 'cellmodel',
plugins: {
ptype: 'cellediting',
clicksToEdit: 1,
id: 'myplugin'
},
height: 200,
width: 400,
renderTo: Ext.getBody()
});
grid.getPlugin('myplugin'); // the cellediting plugin
Note: See also findPlugin. Prior to 6.2.0 the plugin had to have a
pluginId
property but this can now be just
id
. Both are supported (so plugins with a
matching pluginId
are still found) but id
is preferred.
id : String
The id
set on the plugin config object.
plugin instance or null
if not found
Gets the current XY position of the component's underlying element.
local : Boolean (optional)
If true the element's left and top are returned instead of page XY.
Defaults to: false
The XY position of the element (e.g., [100, 200])
Gets the value of a property.
Available since: 5.1.1
prop : String
The name of the property.
The property value. null
if there is no value.
Used by Ext.ComponentQuery, child and down to retrieve all of the items which can potentially be considered a child of this Container.
This may be overriden by Components which have ownership of Components that are not contained in the property-items collection.
NOTE: IMPORTANT note for maintainers: Items are returned in tree traversal order. Each item is appended to the result array followed by the results of that child's getRefItems call. Floating child items are appended after internal child items.
deep : Object
Used by Ext.ComponentQuery, and the up method to find the owning Component in the linkage hierarchy.
By default this returns the Container which contains this Component.
This may be overridden by Component authors who implement ownership hierarchies which are not based upon ownerCt, such as BoundLists being owned by Fields or Menus being owned by Buttons.
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
An object with each child reference. This will be null
if this
container has no descendants with a reference
specified.
Returns the "x" scroll position for this component. Only applicable for scrollable components
Returns the "y" scroll position for this component. Only applicable for scrollable components
Returns the selection model being used by this grid's Ext.view.Table.
The selection model being used by this grid's Ext.view.Table.
Gets the current size of the component's underlying element.
contentSize : Boolean (optional)
true to get the width/size minus borders and padding
An object containing the element's size:
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.
ownerCtSizeModel : 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.
The supplied default state gathering method for the Component class.
This method returns dimension settings such as flex
, anchor
, width
and height
along with collapsed
state.
Subclasses which implement more complex state should call the superclass's implementation, and apply their state to the result if this basic state is to be saved.
Note that Component state will only be saved if the Component has a stateId and there as a StateProvider configured for the document.
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.
cls : Object
This is used to determine where to insert the 'html', 'contentEl' and 'items' in this component.
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'
Gets the topmost non floating alignTo target if there are multiple aligns such as a menu stack hanging off a button or grid column header.
The topmost, non floating alignTo target.
Returns the content region of this element. That is the region within the borders and padding.
A Region containing "top, left, bottom, right" member data.
Returns an array of the visible columns in the grid. This goes down to the lowest column header level, and does not return grouped headers which contain sub headers.
See also Ext.grid.header.Container#getGridColumns
columns An array of visible columns. Returns an empty array if no visible columns are found.
Gets the current X position of the DOM element based on page coordinates.
The X position of the element
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'
The xtype
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
The xtype hierarchy string
Gets the current position of the DOM element based on page coordinates.
The XY position of the element
Gets the current Y position of the DOM element based on page coordinates.
The Y position of the element
Returns the current animation if this object has any effects actively running or queued, else returns false.
Anim if element has active effects, else false
Deprecated since version 4.0
Replaced by getActiveAnimation
Checks if the specified CSS class exists on this element's DOM node.
className : String
The CSS class to check for.
true
if the class exists, else false
.
Checks to see if this object has any listeners for a specified event, or whether the event bubbles. The answer indicates whether the event needs firing or not.
eventName : String
The name of the event to check for
true
if the event is being listened for or bubbles, else false
Determine if there are any columns with a locked configuration option.
columns : Object
Checks if there is currently a specified uiCls
.
cls : String
The cls
to check.
Hides this Component, setting it to invisible using the configured cfg-hideMode.
animateTarget : String/Ext.dom.Element/Ext.Component (optional)
only valid for cfg-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.
this
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
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.
A CSS style string with body styles, padding and border.
The initComponent template method is an important initialization step for a Component. It is intended to be implemented by each subclass of Ext.Component to provide any needed constructor logic. The initComponent method of the class being created is called first, with each initComponent method up the hierarchy to Ext.Component being called thereafter. This makes it easy to implement and, if needed, override the constructor logic of the Component at any step in the hierarchy.
The initComponent method must contain a call to callParent in order to ensure that the parent class' initComponent method is also called.
All config options passed to the constructor are applied to this
before initComponent is called,
so you can simply access them with this.someOption
.
The following example demonstrates using a dynamic string for the text of a button at the time of instantiation of the class.
Ext.define('DynamicButtonText', {
extend: 'Ext.button.Button',
initComponent: function() {
this.text = new Date();
this.renderTo = Ext.getBody();
this.callParent();
}
});
Ext.onReady(function() {
Ext.create('DynamicButtonText');
});
Available since: 1.1.0
This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.
Initialize configuration for this class. a typical example:
Ext.define('My.awesome.Class', {
// The default config
config: {
name: 'Awesome',
isAwesome: true
},
constructor: function(config) {
this.initConfig(config);
}
});
var awesome = new My.awesome.Class({
name: 'Super Awesome'
});
alert(awesome.getName()); // 'Super Awesome'
instanceConfig : Object
this
Initializes an Item Collection for docked items to be inserted into. If items already exist, they will be added to the new collection.
Template method to do any Focusable related initialization that does not involve event listeners creation.
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.
Template method to do any event listener initialization for a Focusable. This generally happens after the focusEl is available.
Called by getInherited
to initialize the inheritedState the first time it is
requested.
inheritedState : Object
inheritedStateInner : Object
This method is called to initialize the items
collection. A derived class can
override this method to do any last minute manipulation of items
and then call
this method using callParent
. Upon return, the items
will no longer be a simple
array.
This method should be called when the instance is ready to start listening for
keyboard events. This is called automatically for Ext.Component
and derived
classes. In Classic Toolkit, this is done after the component is rendered.
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".
targetEl : Object
Initialized the renderData to be used when rendering the renderTpl.
Object with keys and values that are going to be applied to the renderTpl
Initializes the renderTpl.
The renderTpl XTemplate instance.
Override Component.initDraggable. Panel (and subclasses) use the header element as the delegate.
Applies padding, margin, border, top, left, height, and width configs to the appropriate elements.
targetEl : Object
Tools are a Panel-specific capability. Panel uses initTools. Subclasses may contribute tools by implementing addTools.
Inserts a Component into this Container at a specified index. Fires the beforeadd event before inserting, then fires the event-add event after the Component has been inserted.
Available since: 2.3.0
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.
component The Component (or config object) that was inserted with the Container's default config values applied.
Inserts docked item(s) to the panel at the indicated position.
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').
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
Tests whether this Component matches a Ext.ComponentQuery selector string.
selector : String
The selector string to test against.
true
if this Component matches the selector.
Determines whether this Component is an ancestor of the passed Component.
This will return true
if the passed Component is anywhere within the subtree
beneath this Component.
possibleDescendant : Ext.Component
The Component to test for presence within this Component's subtree.
Determines whether this component is the descendant of a passed component.
ancestor : Ext.Component
A Component which may contain this Component.
true
if the component is the descendant of the passed component, otherwise false
.
Method to determine whether this Component is currently disabled.
the disabled state of this Component.
Method to determine whether this Component is draggable.
the draggable state of this component.
Method to determine whether this Component is droppable.
the droppable state of this component.
Method to determine whether this Component is floating.
the floating state of this component.
Determine if this Focusable can receive focus at this time.
Note that Containers can be non-focusable themselves while delegating focus treatment to a child Component; see Ext.container.Container for more information.
deep : Boolean (optional)
Optionally determine if the container itself is focusable, or if container's focus is delegated to a child component and that child is focusable.
Defaults to: false
True if component is focusable, false if not.
Method to determine whether this Component is currently set to hidden.
the hidden state of this Component.
Checks if this component will be contained by the passed component as part of its
layout run. If true
, then the layout on this
can be skipped because it will be
encompassed when the layout for comp
runs. Typical cases where this may be be false
is when asking about floaters nested in containers.
ownerCandidate : Ext.Component
The potential owner.
true
if this component is a layout child of comp
.
Determines whether this Component is the root of a layout. This returns true
if
this component can run its layout without assistance from or impact on its owner.
If this component cannot run its layout given these restrictions, false
is returned
and its owner will be considered as the next candidate for the layout root.
Setting the _isLayoutRoot property to true
causes this method to always
return true
. This may be useful when updating a layout of a Container which shrink
wraps content, and you know that it will not change size, and so can safely be the
topmost participant in the layout run.
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.
true
layout of this component is suspended.
Returns masked state for this Component.
deep : Boolean (optional)
True to look up this Component's parent masked state.
Defaults to: false
True if masked, false otherwise.
Checks if all events, or a specific event, is suspended.
event : String (optional)
The name of the specific event to check
true
if events are suspended
Checks if a particular binding is synchronizing the value.
name : String
The name of the property being bound to.
true
if the binding is syncing.
Returns true
if this component is visible.
Available since: 1.1.0
deep : Boolean (optional)
Pass true
to interrogate the visibility status of all parent Containers to
determine whether this Component is truly visible to the user.
Generally, to determine whether a Component is hidden, the no argument form is needed. For example when creating dynamically laid out UIs in a hidden Container before showing them.
Defaults to: false
true
if this component is visible, false
otherwise.
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
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
true
if this component descends from the specified xtype, false
otherwise.
Adds a "destroyable" object to an internal list of objects that will be destroyed
when this instance is destroyed (via destroy
).
name : String
value : Object
The value
passed.
Locks the activeHeader as determined by which menu is open OR a header as specified.
header : Ext.grid.column.Column (optional)
Header to unlock from the locked section. Defaults to the header which has the menu open currently.
toIdx : Number (optional)
The index to move the unlocked header to. Defaults to appending as the last item.
Gets a reference to the component with the specified reference value.
The method is a short-hand for the lookupReference method.
Available since: 6.0.1
key : String
The name of the reference to lookup.
The referenced component or null
if it is not found.
Called when a raw config object is added to this container either during initialization of the cfg-items config, or when new items are added, or 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.
item : Object
The config object being added.
The component to be added.
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
skipThis : Boolean (optional)
true
to not consider the controller directly attached
to this view (if it exists).
Defaults to: false
The controller. null
if no controller is found.
Gets a reference to the component with the specified reference value.
The lookup method is a short-hand version of this method.
Available since: 5.0
key : String
The name of the reference to lookup.
The referenced component or null
if it is not found.
Gets the Controller or Component that is used as the reference holder for this view.
Available since: 5.0.0
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
The reference holder.
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
skipThis : Boolean (optional)
Pass true
to ignore a session
configured on
this instance and only consider an inherited session.
Defaults to: false
Gets a named template instance for this class. See Ext.XTemplate#getTpl.
Available since: 6.2.0
name : String
The name of the property that holds the template.
The template, null
if not found.
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
skipThis : Boolean (optional)
Pass true
to ignore a viewModel
configured on
this instance and only consider an inherited view model.
Defaults to: false
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
cfg : Ext.Config
The updater function.
Masks this component with a semi-opaque layer and makes the contents unavailable to clicks.
See unmask.
msg : String (optional)
A message to show in the center of the mask layer.
msgCls : String (optional)
A CSS class name to use on the message element in the center of the layer.
Shorthand for addManagedListener. The addManagedListener method is used when some object (call it "A") is listening to an event on another observable object ("B") and you want to remove that listener from "B" when "A" is destroyed. This is not an issue when "B" is destroyed because all of its listeners will be removed at that time.
Example:
Ext.define('Foo', {
extend: 'Ext.Component',
initComponent: function () {
this.addManagedListener(MyApp.SomeGlobalSharedMenu, 'show', this.doSomething);
this.callParent();
}
});
As you can see, when an instance of Foo is destroyed, it ensures that the 'show'
listener on the menu (MyApp.SomeGlobalSharedMenu
) is also removed.
As of version 5.1 it is no longer necessary to use this method in most cases because
listeners are automatically managed if the scope object provided to
addListener is an Observable instance.
However, if the observable instance and scope are not the same object you
still need to use mon
or addManagedListener
if you want the listener to be
managed.
item : Ext.util.Observable/Ext.dom.Element
The item to which to add a listener/listeners.
ename : Object/String
The event name, or an object containing event name properties.
fn : Function/String (optional)
If the ename
parameter was an event
name, this is the handler function or the name of a method on the specified
scope
.
scope : Object (optional)
If the ename
parameter was an event name, this is the scope (this
reference)
in which the handler function is executed.
options : Object (optional)
If the ename
parameter was an event name, this is the
addListener options.
Only when the destroyable
option is specified.
A Destroyable
object. An object which implements the destroy
method which removes all listeners added in this call. For example:
this.btnListeners = myButton.mon({
destroyable: true
mouseover: function() { console.log('mouseover'); },
mouseout: function() { console.log('mouseout'); },
click: function() { console.log('click'); }
});
And when those listeners need to be removed:
Ext.destroy(this.btnListeners);
or
this.btnListeners.destroy();
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.
fromIdx : Number/Ext.Component
The index/component to move.
toIdx : Number
The new index for the Component.
component The Component that was moved.
Deprecated since version 5.0
Use moveBefore or moveAfter instead.
Moves the given item(s)
into this container following after
. This method will
account for layout-generated components like splitters and should be used instead
of index based method-move
. If after
is null
then the item
will be the
first item in this container.
var tb = Ext.create({
xtype: 'toolbar',
renderTo: Ext.getBody(),
items: [{
text: 'one'
}, {
text: 'two'
}]
});
// moves the 'one' button after the 'two' button
tb.moveAfter(tb.getComponent(0), tb.getComponent(1));
Available since: 5.0.0
item : Ext.Component/Ext.Component[]
The item to move. May be a component, component configuration object, or an array of either.
after : Ext.Component
The reference component. May be null
.
The moved item(s).
Moves the given item(s)
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 method-move
. If before
is null
then the
item
will be the last item in this container.
var tb = Ext.create({
xtype: 'toolbar',
renderTo: Ext.getBody(),
items: [{
text: 'one'
}, {
text: 'two'
}]
});
// moves the 'two' button before the 'one' button
tb.moveBefore(tb.getComponent(1), tb.getComponent(0));
Available since: 5.0.0
item : Ext.Component/Ext.Component[]
The item to move. May be a component, component configuration object, or an array of either.
before : Ext.Component
The reference component. May be null
.
The moved item(s).
Moves a docked item to a different side.
item : Ext.Component
side : 'top'/'right'/'bottom'/'left'
Shorthand for removeManagedListener. Removes listeners that were added by the mon method.
item : Ext.util.Observable/Ext.dom.Element
The item from which to remove a listener/listeners.
ename : Object/String
The event name, or an object containing event name properties.
fn : Function (optional)
If the ename
parameter was an event name, this is the handler function.
scope : Object (optional)
If the ename
parameter was an event name, this is the scope (this
reference)
in which the handler function is executed.
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.
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.
The next child found, null
if no child found.
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.
selector : String (optional)
A Ext.ComponentQuery selector to filter the following nodes.
The next node (or the next node which matches the selector).
Returns null
if there is no matching node.
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
selector : String (optional)
A Ext.ComponentQuery selector to filter the following items.
The next sibling (or the next sibling which matches the selector).
Returns null
if there is no matching sibling.
The on method is shorthand for addListener.
Appends an event handler to this object. For example:
myGridPanel.on("itemclick", this.onItemClick, this);
The method also allows for a single argument to be passed which is a config object containing properties which specify multiple events. For example:
myGridPanel.on({
cellclick: this.onCellClick,
select: this.onSelect,
viewready: this.onViewReady,
scope: this // Important. Ensure "this" is correct during handler execution
});
One can also specify options for each event handler separately:
myGridPanel.on({
cellclick: {fn: this.onCellClick, scope: this, single: true},
viewready: {fn: panel.onViewReady, scope: panel}
});
Names of methods in a specified scope may also be used:
myGridPanel.on({
cellclick: {fn: 'onCellClick', scope: this, single: true},
viewready: {fn: 'onViewReady', scope: panel}
});
eventName : String/Object
The name of the event to listen for. May also be an object who's property names are event names.
fn : Function/String (optional)
The method the event invokes or the name of
the method within the specified scope
. Will be called with arguments
given to Ext.util.Observable#fireEvent plus the options
parameter described
below.
scope : Object (optional)
The scope (this
reference) in which the handler function is
executed. If omitted, defaults to the object which fired the event.
options : Object (optional)
An object containing handler configuration.
Note: The options object will also be passed as the last argument to every event handler.
This object may contain any of the following properties:
scope : Object
The scope (this
reference) in which the handler function is executed. If omitted,
defaults to the object which fired the event.
delay : Number
The number of milliseconds to delay the invocation of the handler after the event fires.
single : Boolean
True to add a handler to handle just the next firing of the event, and then remove itself.
buffer : Number
Causes the handler to be scheduled to run in an Ext.util.DelayedTask delayed by the specified number of milliseconds. If the event fires again within that time, the original handler is not invoked, but the new handler is scheduled in its place.
onFrame : Number
Causes the handler to be scheduled to run at the next animation frame event. If the event fires again before that time, the handler is not rescheduled - the handler will only be called once when the next animation frame is fired, with the last set of arguments passed.
target : Ext.util.Observable
Only call the handler if the event was fired on the target Observable, not if the event was bubbled up from a child Observable.
element : String
This option is only valid for listeners bound to Ext.Component. The name of a Component property which references an Ext.dom.Element to add a listener to.
This option is useful during Component construction to add DOM event listeners to elements of Ext.Component which will exist only after the Component is rendered.
For example, to add a click listener to a Panel's body:
var panel = new Ext.panel.Panel({
title: 'The title',
listeners: {
click: this.handlePanelClick,
element: 'body'
}
});
In order to remove listeners attached using the element, you'll need to reference the element itself as seen below.
panel.body.un(...)
delegate : String (optional)
A simple selector to filter the event target or look for a descendant of the target.
The "delegate" option is only available on Ext.dom.Element instances (or when attaching a listener to a Ext.dom.Element via a Component using the element option).
See the delegate example below.
capture : Boolean (optional)
When set to true
, the listener is fired in the capture phase of the event propagation
sequence, instead of the default bubble phase.
The capture
option is only available on Ext.dom.Element instances (or
when attaching a listener to a Ext.dom.Element via a Component using the
element option).
stopPropagation : Boolean (optional)
This option is only valid for listeners bound to Ext.dom.Element.
true
to call stopPropagation on the event object
before firing the handler.
preventDefault : Boolean (optional)
This option is only valid for listeners bound to Ext.dom.Element.
true
to call preventDefault on the event object
before firing the handler.
stopEvent : Boolean (optional)
This option is only valid for listeners bound to Ext.dom.Element.
true
to call stopEvent on the event object
before firing the handler.
args : Array (optional)
Optional set of arguments to pass to the handler function before the actual
fired event arguments. For example, if args
is set to ['foo', 42]
,
the event handler function will be called with an arguments list like this:
handler('foo', 42, <actual event arguments>...);
destroyable : Boolean (optional)
When specified as true
, the function returns a destroyable
object. An object
which implements the destroy
method which removes all listeners added in this call.
This syntax can be a helpful shortcut to using un; particularly when
removing multiple listeners. NOTE - not compatible when using the element
option. See un for the proper syntax for removing listeners added using the
element config.
Defaults to:
false
priority : Number (optional)
An optional numeric priority that determines the order in which event handlers are run. Event handlers with no priority will be run as if they had a priority of 0. Handlers with a higher priority will be prioritized to run sooner than those with a lower priority. Negative numbers can be used to set a priority lower than the default. Internally, the framework uses a range of 1000 or greater, and -1000 or lesser for handlers that are intended to run before or after all others, so it is recommended to stay within the range of -999 to 999 when setting the priority of event handlers in application-level code. A priority must be an integer to be valid. Fractional values are reserved for internal framework use.
order : String (optional)
A legacy option that is provided for backward compatibility.
It is recommended to use the priority
option instead. Available options are:
'before'
: equal to a priority of 100
'current'
: equal to a priority of 0
or default priority'after'
: equal to a priority of -100
Defaults to:
'current'
order : String (optional)
A shortcut for the order
event option. Provided for backward compatibility.
Please use the priority
event option instead.
Combining Options
Using the options argument, it is possible to combine different types of listeners:
A delayed, one-time listener.
myPanel.on('hide', this.handleClick, this, {
single: true,
delay: 100
});
Attaching multiple handlers in 1 call
The method also allows for a single argument to be passed which is a config object containing properties which specify multiple handlers and handler configs.
grid.on({
itemclick: 'onItemClick',
itemcontextmenu: grid.onItemContextmenu,
destroy: {
fn: function () {
// function called within the 'altCmp' scope instead of grid
},
scope: altCmp // unique scope for the destroy handler
},
scope: grid // default scope - provided for example clarity
});
Delegate
This is a configuration option that you can pass along when registering a handler for an event to assist with event delegation. By setting this configuration option to a simple selector, the target element will be filtered to look for a descendant of the target. For example:
var panel = Ext.create({
xtype: 'panel',
renderTo: document.body,
title: 'Delegate Handler Example',
frame: true,
height: 220,
width: 220,
html: '<h1 class="myTitle">BODY TITLE</h1>Body content'
});
// The click handler will only be called when the click occurs on the
// delegate: h1.myTitle ("h1" tag with class "myTitle")
panel.on({
click: function (e) {
console.log(e.getTarget().innerHTML);
},
element: 'body',
delegate: 'h1.myTitle'
});
Defaults to: 'current'
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();
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.
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.
Method to manage awareness of when components are added to their respective Container, firing an #added event. References are established at add time rather than at render time.
Allows addition of behavior when a Component is added to a
Container. At this stage, the Component is in the parent
Container's collection of child items. After calling the
superclass's onAdded
, the ownerCt
reference will be present,
and if configured with a ref, the refOwner
will be set.
Available since: 3.4.0
container : Ext.container.Container
Container which holds the component.
pos : Number
Position at which the component was added.
instanced : Boolean
false
if this component was instanced by the parent
container. true
if the instance already existed when it was passed to the container.
This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.
Appends an after-event handler.
Same as addListener with order
set
to 'after'
.
eventName : String/String[]/Object
The name of the event to listen for.
fn : Function/String
The method the event invokes.
scope : Object (optional)
The scope for fn
.
options : Object (optional)
An object containing handler configuration.
Appends a before-event handler. Returning false
from the handler will stop the event.
Same as addListener with order
set
to 'before'
.
eventName : String/String[]/Object
The name of the event to listen for.
fn : Function/String
The method the event invokes.
scope : Object (optional)
The scope for fn
.
options : Object (optional)
An object containing handler configuration.
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.
item : Ext.Component
This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.
Invoked when this component has first achieved size. This occurs after the componentLayout has completed its initial run.
This method is not called on components that use cfg-liquidLayout, such as Ext.button.Button and Ext.form.field.Base.
Note: If the Component has a ViewController and the controller has a boxReady method it will be called passing the Component and its width and height.
boxReady: function (view, width, height) {
// ...
}
width : Number
The width of this component
height : Number
The height of this component
This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.
Allows addition of behavior to the destroy operation.
This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.
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.
Invoked after a docked item is added to the Panel.
component : Ext.Component
This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.
Invoked after a docked item is removed from the Panel.
component : Ext.Component
This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.
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.
Called when focus enters this Component's hierarchy
e : Object
event : Ext.event.Event
The underlying DOM event.
target : HTMLElement
The element gaining focus.
HTMLElement
:The element losing focus.
toComponent : Ext.Component
The Component gaining focus.
fromComponent : Ext.Component
The Component losing focus.
This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.
Called when focus exits from this Component's hierarchy
e : Ext.event.Event
event : Ext.event.Event
The underlying DOM event.
target : HTMLElement
The element gaining focus.
HTMLElement
:The element losing focus.
toComponent : Ext.Component
The Component gaining focus.
fromComponent : Ext.Component
The Component losing focus.
This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.
Allows addition of behavior to the hide operation. After calling the superclass's onHide, the Component will be hidden.
Gets passed the same parameters as #hide.
animateTarget : String/Ext.dom.Element/Ext.Component (optional)
callback : Function (optional)
Callback function to be called when finished
scope : Object (optional)
This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.
Called when this Inheritable is added to a parent
instanced : Boolean
Called when this inheritable is removed from a parent
destroying : Boolean
true
if this item will be destroyed by it's container
Mousedown brings to front, and programmatically grabs focus unless the mousedown was on a focusable element
e : Object
Called after the component is moved, this method is empty by default but can be implemented by any subclass that needs to perform custom logic after a move occurs.
x : Number
The new x position.
y : Number
The new y position.
This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.
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.
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.
Method to manage awareness of when components are removed from their respective Container, firing a #removed event. References are properly cleaned up after removing a component from its owning container.
Allows addition of behavior when a Component is removed from
its parent Container. At this stage, the Component has been
removed from its parent Container's collection of child items,
but has not been destroyed (It will be destroyed if the parent
Container's autoDestroy
is true
, or if the remove call was
passed a truthy second parameter). After calling the
superclass's onRemoved
, the ownerCt
and the refOwner
will not
be present.
destroying : Boolean
Will be passed as true
if the Container performing the remove operation will delete this
Component upon remove.
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.
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.
Called when the component is resized.
This method is not called on components that use cfg-liquidLayout, such as Ext.button.Button and Ext.form.field.Base.
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
This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.
Tracks when things happen to the view and preserves the horizontal scroll position.
Invoked when a scroll operation is completed via this component's scroller.
x : Number
The current x position
y : Number
The current y position
This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.
Invoked when this component is scrolled via its scroller.
x : Number
The current x position
y : Number
The current y position
This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.
Invoked when a scroll is initiated on this component via its scroller.
x : Number
The current x position
y : Number
The current y position
This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.
Allows addition of behavior to the show operation. After calling the superclass's onShow, the Component will be visible.
Override in subclasses where more complex behaviour is needed.
Gets passed the same parameters as #show.
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.
Invoked after the #afterShow method is complete.
Gets passed the same callback
and scope
parameters that #afterShow received.
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.
Fires the TablePanel's viewready event when the view declares that its internal DOM is ready
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.
element : Object
Template method to do any post-blur processing.
e : Ext.event.Event
The event object
Template method to do any post-focus processing.
e : Ext.event.Event
The event object
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.
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.
The previous child found, null
if no child found.
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.
selector : String (optional)
A Ext.ComponentQuery selector to filter the preceding nodes.
The previous node (or the previous node which matches the selector).
Returns null
if there is no matching node.
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
selector : String (optional)
A Ext.ComponentQuery selector to filter the preceding items.
The previous sibling (or the previous sibling which matches the selector).
Returns null
if there is no matching sibling.
Processes UI events from the view. Propagates them to whatever internal Components need to process them.
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
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
property : String (optional)
The name of the property to update.
value : Object (optional)
The value of property
. Only needed if property
is given.
Retrieves all descendant components which match the passed selector. Executes an Ext.ComponentQuery.query using this container as its root.
selector : String (optional)
Selector complying to an Ext.ComponentQuery selector. If no selector is specified all items will be returned.
Components which matched the selector
Retrieves all descendant components which match the passed function. The function should return false for components that are to be excluded from the selection.
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.
Components matched by the passed function
Finds a component at any level under this container matching the id/itemId. This is a shorthand for calling ct.down('#' + id);
id : String
The id to find
The matching id, null if not found
Reconfigures the grid or tree with a new store and/or columns. Stores and columns may also be passed as params.
grid.reconfigure(store, columns);
Additionally, you can pass just a store or columns.
tree.reconfigure(store);
// or
grid.reconfigure(columns);
// or
tree.reconfigure(null, columns);
If you're using locked columns, the enableLocking config should be set
to true
before the reconfigure method is executed.
store : Ext.data.Store/Object (optional)
The new store instance or store config. You can
pass null
if no new store.
columns : Object[] (optional)
An array of column configs
store : Object
columns : Object
allowUnbind : Object
actionable : Object
An object which has an interest in the implementation of actionable mode in this grid.
An actionable object may be a Plugin which upon activation injects tabbable elements or Components into a grid row.
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.
cmp : 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).
origin : Object
The Observable whose events this object is to relay.
events : String[]/Object
Array of event names to relay or an Object with key/value pairs translating to ActualEventName/NewEventName respectively. For example: this.relayEvents(this, {add:'push', remove:'pop'});
Would now redispatch the add event of this as a push event and the remove event as a pop event.
prefix : String (optional)
A common prefix to prepend to the event names. For example:
this.relayEvents(this.getStore(), ['load', 'clear'], 'store');
Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'.
A Destroyable
object. An object which implements the destroy
method which, when destroyed, removes all relayers. For example:
this.storeRelayers = this.relayEvents(this.getStore(), ['load', 'clear'], 'store');
Can be undone by calling
Ext.destroy(this.storeRelayers);
or this.store.relayers.destroy();
Removes a component from this container. Fires the beforeremove event before removing, then fires the event-remove event after the component has been removed.
Available since: 2.3.0
component : Ext.Component/String
The component instance or id to remove.
disposition : Object (optional)
Flags to determine what to do with the removed component.
(May also be specified as a boolean autoDestroy
flag for backward compatibility).
destroy : Boolean (optional)
Defaults to this Container's autoDestroy config. Specifies whether to destroy the component being removed.
detach : Object (optional)
Defaults to the detachOnRemove configuration Specifies whether to remove the component's DOM from the container and into the detached body element
component The Component that was removed.
Removes all components from this container.
Available since: 2.3.0
autoDestroy : Boolean (optional)
True to automatically invoke the removed Component's Ext.Component#method-destroy function. Defaults to the value of this Container's autoDestroy config.
Array of the removed components
Remove any anchor to this element. See anchorTo.
this
Removes a CSS class from the body element.
cls : String/String[]
The class to remove
this
Removes a CSS class from the top level element representing this component.
Available since: 2.3.0
cls : String/String[]
The CSS class name to remove.
Returns the Component to allow method chaining.
Deprecated since version 4.1
Use addCls instead.
Removes a CSS class from the top level element representing this component.
cls : String/String[]
The CSS class name to remove.
Returns the Component to allow method chaining.
Removes a cls
to the uiCls
array, which will also call removeUIClsFromElement and removes it from all
elements of this component.
classes : String/String[]
A string or an array of strings to remove to the uiCls
.
skip : Boolean
True to remove the class
Removes delegated listeners for a given eventName, function, and scope. Users should not invoke this method directly. It is called automatically by the framework as part of removeListener processing.
eventName : Object
fn : Object
scope : Object
Removes the docked item from the panel.
item : Ext.Component
The Component to remove.
autoDestroy : Boolean (optional)
Destroy the component after removal.
Removes an event handler.
eventName : String
The type of event the handler was associated with.
fn : Function
The handler to remove. This must be a reference to the function passed into the addListener call.
scope : Object (optional)
The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable#addListener or the listener will not be removed.
Convenience Syntax
You can use the addListener
destroyable: true
config option in place of calling un(). For example:
var listeners = cmp.on({
scope: cmp,
afterrender: cmp.onAfterrender,
beforehide: cmp.onBeforeHide,
destroyable: true
});
// Remove listeners
listeners.destroy();
// or
cmp.un(
scope: cmp,
afterrender: cmp.onAfterrender,
beforehide: cmp.onBeforeHide
);
Exception - DOM event handlers using the element config option
You must go directly through the element to detach an event handler attached using the addListener element option.
panel.on({
element: 'body',
click: 'onBodyCLick'
});
panel.body.un({
click: 'onBodyCLick'
});
Removes listeners that were added by the mon method.
item : Ext.util.Observable/Ext.dom.Element
The item from which to remove a listener/listeners.
ename : Object/String
The event name, or an object containing event name properties.
fn : Function (optional)
If the ename
parameter was an event name, this is the handler function.
scope : Object (optional)
If the ename
parameter was an event name, this is the scope (this
reference)
in which the handler function is executed.
Remove a single managed listener item
isClear : Boolean
True if this is being called during a clear
managedListener : Object
The managed listener item See removeManagedListener for other args
Removes a property from the grid.
prop : String
The name of the property to remove.
Method which removes a specified UI + uiCls
from the components element. The cls
which is added to the element will be: this.baseCls + '-' + ui + uiCls
.
uiCls : String
The UI class to remove from the element.
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.
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.
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)
Gets the Controller or Component that is used as the event root for this view.
Available since: 5.0.0
defaultScope : Object (optional)
The default scope to return if none is found.
Defaults to: this
The default listener scope.
Returns the default listener scope for a "satellite" of this component. Used for resolving scope for observable objects that are not part of the normal Container/Component hierarchy (for example, plugins)
Available since: 5.1.1
satellite : Ext.mixin.Observable
defaultScope : Object (optional)
The listener scope
Resumes firing of the named event(s).
After calling this method to resume events, the events will fire when requested to fire.
Note that if the suspendEvent method is called multiple times for a certain event, this converse method will have to be called the same number of times for it to resume firing.
eventName : String...
Multiple event names to resume.
Resumes firing events (see suspendEvents).
If events were suspended using the queueSuspended
parameter, then all events fired
during event suspension will be sent to any listeners now.
discardQueue : Boolean (optional)
true
to prevent any previously queued events from firing
while we were suspended. See suspendEvents.
Converts local coordinates into page-level coordinates
xy : Number[]
The local x and y coordinates
The translated coordinates
Returns focus to the Component or element found in the cached focusEnterEvent.
Usually called by onHide.
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.
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.
True if the property was saved, false if not.
Gathers additional named properties of the instance and adds their current values to the passed state object.
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.
state
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);
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.
Scrolls this component to the specified x
and y
coordinates. Only applicable
for scrollable components.
x : Number
y : Number
animate : Boolean/Object (optional)
true for the default animation or a standard Element animation config object
Ensures that all effects queued after sequenceFx is called on this object are run in sequence. This is the opposite of syncFx.
this
Toggles ARIA actionable mode on/off
enabled : Boolean
true
if actionable mode was entered
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.
active : Boolean (optional)
True to activate the Component, false to deactivate it.
Defaults to: false
doFocus : Boolean (optional)
When activating, set to true to focus the component; when deactivating, set to false to avoid returning focus to previous element.
Sets the element's box.
box : Object
The box to fill {x, y, width, height}
this
Sets a single/multiple configuration options.
name : String/Object
The name of the property to set, or a set of key value pairs to set.
value : Object (optional)
The value to set for the name parameter.
this
Sets the 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)
dock : Object
The dock position.
this
Deprecated since version 5.0
Use setDock instead.
Set visibility of docked items after the panel is collapsed or expanded
els : Ext.dom.CompositeElement
show : Boolean
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.
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.
The LoadMask instance that has just been shown.
Sets the local x coordinate of this element using CSS style. When used on an absolute positioned element this method is symmetrical with getLocalX, but may not be symmetrical when used on a relatively positioned element.
x : Number
The x coordinate. A value of null
sets the left style to 'auto'.
this
Sets the local x and y coordinates of this element using CSS style. When used on an absolute positioned element this method is symmetrical with getLocalXY, but may not be symmetrical when used on a relatively positioned element.
x : Number/Array
The x coordinate or an array containing [x, y]. A value of
null
sets the left style to 'auto'
y : Number (optional)
The y coordinate, required if x is not an array. A value of
null
sets the top style to 'auto'
this
Sets the local y coordinate of this element using CSS style. When used on an absolute positioned element this method is symmetrical with getLocalY, but may not be symmetrical when used on a relatively positioned element.
y : Number
The y coordinate. A value of null
sets the top style to 'auto'.
this
Set masked state for this Component.
isMasked : Boolean
True if masked, false otherwise.
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 undefined
will preserve the current value.
overflowX : String
The overflow-x value.
overflowY : String
The overflow-y value.
this
Deprecated since version 5.0.0
Use setScrollable instead
Sets the page XY position of the component. To set the left and top instead, use setPosition. This method fires the event-move event.
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.
this
Sets the left and top of the component. To set the page XY position instead, use setPagePosition. This method fires the event-move event.
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.
this
Sets the value of a property.
prop : String
The name of the property to set.
value : Object
The value to test.
create : Boolean (optional)
true
to create the property if it doesn't already exist.
Defaults to: false
Sets the "x" scroll position for this component. Only applicable for scrollable components
x : Number
animate : Boolean/Object (optional)
true for the default animation or a standard Element animation config object
Sets the "y" scroll position for this component. Only applicable for scrollable components
y : Number
animate : Boolean/Object (optional)
true for the default animation or a standard Element animation config object
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}
.
width : Number/String/Object
The new width to set. This may be one of:
{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:
undefined
to leave the height unchanged.this
Convenience function to hide or show this component by Boolean.
Available since: 1.1.0
visible : Boolean
true
to show, false
to hide.
this
Sets the X position of the DOM element based on page coordinates.
x : Number
The X position
this
Sets the position of the DOM element in page coordinates.
pos : Number[]
Contains X & Y [x, y] values for new position (coordinates are page-based)
this
Sets the Y position of the DOM element based on page coordinates.
y : Number
The Y position
this
z-index is managed by the zIndexManager and may be overwritten at any time. Returns the next z-index to be used.
If this is a Container, then it will have rebased any managed floating Components, and so the next available z-index will be approximately 10000 above that.
index : Object
Inject a reference to the function which applies the render template into the framing template. The framing template wraps the content.
frameTpl : Object
Shows this Component, rendering it first if autoRender or cfg-floating are true
.
After being shown, a cfg-floating Component (such as a Ext.window.Window), is activated it and brought to the front of its z-index stack.
animateTarget : String/Ext.dom.Element (optional)
only valid for cfg-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.
this
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());
}
}
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.
this
Shows this component by the specified Ext.Component or Ext.dom.Element. Used when this component is cfg-floating.
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.
offset : Number[] (optional)
Alignment offsets as used by Ext.util.Positionable#getAlignToXY. See alignTo for possible values.
this
This method cleans up after the slide out of the floated panel.
suppressEvents : Object
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
Stops any running effects and clears this object's internal effects queue if it contains any additional effects that haven't started yet.
suppressEvent : Object
The Element
Stops any running effects and clears this object's internal effects queue if it contains any additional effects that haven't started yet.
The Element
Deprecated since version 4.0
Replaced by stopAnimation
Suspends firing of the named event(s).
After calling this method to suspend events, the events will no longer fire when requested to fire.
Note that if this is called multiple times for a certain event, the converse method resumeEvent will have to be called the same number of times for it to resume firing.
eventName : String...
Multiple event names to suspend.
Suspends the firing of all events. (see resumeEvents)
queueSuspended : Boolean
true
to queue up suspended events to be fired
after the resumeEvents call instead of discarding all suspended events.
Ensures that all effects queued after syncFx is called on this object are run concurrently. This is the opposite of sequenceFx.
this
Updates the overall view after columns have been resized, or moved from the locked to unlocked side or vice-versa.
If all columns are removed from either side, that side must be hidden, and the sole remaining column owning grid then becomes the grid. It must flex to occupy the whole of the locking view. And it must also allow scrolling.
If columns are shared between the two sides, the locked grid shrinkwraps the width of the visible locked columns while the normal grid flexes in what space remains.
A pair of flags indicating which views need to be cleared then refreshed.
this contains two properties, locked
and normal
which are true
if the view needs to be cleared
and refreshed.
Synchronizes the row heights between the locked and non locked portion of the grid for each row. If one row is smaller than the other, the height will be increased to match the larger one.
Sends this Component to the back of (lower z-index than) any other visible windows
this
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.
preventFocus : Boolean (optional)
Specify true
to prevent the Component from being focused.
Defaults to: false
this
Toggles the specified CSS class on this component (removes it if it already exists, otherwise adds it).
className : String
The CSS class to toggle.
state : Boolean (optional)
If specified as true
, causes the class to be added. If
specified as false
, causes the class to be removed.
Returns the Component to allow method chaining.
Shortcut for performing an method-expand or method-collapse based on the current state of the panel.
this
Translates the passed page coordinates into left/top css values for the element
x : Number/Array
The page x or an array containing [x, y]
y : Number (optional)
The page y, required if x is not an array
An object with left and top properties. e.g. {left: (value), top: (value)}
Translates the passed page coordinates into x and y css values for the element
x : Number/Array
The page x or an array containing [x, y]
y : Number (optional)
The page y, required if x is not an array
An object with x and y properties. e.g. {x: (value), y: (value)}
Shorthand for removeListener. Removes an event handler.
eventName : String
The type of event the handler was associated with.
fn : Function
The handler to remove. This must be a reference to the function passed into the addListener call.
scope : Object (optional)
The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable#addListener or the listener will not be removed.
Convenience Syntax
You can use the addListener
destroyable: true
config option in place of calling un(). For example:
var listeners = cmp.on({
scope: cmp,
afterrender: cmp.onAfterrender,
beforehide: cmp.onBeforeHide,
destroyable: true
});
// Remove listeners
listeners.destroy();
// or
cmp.un(
scope: cmp,
afterrender: cmp.onAfterrender,
beforehide: cmp.onBeforeHide
);
Exception - DOM event handlers using the element config option
You must go directly through the element to detach an event handler attached using the addListener element option.
panel.on({
element: 'body',
click: 'onBodyCLick'
});
panel.body.un({
click: 'onBodyCLick'
});
Removes a before-event handler.
Same as removeListener with order
set to 'after'
.
eventName : String/String[]/Object
The name of the event the handler was associated with.
fn : Function/String
The handler to remove.
scope : Object (optional)
The scope originally specified for fn
.
options : Object (optional)
Extra options object.
Removes a before-event handler.
Same as removeListener with order
set to 'before'
.
eventName : String/String[]/Object
The name of the event the handler was associated with.
fn : Function/String
The handler to remove.
scope : Object (optional)
The scope originally specified for fn
.
options : Object (optional)
Extra options object.
show : Object
matchPosition : Object
focus : Object
Destroys a given set of linked
objects. This is only needed if
the linked object is being destroyed before this instance.
names : String[]
The names of the linked objects to destroy.
this
Unlocks the activeHeader as determined by which menu is open OR a header as specified.
header : Ext.grid.column.Column (optional)
Header to unlock from the locked section. Defaults to the header which has the menu open currently.
toIdx : Number (optional)
The index to move the unlocked header to.
Defaults to: 0
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');
selector : String/Ext.Component (optional)
The selector component or actual component to test. If not passed the immediate owner/activator 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.
The matching ancestor Container (or undefined
if no match was found).
Update the content area of a component.
Available since: 3.4.0
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. Causes embedded script tags to be executed. Inline source will be executed
with this Component as the scope (this
reference).
Defaults to: false
callback : Function (optional)
Only legitimate when using the html
configuration.
Callback to execute when scripts have finished loading.
scriptScope : Object (optional)
The scope (this
reference) in which to
execute inline script elements content. Scripts with a src
attribute cannot
be executed with this scope.
Defaults to: `this`
Sets the current box measurements of the component's underlying element.
box : Object
An object in the format {x, y, width, height}
this
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.
Create, hide, or show the header component as appropriate based on the current config.
force : Boolean
True to force the header to be created
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.
Updates the viewModel config.
viewModel : Ext.app.ViewModel
oldViewModel : Ext.app.ViewModel
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.
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.
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.
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.
Adds new config properties to this class. This is called for classes when they are declared, then for any mixins that class may define and finally for any overrides defined that target the class.
config : Object
mixinClass : Ext.Class (optional)
The mixin class if the configs are from a mixin.
Add methods / properties to the prototype of this class.
Ext.define('My.awesome.Cat', {
constructor: function() {
...
}
});
My.awesome.Cat.addMembers({
meow: function() {
alert('Meowww...');
}
});
var kitty = new My.awesome.Cat();
kitty.meow();
members : Object
The members to add to this class.
isStatic : Boolean (optional)
Pass true
if the members are static.
Defaults to: false
privacy : Boolean (optional)
Pass true
if the members are private. This
only has meaning in debug mode and only for methods.
Defaults to: false
Add / override static properties of this class.
Ext.define('My.cool.Class', {
...
});
My.cool.Class.addStatics({
someProperty: 'someValue', // My.cool.Class.someProperty = 'someValue'
method1: function() { ... }, // My.cool.Class.method1 = function() { ... };
method2: function() { ... } // My.cool.Class.method2 = function() { ... };
});
members : Object
this
Borrow another class' members to the prototype of this class.
Ext.define('Bank', {
money: '$$$',
printMoney: function() {
alert('$$$$$$$');
}
});
Ext.define('Thief', {
...
});
Thief.borrow(Bank, ['money', 'printMoney']);
var steve = new Thief();
alert(steve.money); // alerts '$$$'
steve.printMoney(); // alerts '$$$$$$$'
fromClass : Ext.Base
The class to borrow members from
members : Array/String
The names of the members to borrow
this
Create 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.
the created instance.
Create aliases for existing prototype methods. Example:
Ext.define('My.cool.Class', {
method1: function() { ... },
method2: function() { ... }
});
var test = new My.cool.Class();
My.cool.Class.createAlias({
method3: 'method1',
method4: 'method2'
});
test.method3(); // test.method1()
My.cool.Class.createAlias('method5', 'method3');
test.method5(); // test.method3() -> test.method1()
alias : String/Object
The new method name, or an object to set multiple aliases. See flexSetter
origin : String/Object
The original method name
Returns the Ext.Configurator
for this class.
Get the current class' name in string format.
Ext.define('My.cool.Class', {
constructor: function() {
alert(this.self.getName()); // alerts 'My.cool.Class'
}
});
My.cool.Class.getName(); // 'My.cool.Class'
className
Used internally by the mixins pre-processor
name : Object
mixinClass : Object
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).
members : Object
The properties to add to this class. This should be specified as an object literal containing one or more properties.
this class
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.
this : Ext.Component
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires after any Ext.Component is added or inserted into the container.
Available since: 2.3.0
this : Ext.container.Container
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.
Fires after a Component had been added to a Container.
Available since: 3.4.0
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.
Fires when the components in this container are arranged by the associated layout manager.
Available since: 2.3.0
this : Ext.container.Container
layout : Ext.layout.container.Container
The ContainerLayout implementation for this container
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
This event first after a component's layout has been updated by a layout that included animation (e.g., a Ext.panel.Panel in an Ext.layout.container.Accordion layout).
Available since: 6.0.0
this : Ext.Component
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires after the component rendering is finished.
The afterrender
event is fired after this Component has been rendered, been post-processed by any
afterRender
method defined for the Component.
Available since: 3.4.0
this : Ext.Component
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
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.
this : Ext.Component
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
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
this : Ext.container.Container
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.
Fired before the cell click is processed. Return false to cancel the default action.
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
e : Ext.event.Event
position : Ext.grid.CellContext
A CellContext object which defines the target cell.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fired before the cell double click is processed. Return false to cancel the default action.
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
e : Ext.event.Event
position : Ext.grid.CellContext
A CellContext object which defines the target cell.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fired before the cell key down is processed. Return false to cancel the default action.
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
e : Ext.event.Event
position : Ext.grid.CellContext
A CellContext object which defines the target cell.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fired before the cell mouse down is processed. Return false to cancel the default action.
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
e : Ext.event.Event
position : Ext.grid.CellContext
A CellContext object which defines the target cell.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fired before the cell mouse up is processed. Return false to cancel the default action.
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
e : Ext.event.Event
position : Ext.grid.CellContext
A CellContext object which defines the target cell.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires before the user closes the panel. Return false from any listener to stop the close event being fired
panel : Ext.panel.Panel
The Panel object
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires before this panel is collapsed. Return false to prevent the collapse.
p : Ext.panel.Panel
The Panel being collapsed.
direction : String
. The direction of the collapse. One of
animate : Boolean
True if the collapse is animated, else false.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires before the click event on the container is processed. Returns false to cancel the default action.
this : Ext.view.View
e : Ext.event.Event
The raw event object
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires before the dblclick event on the container is processed. Returns false to cancel the default action.
this : Ext.view.View
e : Ext.event.Event
The raw event object
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires before the keydown event on the container is processed. Returns false to cancel the default action.
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.
Fires before the keypress event on the container is processed. Returns false to cancel the default action.
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.
Fires before the keyup event on the container is processed. Returns false to cancel the default action.
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.
Fires before the mousedown event on the container is processed. Returns false to cancel the default action.
this : Ext.view.View
e : Ext.event.Event
The raw event object
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires before the mouseout event on the container is processed. Returns false to cancel the default action.
this : Ext.view.View
e : Ext.event.Event
The raw event object
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires before the mouseover event on the container is processed. Returns false to cancel the default action.
this : Ext.view.View
e : Ext.event.Event
The raw event object
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires before the mouseup event on the container is processed. Returns false to cancel the default action.
this : Ext.view.View
e : Ext.event.Event
The raw event object
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
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.
this : Ext.Component
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fired before a record is deselected. If any listener returns false, the deselection is cancelled.
this : Ext.selection.RowModel
record : Ext.data.Model
The deselected record
index : Number
The row index deselected
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires before the component is destroyed.
Note: This event should not be used to try to veto the destruction sequence by returning
false
, even though this is often permitted in other "before" events. Doing so will have
unpredictable side-effects and can result in partially destroyed objects. Instead look to
other events like beforeclose that occur prior to
the call to the destroy method.
Available since: 1.1.0
this : Ext.Component
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires before this panel is expanded. Return false to prevent the expand.
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.
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
this : Ext.Component
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires before the click event on an item is processed. Return false to cancel the default action. Fires before the mousedown event on an item is processed. Return false to cancel the default action.
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.
Fires before the dblclick event on an item is processed. Return false to cancel the default action. Fires before the mousedown event on an item is processed. Return false to cancel the default action.
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.
Fires before the longpress event on an item is processed. Return false to cancel the default action. Fires before the mousedown event on an item is processed. Return false to cancel the default action.
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.
Fires before the mousedown event on an item is processed. Return false to cancel the default action.
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.
Fires before the mouseenter event on an item is processed. Return false to cancel the default action. Fires before the mousedown event on an item is processed. Return false to cancel the default action.
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.
Fires before the mouseleave event on an item is processed. Return false to cancel the default action. Fires before the mousedown event on an item is processed. Return false to cancel the default action.
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.
Fires before the mouseup event on an item is processed. Return false to cancel the default action. Fires before the mousedown event on an item is processed. Return false to cancel the default action.
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.
Fires before a request is made for a new data object. If the beforeload handler returns false the load action will be canceled.
Note: If you are using a buffered store, you should use beforeprefetch.
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.
Fires before a property value changes. Handlers can return false to cancel the property change (this will internally call Ext.data.Model#reject on the property's record).
source : Object
The source data object for the grid (corresponds to the same object passed in as the source config property).
recordId : String
The record's id in the data store
value : Object
The current edited property value
oldValue : Object
The original property value prior to editing
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires before a reconfigure to enable modification of incoming Store and columns.
this : Ext.grid.Panel
store : Ext.data.Store
The store that was passed to the method-reconfigure method
columns : Object[]
The column configs that were passed to the method-reconfigure method
oldStore : Ext.data.Store
The store that will be replaced
oldColumns : Ext.grid.column.Column[]
The column headers that will be replaced.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires before any Ext.Component is removed from the container. A handler can return false to cancel the remove.
Available since: 2.3.0
this : Ext.container.Container
component : Ext.Component
The component being removed
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires before the component is rendered. Return false
from an event handler to stop the
method-render.
Available since: 1.1.0
this : Ext.Component
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires before the click event on a row body element is processed. Return false to cancel the default action.
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used. Fires before the mousedown event on a row body element is processed. Return false to cancel the default action.
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used.
view : Ext.view.View
The rowbody's owning View
rowBodyEl : HTMLElement
The row body's element
e : Ext.event.Event
The raw event object
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
This action following this event is preventable. When any of the listeners returns false, the action is cancelled.
Fires before the dblclick event on a row body element is processed. Return false to cancel the default action.
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used. Fires before the mousedown event on a row body element is processed. Return false to cancel the default action.
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used.
view : Ext.view.View
The rowbody's owning View
rowBodyEl : HTMLElement
The row body's element
e : Ext.event.Event
The raw event object
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
This action following this event is preventable. When any of the listeners returns false, the action is cancelled.
Fires before the keydown event on a row body element is processed. Return false to cancel the default action.
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used. Fires before the mousedown event on a row body element is processed. Return false to cancel the default action.
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used.
view : Ext.view.View
The rowbody's owning View
rowBodyEl : HTMLElement
The row body's element
e : Ext.event.Event
The raw event object
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
This action following this event is preventable. When any of the listeners returns false, the action is cancelled.
Fires before the keypress event on a row body element is processed. Return false to cancel the default action.
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used. Fires before the mousedown event on a row body element is processed. Return false to cancel the default action.
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used.
view : Ext.view.View
The rowbody's owning View
rowBodyEl : HTMLElement
The row body's element
e : Ext.event.Event
The raw event object
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
This action following this event is preventable. When any of the listeners returns false, the action is cancelled.
Fires before the keyup event on a row body element is processed. Return false to cancel the default action.
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used. Fires before the mousedown event on a row body element is processed. Return false to cancel the default action.
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used.
view : Ext.view.View
The rowbody's owning View
rowBodyEl : HTMLElement
The row body's element
e : Ext.event.Event
The raw event object
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
This action following this event is preventable. When any of the listeners returns false, the action is cancelled.
Fires before the longpress event on a row body element is processed. Return false to cancel the default action.
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used. Fires before the mousedown event on a row body element is processed. Return false to cancel the default action.
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used.
view : Ext.view.View
The rowbody's owning View
rowBodyEl : HTMLElement
The row body's element
e : Ext.event.Event
The raw event object
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
This action following this event is preventable. When any of the listeners returns false, the action is cancelled.
Fires before the mousedown event on a row body element is processed. Return false to cancel the default action.
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used.
view : Ext.view.View
The rowbody's owning View
rowBodyEl : HTMLElement
The row body's element
e : Ext.event.Event
The raw event object
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
This action following this event is preventable. When any of the listeners returns false, the action is cancelled.
Fires before the mouseup event on a row body element is processed. Return false to cancel the default action.
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used. Fires before the mousedown event on a row body element is processed. Return false to cancel the default action.
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used.
view : Ext.view.View
The rowbody's owning View
rowBodyEl : HTMLElement
The row body's element
e : Ext.event.Event
The raw event object
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
This action following this event is preventable. When any of the listeners returns false, the action is cancelled.
Fired when View is asked to exit Actionable mode in the current row,
and proceed to the previous/next row. If the handler returns false
,
View processing is aborted.
this : Ext.view.Table
keyEvent : Ext.event.Event
The key event that caused navigation.
prevRow : HTMLElement
Currently active table row.
nextRow : HTMLElement
Table row that is going to be focused and activated.
forward : Boolean
true
if we're navigating forward (Tab), false
if
navigating backward (Shift-Tab).
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fired before a record is selected. If any listener returns false, the selection is cancelled.
this : Ext.selection.RowModel
record : Ext.data.Model
The selected record
index : Number
The row index selected
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
An event fired when an extension block is extended using a drag gesture. Only fired when the SpreadsheetSelectionModel is used and configured with the extensible config.
grid : Ext.panel.Table
The owning grid.
An : Ext.grid.selection.Selection
object which encapsulates a contiguous selection block.
extension : Object
An object describing the type and size of extension.
type : String
"rows"
or "columns"
start : Ext.grid.CellContext
The start (top left) cell of the extension area.
end : Ext.grid.CellContext
The end (bottom right) cell of the extension area.
columns : Number (optional)
The number of columns extended (-ve means on the left side).
rows : Number (optional)
The number of rows extended (-ve means on the top side).
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
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
this : Ext.Component
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires before the state of the object is restored. Return false from an event handler to stop the restore.
this : Ext.state.Stateful
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.
Fires before the state of the object is saved to the configured state provider. Return false to stop the save.
this : Ext.state.Stateful
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.
Fires when this Component loses focus.
this : Ext.Component
event : Ext.event.Event
The blur event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires one time - after the component has been laid out for the first time at its initial size.
This event does not fire on components that use cfg-liquidLayout, such as Ext.button.Button and Ext.form.field.Base.
this : Ext.Component
width : Number
The initial width.
height : Number
The initial height.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fired when table cell is clicked.
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
e : Ext.event.Event
position : Ext.grid.CellContext
A CellContext object which defines the target cell.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fired when table cell is double clicked.
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
e : Ext.event.Event
position : Ext.grid.CellContext
A CellContext object which defines the target cell.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fired when the keydown event is captured on the cell.
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
e : Ext.event.Event
position : Ext.grid.CellContext
A CellContext object which defines the target cell.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fired when the mousedown event is captured on the cell.
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
e : Ext.event.Event
position : Ext.grid.CellContext
A CellContext object which defines the target cell.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fired when the mouseup event is captured on the cell.
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
e : Ext.event.Event
position : Ext.grid.CellContext
A CellContext object which defines the target cell.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires after any Ext.Component has changed its ordinal position within the container.
this : Ext.container.Container
component : Ext.Component
The component that was moved
prevIndex : Number
The previous ordinal position of the Component
newIndex : Number
The new ordinal position of the Component
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when the user closes the panel.
panel : Ext.panel.Panel
The Panel object
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires after this Panel has collapsed.
p : Ext.panel.Panel
The Panel that has been collapsed.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
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.
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.
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.
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.
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.
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.
Fires when the container is clicked.
this : Ext.view.View
e : Ext.event.Event
The raw event object
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when the container is double clicked.
this : Ext.view.View
e : Ext.event.Event
The raw event object
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when a key is pressed down while the container is focused, and no item is currently selected.
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.
Fires when a key is pressed while the container is focused, and no item is currently selected.
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.
Fires when a key is released while the container is focused, and no item is currently selected.
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.
Fires when there is a mousedown on the container
this : Ext.view.View
e : Ext.event.Event
The raw event object
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when you move the mouse out of the container.
this : Ext.view.View
e : Ext.event.Event
The raw event object
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when you move the mouse over the container.
this : Ext.view.View
e : Ext.event.Event
The raw event object
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when there is a mouseup on the container
this : Ext.view.View
e : Ext.event.Event
The raw event object
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
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.
this : Ext.Component
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fired after a record is deselected
this : Ext.selection.RowModel
record : Ext.data.Model
The deselected record
index : Number
The row index deselected
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires after the component is method-destroyed.
Available since: 1.1.0
this : Ext.Component
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires after the component is disabled.
Available since: 1.1.0
this : Ext.Component
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when any Ext.Component is added or inserted as a docked item.
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.
Fires when any Ext.Component is removed from the docked items.
this : Ext.panel.Panel
component : Ext.Component
The component being removed
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires after the component is enabled.
Available since: 1.1.0
this : Ext.Component
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires after this Panel has expanded.
p : Ext.panel.Panel
The Panel that has been expanded.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fired whenever the filter set changes.
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.
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.
Fires when this Component receives focus.
this : Ext.Component
event : Ext.event.Event
The focus event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when focus enters this Component's hierarchy.
this : Ext.Component
event : Ext.event.Event
The focusenter event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when focus leaves this Component's hierarchy.
this : Ext.Component
event : Ext.event.Event
The focusleave event.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fired when the Panel glyph has been changed by the setGlyph method.
this : Ext.panel.Panel
newGlyph : Number/String
oldGlyph : Number/String
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fired whenever the grouping in the grid changes.
store : Ext.data.Store
The store.
grouper : Ext.util.Grouper
The grouper object.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
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
e : Ext.event.Event
t : HTMLElement
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
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
e : Ext.event.Event
t : HTMLElement
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires after the component is hidden. Fires after the component is hidden when calling the hide method.
Available since: 1.1.0
this : Ext.Component
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires after the Panel icon has been set or changed.
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.
Fires after the Panel iconCls has been set or changed.
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.
Fires when an item is clicked. Fires before the mousedown event on an item is processed. Return false to cancel the default action.
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.
Fires when an item is double clicked. Fires before the mousedown event on an item is processed. Return false to cancel the default action.
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.
Fires on a longpress event on an item. Fires before the mousedown event on an item is processed. Return false to cancel the default action.
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.
Fires when there is a mouse down on an item Fires before the mousedown event on an item is processed. Return false to cancel the default action.
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.
Fires when the mouse enters an item. Fires before the mousedown event on an item is processed. Return false to cancel the default action.
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.
Fires when the mouse leaves an item. Fires before the mousedown event on an item is processed. Return false to cancel the default action.
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.
Fires when there is a mouse up on an item Fires before the mousedown event on an item is processed. Return false to cancel the default action.
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.
Fires whenever the store reads data from a remote data source.
Note: If you are using a buffered store, you should use prefetch.
this : Ext.data.Store
records : Ext.data.Model[]
An array of records
successful : Boolean
True if the operation was successful.
operation : Ext.data.operation.Read
The Ext.data.operation.Read object that was used in the data load call
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when a column is locked.
this : Ext.grid.Panel
The gridpanel.
column : Ext.grid.column.Column
The column being locked.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires after the component is moved.
this : Ext.Component
x : Number
The new x position.
y : Number
The new y position.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when the configured (or reconfigured) column set is split into two depending on the locked flag.
lockedColumns : Ext.grid.column.Column[]
The locked columns.
normalColumns : Ext.grid.column.Column[]
The normal columns.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires after a property value has changed.
source : Object
The source data object for the grid (corresponds to the same object passed in as the source config property).
recordId : String
The record's id in the data store
value : Object
The current edited property value
oldValue : Object
The original property value prior to editing
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires after a reconfigure.
this : Ext.grid.Panel
store : Ext.data.Store
The store that was passed to the method-reconfigure method
columns : Object[]
The column configs that were passed to the method-reconfigure method
oldStore : Ext.data.Store
The store that was replaced
oldColumns : Ext.grid.column.Column[]
The column headers that were replaced.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires after any Ext.Component is removed from the container.
Available since: 2.3.0
this : Ext.container.Container
component : Ext.Component
The component that was removed
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when a component is removed from an Ext.container.Container
Available since: 3.4.0
this : Ext.Component
ownerCt : Ext.container.Container
Container which holds the component
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires after the component markup is rendered.
Available since: 1.1.0
this : Ext.Component
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
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.
This event does not fire on components that use cfg-liquidLayout, such as Ext.button.Button and Ext.form.field.Base.
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.
Fires when a row body element is clicked
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used. Fires before the mousedown event on a row body element is processed. Return false to cancel the default action.
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used.
view : Ext.view.View
The rowbody's owning View
rowBodyEl : HTMLElement
The row body's element
e : Ext.event.Event
The raw event object
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when a row body element is double clicked
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used. Fires before the mousedown event on a row body element is processed. Return false to cancel the default action.
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used.
view : Ext.view.View
The rowbody's owning View
rowBodyEl : HTMLElement
The row body's element
e : Ext.event.Event
The raw event object
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when a key is pressed down while a row body element is currently selected
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used. Fires before the mousedown event on a row body element is processed. Return false to cancel the default action.
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used.
view : Ext.view.View
The rowbody's owning View
rowBodyEl : HTMLElement
The row body's element
e : Ext.event.Event
The raw event object
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when a key is pressed while a row body element is currently selected.
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used. Fires before the mousedown event on a row body element is processed. Return false to cancel the default action.
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used.
view : Ext.view.View
The rowbody's owning View
rowBodyEl : HTMLElement
The row body's element
e : Ext.event.Event
The raw event object
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when a key is released while a row body element is currently selected
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used. Fires before the mousedown event on a row body element is processed. Return false to cancel the default action.
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used.
view : Ext.view.View
The rowbody's owning View
rowBodyEl : HTMLElement
The row body's element
e : Ext.event.Event
The raw event object
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires on a row body element longpress event
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used. Fires before the mousedown event on a row body element is processed. Return false to cancel the default action.
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used.
view : Ext.view.View
The rowbody's owning View
rowBodyEl : HTMLElement
The row body's element
e : Ext.event.Event
The raw event object
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when there is a mouse down on a row body element
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used. Fires before the mousedown event on a row body element is processed. Return false to cancel the default action.
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used.
view : Ext.view.View
The rowbody's owning View
rowBodyEl : HTMLElement
The row body's element
e : Ext.event.Event
The raw event object
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when there is a mouse up on a row body element
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used. Fires before the mousedown event on a row body element is processed. Return false to cancel the default action.
Note: This event is fired only when the Ext.grid.feature.RowBody feature is used.
view : Ext.view.View
The rowbody's owning View
rowBodyEl : HTMLElement
The row body's element
e : Ext.event.Event
The raw event object
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fired when a table row is clicked.
this : Ext.view.Table
record : Ext.data.Model
element : HTMLElement
The TR element for the row.
rowIndex : Number
e : Ext.event.Event
position : Ext.grid.CellContext
A CellContext object which defines the target row.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fired when table row is double clicked.
this : Ext.view.Table
record : Ext.data.Model
element : HTMLElement
The TR element for the row.
rowIndex : Number
e : Ext.event.Event
position : Ext.grid.CellContext
A CellContext object which defines the target row.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fired when the keydown event is captured on the row.
this : Ext.view.Table
record : Ext.data.Model
element : HTMLElement
The TR element for the row.
rowIndex : Number
e : Ext.event.Event
position : Ext.grid.CellContext
A CellContext object which defines the target row.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fired when the mousedown event is captured on the row.
this : Ext.view.Table
record : Ext.data.Model
tr : HTMLElement
The TR element for the row.
rowIndex : Number
e : Ext.event.Event
position : Ext.grid.CellContext
A CellContext object which defines the target row.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fired when the mouseup event is captured on the row.
this : Ext.view.Table
record : Ext.data.Model
element : HTMLElement
The TR element for the row.
rowIndex : Number
e : Ext.event.Event
position : Ext.grid.CellContext
A CellContext object which defines the target row.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fired after a record is selected
this : Ext.selection.RowModel
record : Ext.data.Model
The selected record
index : Number
The row index selected
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fired after a selection change has occurred
this : Ext.selection.Model
selected : Ext.data.Model[]
The selected records
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
An event fired when an extension block is dragged to encompass a new range. Only fired when the SpreadsheetSelectionModel is used and configured with the extensible config.
grid : Ext.panel.Table
The owning grid.
An : Ext.grid.selection.Selection
object which encapsulates a contiguous selection block.
extension : Object
An object describing the type and size of extension.
type : String
"rows"
or "columns"
overCell : HTMLElement
The grid cell over which the mouse is being dragged.
start : Ext.grid.CellContext
The start (top left) cell of the extension area.
end : Ext.grid.CellContext
The end (bottom right) cell of the extension area.
columns : Number (optional)
The number of columns extended (-ve means on the left side).
rows : Number (optional)
The number of rows extended (-ve means on the top side).
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires after the component is shown when calling the show method.
Available since: 1.1.0
this : Ext.Component
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
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.
Fires after the state of the object is restored.
this : Ext.state.Stateful
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.
Fires after the state of the object is saved to the configured state provider.
this : Ext.state.Stateful
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.
Fires after the Panel title has been set or changed.
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.
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.
Fires when a column is unlocked.
this : Ext.grid.Panel
The gridpanel.
column : Ext.grid.column.Column
The column being unlocked.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when the grid view is available (use this for selecting a default row).
this : Ext.panel.Table
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
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
The border-width of the lockable grid body border
Defaults to:
$grid-body-border-width
The border-color of the border between the locked views. Defaults to the panel border color. May be overridden in a theme.
Defaults to:
$panel-border-color
The border-style of the border between the locked views
Defaults to:
solid
The width of the border between the locked views
Defaults to:
1px
The background-image of property grid cells
Defaults to:
'none'
The background-position of property grid cells
Defaults to:
'none'
The padding to add before the text of property grid cells to make room for the background-image. Only applies if $grid-property-cell-background-image is not null
Defaults to:
'none'
True to include the "default-framed" panel UI
Defaults to:
$include-default-uis
True to include the "default" panel UI
Defaults to:
$include-default-uis
True to include the "light-framed" panel UI
Defaults to:
$include-default-uis
True to include the "light" panel UI
Defaults to:
$include-default-uis
The direction to strech the background-gradient of bottom docked Headers when slicing images for IE using Sencha Cmd
Defaults to:
top
The direction to strech the background-gradient of left docked Headers when slicing images for IE using Sencha Cmd
Defaults to:
right
The direction to strech the background-gradient of right docked Headers when slicing images for IE using Sencha Cmd
Defaults to:
left
The direction to strech the background-gradient of top docked Headers when slicing images for IE using Sencha Cmd
Defaults to:
bottom
The default border-color of the Panel body
Defaults to:
$panel-border-color
The default font-family of the Panel body
Defaults to:
$font-family
The default font-weight of the Panel body
Defaults to:
$font-weight
The border-width of the body element of framed Panels
Defaults to:
1px
The border-color of framed Panels
Defaults to:
$panel-border-color
The border-width of framed Panel Headers
Defaults to:
$panel-header-border-width
The inner border-color of framed Panel Headers
Defaults to:
#fff
The inner border-width of framed Panel Headers
Defaults to:
0
The padding of framed Panel Headers
Defaults to:
$panel-header-padding
The padding of framed Panels.
The padding value must be equal to or greater than value specified in the $panel-frame-border-radius variable (or the maximum value if corner values are specified individually). See also: $panel-ignore-frame-padding
Defaults to:
4px
The background-color of the Panel Header
Defaults to:
$panel-base-color
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'
The border-color of the Panel Header
Defaults to:
$panel-border-color
The border-width of Panel Headers
Defaults to:
$panel-border-width
The color of the Panel Header glyph icon
Defaults to:
$panel-header-color
The background-position of the Panel Header icon
Defaults to:
center center
The space between the Panel Header icon and text
Defaults to:
4px
The inner border-color of the Panel Header
Defaults to:
#fff
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
The margin of the Panel Header's text element
Defaults to:
0
The padding of the Panel Header's text element
Defaults to:
0
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.
Note: This var is not applicable to IE8 & IE9.
Defaults to:
false
True to include neptune style border management rules.
Defaults to:
false
The background sprite to use for Panel Ext.panel.Tool
Defaults to:
'tools/tool-sprites'
The color of the outline around Panel Ext.panel.Tool when focused
Defaults to:
$base-color
The outline-offset of Panel Ext.panel.Tool when focused
Defaults to:
0
The outline-style of Panel Ext.panel.Tool when focused
Defaults to:
solid
The outline-width of Panel Ext.panel.Tool when focused
Defaults to:
1px
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
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
Creates a visual theme for a Panel.
Note: When using frame: true
, this mixin call creates a UI property with the name and a "-framed" suffix.
For example, Panel's UI will be set to "highlight-framed" if frame:true
.
$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-tool-glyph-color : color (optional)
The color to use for tool icons when Global_CSS#$enable-font-icons is true
.
Defaults to: $tool-glyph-color
$ui-tool-focus-outline-color : color (optional)
The color of the outline around Panel Ext.panel.Tool when focused
Defaults to: $panel-tool-focus-outline-color
$ui-tool-focus-outline-style : String (optional)
The outline-style of Panel Ext.panel.Tool when focused
Defaults to: $panel-tool-focus-outline-style
$ui-tool-focus-outline-width : Number (optional)
The outline-width of Panel Ext.panel.Tool when focused
Defaults to: $panel-tool-focus-outline-width
$ui-tool-focus-outline-offset : Number (optional)
The outline-offset of Panel Ext.panel.Tool when focused
Defaults to: $panel-tool-focus-outline-offset
$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