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.
Provides a date input field with a Ext.picker.Date dropdown and automatic date validation.
This field recognizes and uses the JavaScript Date object as its main value type. In addition, it recognizes string values which are parsed according to the format and/or altFormats configs. These may be reconfigured to use date formats appropriate for the user's locale.
The field may be limited to a certain range of dates by using the minValue, maxValue, disabledDays, and disabledDates config parameters. These configurations will be used both in the field's validation, and in the date picker dropdown by preventing invalid dates from being selected.
This example shows a couple of different date format parsing scenarios. Both use custom date format
configurations; the first one matches the configured format while the second matches the altFormats.
An incrementing numeric counter indicating activation index for use by the zIndexManager to sort its stack.
Defaults to:
0
If specified, then the component will be displayed with this value as its active error when first rendered. Use setActiveError or unsetActiveError to change it after component creation.
Gets the active error message for this component, if any. This does not trigger validation on its own, it merely returns any message that the component may already hold.
The active error message on the component; if there is no error, an empty string is returned.
Sets the active error message to the given string. This replaces the entire error message contents with the given string. Also see setActiveErrors which accepts an Array of messages and formats them according to the activeErrorsTpl. Note that this only updates the error message element's text and attributes, you'll have to call doComponentLayout to actually update the field's layout to match. If the field extends Ext.form.field.Base you should call markInvalid instead.
msg : String
The error message
The template used to format the Array of error messages passed to setActiveErrors into a single HTML string. if the msgTarget is title, it defaults to a list separated by new lines. Otherwise, it renders each message as an item in an unordered list.
Defaults to:
undefined
An optional string or XTemplate configuration to insert in the field markup
at the end of the input containing element. If an XTemplate is used, the component's render data
serves as the context.
An optional string or XTemplate configuration to insert in the field markup
after the label text. If an XTemplate is used, the component's render data
serves as the context.
An optional string or XTemplate configuration to insert in the field markup
after the label element. If an XTemplate is used, the component's render data
serves as the context.
An optional string or XTemplate configuration to insert in the field markup
after the subTpl markup. If an XTemplate is used, the
component's render data serves as the context.
A Component or Element by which to position this component according to the defaultAlign. Defaults to ths owning Container.
Only applicable if this component is floating
Used upon first show.
Defaults to:
null
Specify false to validate that the value's length must be > 0. If true, then a blank value is always taken to be valid regardless of any vtype
validation that may be applied.
If vtype validation must still be applied to blank values, configure validateBlank as true;
Defaults to:
true
Specify false to automatically trim the value before validating the whether the value is blank. Setting this to false automatically sets allowBlank to false.
Defaults to:
true
Multiple date formats separated by "|" to try when parsing a user input value and it does not match the defined format.
Defaults to:
"m/d/Y|n/j/Y|n/j/y|m/j/y|n/d/y|m/j/Y|n/d/Y|m-d-y|m-d-Y|m/d|m-d|md|mdy|mdY|d|Y-m-d|n-j|n/j"
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
A tag name or Ext.dom.Helper spec used to create the Element which will encapsulate this Component.
You do not normally need to specify this. For the base classes Ext.Component and Ext.container.Container, this defaults to 'div'. The more complex Sencha classes use a more complex DOM structure specified by their own renderTpls.
This is intended to allow the developer to create application-specific utility Components encapsulated by different DOM elements. Example usage:
{
xtype: 'component',
autoEl: {
tag: 'img',
src: 'http://www.example.com/example.jpg'
}
}, {
xtype: 'component',
autoEl: {
tag: 'blockquote',
html: 'autoEl is cool!'
}
}, {
xtype: 'container',
autoEl: 'ul',
cls: 'ux-unordered-list',
items: {
xtype: 'component',
autoEl: 'li',
html: 'First list item'
}
}
Available since: 2.3.0
Whether to adjust the component's body width to make room for 'side' error messages.
Defaults to:
true
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
Sets the overflow on the content element of the component.
scroll : Boolean
True to allow the Component to auto scroll.
this
true to automatically show the component upon creation. This config option may only be used for
floating components or components that use autoRender.
Defaults to:
false
Available since: 2.3.0
The CSS class to be applied to the body content element.
Defaults to:
Ext.baseCSSPrefix + 'form-item-body'
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'
An optional string or XTemplate configuration to insert in the field markup
at the beginning of the input containing element. If an XTemplate is used, the component's render data
serves as the context.
An optional string or XTemplate configuration to insert in the field markup
before the label text. If an XTemplate is used, the component's render data
serves as the context.
An optional string or XTemplate configuration to insert in the field markup
before the label element. If an XTemplate is used, the component's render data
serves as the context.
An optional string or XTemplate configuration to insert in the field markup
before the subTpl markup. If an XTemplate is used, the
component's render data serves as the context.
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
The error text to display if the allowBlank validation fails
Defaults to:
'This field is required'
Specifies the border size for this component. The border 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).
For components that have no border by default, setting this won't make the border appear by itself. You also need to specify border color and style:
border: 5,
style: {
borderColor: 'red',
borderStyle: 'solid'
}
To turn off the border, use border: false.
Defines a timeout in milliseconds for buffering checkChangeEvents that fire in rapid succession. Defaults to 50 milliseconds.
Defaults to:
50
A list of event names that will be listened for on the field's input element, which will cause the field's value to be checked for changes. If a change is detected, the change event will be fired, followed by validation if the validateOnChange option is enabled.
Defaults to ['change', 'propertychange', 'keyup'] in Internet Explorer, and ['change', 'input', 'textInput', 'keyup', 'dragdrop'] in other browsers. This catches all the ways that field values can be changed in most supported browsers; the only known exceptions at the time of writing are:
If you need to guarantee on-the-fly change notifications including these edge cases, you can call the checkChange method on a repeating interval, e.g. using Ext.TaskManager, or if the field is within a Ext.form.Panel, you can use the FormPanel's Ext.form.Panel#pollForChanges configuration to set up such a task automatically.
Defaults to:
Ext.isIE && (!document.documentMode || document.documentMode <= 9) ? [
'change',
'propertychange',
'keyup'
] : [
'change',
'input',
'textInput',
'keyup',
'dragdrop'
]
The canonical form of childEls is an object keyed by child's property name
with values that are objects with the following properties.
itemId - The id to combine with the Component's id that is the id of the
child element.id - The id of the child element.leaf - Set to true to ignore content when scanning for childEls. This
should be set on things like the generated content for an Ext.view.View.select: A selector that will be passed to Ext.dom.Element#select.selectNode: A selector that will be passed to Ext.dom.Element#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:
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'
}
}
An optional extra CSS class that will be added to this component's Element. This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
Defaults to:
''
Available since: 1.1.0
Defines the column width inside Ext.layout.container.Column.
Can be specified as a number or as a percentage.
Defaults to:
undefined
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 this Components within its containing element, false to allow it to fall outside of its containing
element. By default this Component will be rendered to document.body. To render and constrain this Component within
another element specify renderTo.
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
Sets the value of controller
controller : String / Object / Ext.app.ViewController
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 floating
Used upon first show.
Defaults to:
"c-c"
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
The CSS class to use when the field value is dirty.
Defaults to:
Ext.baseCSSPrefix + 'form-dirty'
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'
An array of "dates" to disable, as strings. These strings will be used to build a dynamic regular expression so they are very powerful. Some examples:
// disable these exact dates:
disabledDates: ["03/08/2003", "09/16/2003"]
// disable these days for every year:
disabledDates: ["03/08", "09/16"]
// only match the beginning (useful if you are using short years):
disabledDates: ["^03/08"]
// disable every day in March 2006:
disabledDates: ["03/../2006"]
// disable every day in every March:
disabledDates: ["^03"]
Note that the format of the dates included in the array should exactly match the format config. In order
to support regular expressions, if you are using a date format that has "." in it, you will have
to escape the dot when restricting dates. For example: ["03\\.08\\.03"].
Replaces any existing disabled dates with new values and refreshes the Date picker.
disabledDates : String[]
An array of date strings (see the disabledDates config for details on supported values) used to disable a pattern of dates.
The tooltip text to display when the date falls on a disabled date.
Defaults to:
"Disabled"
An array of days to disable, 0 based. Some examples:
// disable Sunday and Saturday:
disabledDays: [0, 6]
// disable weekdays:
disabledDays: [1,2,3,4,5]
Replaces any existing disabled days (by index, 0-6) with new values and refreshes the Date picker.
disabledDays : Number[]
An array of disabled day indexes. See the disabledDays config for details on supported values.
The tooltip to display when the date falls on a disabled day.
Defaults to:
"Disabled"
Specify as true to make a floating Component draggable using the Component's encapsulating element as the drag handle.
This may also be specified as a config object for the Ext.util.ComponentDragger which is instantiated to perform dragging.
For example to create a Component which may only be dragged around using a certain internal element as the drag handle, use the delegate option:
new Ext.Component({
constrain: true,
floating: true,
style: {
backgroundColor: '#fff',
border: '1px solid black'
},
html: '<h1 style="cursor:move">The title</h1><p>The content</p>',
draggable: {
delegate: 'h1'
}
}).show();
Defaults to:
false
False to prevent the user from typing text directly into the field; the field can only have its value set via selecting a value from the picker. In this state, the picker can also be opened by clicking directly on the input field itself.
Defaults to:
true
Sets the editable state of this field.
editable : Boolean
True to allow the user to directly edit the field text. If false is passed, the user will only be able to modify the field using the trigger.
The CSS class to apply to an empty field to style the emptyText. This class is automatically added and removed as needed depending on the current field value.
Defaults to:
'x-form-empty-field'
The default text to place into an empty field.
Note that normally this value will be submitted to the server if this field is enabled; to prevent this you can set the submitEmptyText option of Ext.form.Basic#submit to false.
Also note that if you use inputType:'file', emptyText is not supported and should be avoided.
Note that for browsers that support it, setting this property will use the HTML 5 placeholder attribute, and for older browsers that don't support the HTML 5 placeholder attribute the value will be placed directly into the input element itself as the raw value. This means that older browsers will obfuscate the emptyText value for password input fields.
true to enable the proxying of key events for the HTML input field
Defaults to:
false
True to set the maxLength property on the underlying input field. Defaults to false
The CSS class to be applied to the error message element.
Defaults to:
Ext.baseCSSPrefix + 'form-error-msg'
An extra CSS class to be applied to the body content element in addition to baseBodyCls.
Defaults to:
''
The label for the field. It gets appended with the labelSeparator, and its position and sizing is determined by the labelAlign and labelWidth configs.
Defaults to:
undefined
Returns the label for the field. Defaults to simply returning the fieldLabel config. Can be overridden to provide a custom generated label.
The configured field label, or empty string if not defined
This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.
Set the label of this field.
label : String
The new label. The labelSeparator will be automatically appended to the label string.
Optional CSS style(s) to be applied to the field input element. Should be a valid argument to Ext.dom.Element#applyStyles. Defaults to undefined. See also the setFieldStyle method for changing the style after initialization.
Set the CSS style of the field input element.
style : String/Object/Function
The style(s) to apply. Should be a valid argument to Ext.dom.Element#applyStyles.
The content of the field body is defined by this config option.
Defaults to:
[
// note: {id} here is really {inputId}, but {cmpId} is available
'<input id="{id}" data-ref="inputEl" type="{type}" role="{role}" {inputAttrTpl}',
' size="1"',
// allows inputs to fully respect CSS widths across all browsers
'<tpl if="name"> name="{name}"</tpl>',
'<tpl if="value"> value="{[Ext.util.Format.htmlEncode(values.value)]}"</tpl>',
'<tpl if="placeholder"> placeholder="{placeholder}"</tpl>',
'{%if (values.maxLength !== undefined){%} maxlength="{maxLength}"{%}%}',
'<tpl if="readOnly"> readonly="readonly"</tpl>',
'<tpl if="disabled"> disabled="disabled"</tpl>',
'<tpl if="tabIdx != null"> tabindex="{tabIdx}"</tpl>',
'<tpl if="fieldStyle"> style="{fieldStyle}"</tpl>',
' class="{fieldCls} {typeCls} {typeCls}-{ui} {editableCls} {inputCls}" autocomplete="off"/>',
{
disableFormats: true
}
]
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
Specify as true to float the Component outside of the document flow using CSS absolute positioning.
Components such as Ext.window.Windows and Ext.menu.Menus are floating by default.
Floating Components that are programatically rendered will register themselves with the global Ext.WindowManager
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
Specifies whether the floated component should be automatically focused when it is brought to the front.
Defaults to:
true
The default date format string which can be overriden for localization support. The format must be valid according to Ext.Date#parse.
Defaults to:
"m/d/Y"
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
A CSS class to be applied to the outermost element to denote that it is participating in the form field layout.
Defaults to:
Ext.baseCSSPrefix + 'form-item'
Specify as true to have the Component inject framing elements within the Component at render time to provide a
graphical rounded frame around the Component content.
This is only necessary when running on outdated, or non standard-compliant browsers such as Microsoft's Internet Explorer prior to version 9 which do not support rounded corners natively.
The extra space taken up by this framing is available from the read only property frameSize.
A string that will be appended to the field's current value for the purposes of calculating the target field size. Only used when the grow config is true. Defaults to a single capital "W" (the widest character in common fonts) to leave enough space for the next typed character and avoid the field value shifting before the width is adjusted.
Defaults to:
'W'
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:
this
When set to true, the label element (fieldLabel and labelSeparator) will be automatically hidden if the fieldLabel is empty. Setting this to false will cause the empty label element to be rendered and space to be reserved for it; this is useful if you want a field without a label to line up with other labeled fields in the same form.
If you wish to unconditionall hide the label even if a non-empty fieldLabel is configured, then set the hideLabel config to true.
Defaults to:
true
Set to true to completely hide the label element (fieldLabel and labelSeparator). Also see hideEmptyLabel, which controls whether space will be reserved for an empty fieldLabel.
Defaults to:
false
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
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
An optional string or XTemplate configuration to insert in the field markup
inside the input element (as attributes). If an XTemplate is used, the component's
subTpl data serves as the context.
The id that will be given to the generated input DOM element. Defaults to an automatically generated id. If you configure this manually, you must make sure it is unique in the document.
Returns the input id for this field. If none was specified via the inputId config, then an id will be automatically generated.
The type attribute for input fields -- e.g. radio, text, password, file. The extended types supported by HTML5 inputs (url, email, etc.) may also be used, though using them will cause older browsers to fall back to 'text'.
The type 'password' must be used to render that field type currently -- there is no separate Ext component for that. You can use Ext.form.field.File which creates a custom-rendered file upload field, but if you want a plain unstyled file input you can use a Base with inputType:'file'.
Defaults to:
'text'
The CSS class that is added to the element wrapping the input element
Defaults to:
Ext.baseCSSPrefix + 'form-text-wrap'
The CSS class to use when marking the component invalid.
Defaults to:
Ext.baseCSSPrefix + 'form-invalid'
The error text to display when the date in the field is invalid.
Defaults to:
"{0} is not a valid date - it must be in the format {1}"
true if this field renders as a text input.
Defaults to:
true
Available since: 5.0.1
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()
p2 = p1.ownerCt.getComponent('p2'); // reference via a sibling
Also see id, Ext.container.Container#query, Ext.container.Container#down and
Ext.container.Container#child.
Note: Valid identifiers start with a letter or underscore and are followed by (optional) additional letters, underscores, digits or hyphens.
Note: to access the container of an item see ownerCt.
Available since: 3.4.0
The rendering template for the field decorations. Component classes using this mixin should include logic to use this as their renderTpl, and implement the getSubTplMarkup method to generate the field body content.
Defaults to:
[
'{beforeLabelTpl}',
'<label id="{id}-labelEl" data-ref="labelEl" class="{labelCls} {labelCls}-{ui} {labelClsExtra} ',
'{unselectableCls}" style="{labelStyle}"<tpl if="inputId">',
' for="{inputId}"</tpl> {labelAttrTpl}>',
'<span class="{labelInnerCls} {labelInnerCls}-{ui}" style="{labelInnerStyle}">',
'{beforeLabelTextTpl}',
'<tpl if="fieldLabel">{fieldLabel}',
'<tpl if="labelSeparator">{labelSeparator}</tpl>',
'</tpl>',
'{afterLabelTextTpl}',
'</span>',
'</label>',
'{afterLabelTpl}',
'<div id="{id}-bodyEl" data-ref="bodyEl" class="{baseBodyCls} {baseBodyCls}-{ui}<tpl if="fieldBodyCls">',
' {fieldBodyCls} {fieldBodyCls}-{ui}</tpl> {growCls} {extraFieldBodyCls}"',
'<tpl if="bodyStyle"> style="{bodyStyle}"</tpl>>',
'{beforeBodyEl}',
'{beforeSubTpl}',
'{[values.$comp.getSubTplMarkup(values)]}',
'{afterSubTpl}',
'{afterBodyEl}',
'</div>',
'<tpl if="renderError">',
'<div id="{id}-errorWrapEl" data-ref="errorWrapEl" class="{errorWrapCls} {errorWrapCls}-{ui}',
' {errorWrapExtraCls}" style="{errorWrapStyle}">',
'<div role="alert" aria-live="polite" id="{id}-errorEl" data-ref="errorEl" ',
'class="{errorMsgCls} {invalidMsgCls} {invalidMsgCls}-{ui}" ',
'data-anchorTarget="{id}-inputEl">',
'</div>',
'</div>',
'</tpl>',
{
disableFormats: true
}
]
Controls the position and alignment of the fieldLabel. Valid values are:
Defaults to:
'left'
An optional string or XTemplate configuration to insert in the field markup
inside the label element (as attributes). If an XTemplate is used, the component's
render data serves as the context.
The CSS class to be applied to the label element. This (single) CSS class is used to formulate the renderSelector and drives the field layout where it is concatenated with a hyphen ('-') and labelAlign. To add additional classes, use labelClsExtra.
Defaults to:
Ext.baseCSSPrefix + 'form-item-label'
An optional string of one or more additional CSS classes to add to the label element. Defaults to empty.
The amount of space in pixels between the fieldLabel and the field body.
This defaults to 5 for compatibility with Ext JS 4, however, as of Ext JS 5
the space between the label and the body can optionally be determined by the theme
using the $form-label-horizontal-spacing (for side-aligned labels) and
$form-label-vertical-spacing (for top-aligned labels) SASS variables.
In order for the stylesheet values as to take effect, you must use a labelPad value
of null.
Defaults to:
5
Character(s) to be inserted at the end of the label text.
Set to empty string to hide the separator completely.
Defaults to:
':'
The width of the fieldLabel in pixels. Only applicable if labelAlign is set to "left" or "right".
Defaults to:
100
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'); }
}
}
});
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.
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).
Related to the cfg-childEls configuration which specifies named properties which correspond to component sub-elements.
The name of the element property in this component to mask when masked by a LoadMask.
Defaults to null to indicate that Components cannot by default contain a LoadMask, and that any LoadMask should be rendered into the document body.
For example, Panels use "el" to indicate that the whole panel should be masked. 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:
null
An input mask regular expression that will be used to filter keystrokes (character being typed) that do not match. Note: It does not filter characters already in the input.
Whether the picker dropdown's width should be explicitly set to match the width of the field. Defaults to true.
Defaults to:
true
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
Maximum input field length allowed by validation. This behavior is intended to provide instant feedback to the user by improving usability to allow pasting and editing or overtyping and back tracking. To restrict the maximum number of characters that can be entered into the field use the enforceMaxLength option.
Defaults to Number.MAX_VALUE.
Defaults to:
Number.MAX_VALUE
Error text to display if the maximum length validation fails
Defaults to:
'The maximum length for this field is {0}'
The error text to display when the date in the cell is after maxValue.
Defaults to:
"The date in this field must be equal to or before {0}"
The maximum allowed date. Can be either a Javascript date object or a string date in a valid format.
Replaces any existing maxValue with the new value and refreshes the Date picker.
value : Date
The maximum date that can be selected
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
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
Error text to display if the minimum length validation fails.
Defaults to:
'The minimum length for this field is {0}'
The error text to display when the date in the cell is before minValue.
Defaults to:
"The date in this field must be equal to or after {0}"
The minimum allowed date. Can be either a Javascript date object or a string date in a valid format.
Replaces any existing minValue with the new value and refreshes the Date picker.
value : Date
The minimum date that can be selected
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
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.
The location where the error message text should display. Must be one of the following values:
qtip Display a quick tip containing the message when the user hovers over the field.
This is the default.
Ext.tip.QuickTipManager#init must have been called for this setting to work.
title Display the message in a default browser title attribute popup.
under Add a block div beneath the field containing the error message.side Add an error icon to the right of the field, displaying the message in a popup on hover.none Don't display any error message. This might be useful if you are implementing custom error display.[element id] Add the error message directly to the innerHTML of the specified element.Defaults to:
'qtip'
The name of the field. This is used as the parameter name when including the field value in a form submit(). If no name is configured, it falls back to the inputId. To prevent the field from being included in the form submit, set submitValue to false.
Returns the name attribute of the field. This is used as the parameter name when including the field value in a form submit().
name The field name
A class to be added to the field's bodyEl element when the picker is opened.
Defaults to:
'x-pickerfield-open'
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.
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.
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).
The alignment position with which to align the picker. Defaults to "tl-bl?"
Defaults to:
'tl-bl?'
An offset [x,y] to use in addition to the pickerAlign when positioning the picker. Defaults to undefined.
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
true to disable displaying any error message set on this object.
Defaults to:
false
One or more names of config properties that this component should publish to
its ViewModel. Some components override this and publish their most useful
configs by default.
This config uses the 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
}
}
Defaults to:
null
Available since: 5.0.0
true to prevent the user from changing the field, and hide all triggers.
Sets the read-only state of this field.
readOnly : Boolean
True to prevent the user changing the field and explicitly hide the trigger(s). Setting this to true will supersede settings editable and hideTrigger. Setting this to false will defer back to editable and hideTrigger.
The CSS class applied to the component's main element when it is readOnly.
Defaults to:
Ext.baseCSSPrefix + 'form-readonly'
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
A JavaScript RegExp object to be tested against the field value during validation. If the test fails, the field will be marked invalid using either regexText or invalidText.
The error text to display if regex is used and the test fails during validation
Defaults to:
''
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.
A Region containing "top, left, bottom, right" properties.
The data used by 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 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 Ext JS and Sencha Touch
classes which use a more complex DOM structure, provide their own template definitions.
This is intended to allow the developer to create application-specific utility Components with customized internal structure.
Upon rendering, any created child elements may be automatically imported into object properties using the renderSelectors and cfg-childEls options.
Defaults to:
[
'<tpl if="renderScroller">',
'<div class="{scrollerCls}" style="{%this.renderPadding(out, values)%}">',
'</tpl>',
'{%this.renderContent(out,values)%}',
'<tpl if="renderScroller"></div></tpl>'
]
true to attach a Ext.util.ClickRepeater to the trigger(s).
Click repeating behavior can also be configured on the individual {@link #cfg!triggers trigger instances using the trigger's repeatClick config.
Defaults to:
false
The CSS class to apply to a required field, i.e. a field where allowBlank is false.
Defaults to:
'x-form-required-field'
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'
A buffer to be applied if many state events are fired within a short period.
Defaults to:
100
true to automatically select any existing field text when the field receives input
focus. Only applies when editable = true
Defaults to:
false
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'
false to hide the footer area of the Date picker containing the Today button and disable the keyboard handler for spacebar that selects the current date.
Defaults to:
true
If this property is a number, it is interpreted as follows:
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. Some container layouts always shrink-wrap their children, effectively ignoring this property (e.g., Ext.layout.container.HBox, Ext.layout.container.VBox, Ext.layout.component.Dock).
Defaults to:
2
An initial value for the 'size' attribute on the text input element. This is only used if the field has no configured width and is not given a width by its container's layout. Defaults to 20.
Deprecated
use width instead.
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:
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
Day index at which the week should begin, 0-based.
Defaults to 0 (Sunday).
Defaults to:
undefined
<An array of events that, when fired, should trigger this object to
save its state. Defaults to none. 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.
A flag which causes the object to attempt to restore the state of internal properties from a saved state on startup. The object must have a stateId for state to be managed.
Auto-generated ids are not guaranteed to be stable across page loads and cannot be relied upon to save and restore the same state for a object.
For state saving to work, the state manager's provider must have been set to an implementation of Ext.state.Provider which overrides the set and get methods to save and recall name/value pairs. A built-in implementation, Ext.state.CookieProvider is available.
To set the state provider for the current page:
Ext.state.Manager.setProvider(new Ext.state.CookieProvider({ expires: new Date(new Date().getTime()+(10006060247)), //7 days from now }));
A stateful object attempts to save state when one of the events listed in the stateEvents configuration fires.
To save state, a stateful object first serializes its state by calling getState.
The Component base class implements getState to save its width and height within the state only if they were initially configured, and have changed from the configured value.
The Panel class saves its collapsed state in addition to that.
The Grid class saves its column state and store state (sorters and filters and grouper) in addition to its superclass state.
If there is more application state to be save, the developer must provide an implementation which first calls the superclass method to inherit the above behaviour, and then injects new properties into the returned object.
The value yielded by getState is passed to Ext.state.Manager#set which uses the configured Ext.state.Provider to save the object keyed by the stateId.
During construction, a stateful object attempts to restore its state by calling Ext.state.Manager#get passing the stateId
The resulting object is passed to applyState*. The default implementation of applyState simply copies properties into the object, but a developer may override this to support restoration of more complex application state.
You can perform extra processing on state save and restore by attaching handlers to the beforestaterestore, staterestore, beforestatesave and statesave events.
Defaults to:
false
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.
A JavaScript RegExp object used to strip unwanted content from the value
during input. If stripCharsRe is specified,
every character sequence matching stripCharsRe will be removed.
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.
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 date format string which will be submitted to the server. The format must be valid according to Ext.Date#parse.
Defaults to format.
Setting this to false will prevent the field from being submitted even when it is not disabled.
Defaults to:
true
Returns the value that would be included in a standard form submit for this field. This will be combined with the field's name to form a name=value pair in the submitted parameters. If an empty string is returned then just the name= will be submitted; if null is returned then nothing will be submitted.
Note that the value returned will have been processed but may or may not have been successfully validated.
The value to be submitted, or null.
The tabIndex for this field. Note this only applies to fields that are rendered, not those which are built via applyTo
Return the actual tabIndex for this Focusable.
tabIndex attribute value
Set the tabIndex property for this Focusable. If the focusEl is avalable, set tabIndex attribute on it, too.
newTabIndex : Number
new tabIndex to set
True to automatically call toFront when the method-show method is called on an already visible, floating component.
Defaults to:
true
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
An additional CSS class used to style the trigger button. The trigger will always get the class 'x-form-trigger' and triggerCls will be appended if specified (default class displays a calendar icon).
Defaults to:
'x-form-date-trigger'
Ext.form.trigger.Trigger to use in this field. The keys in this object are unique identifiers for the triggers. The values in this object are Ext.form.trigger.Trigger configuration objects.
Defaults to:
undefined
The CSS class that is added to the div wrapping the input element and trigger button(s).
Defaults to:
Ext.baseCSSPrefix + 'form-trigger-wrap'
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:
[]
True to enforce strict date parsing to prevent the default Javascript "date rollover". Defaults to the useStrict parameter set on Ext.Date See Ext.Date#parse.
Defaults to:
undefined
Specify as true to modify the behaviour of allowBlank so that blank values are not passed as valid, but are subject to any configure vtype validation.
Defaults to:
false
Whether the field should validate when it loses focus. This will cause fields to be validated as the user steps through the fields in the form regardless of whether they are making changes to those fields along the way. See also validateOnChange.
Defaults to:
true
Specifies whether this field should be validated immediately whenever a change in its value is detected. If the validation results in a change in the field's validity, a validitychange event will be fired. This allows the field to show feedback about the validity of its contents immediately as the user is typing.
When set to false, feedback will not be immediate. However the form will still be validated before submitting if the clientValidation option to Ext.form.Basic#doAction is enabled, or if the field or form are validated manually.
See also Ext.form.field.Base#checkChangeEvents for controlling how changes to the field's value are detected.
Defaults to:
true
This property, when a String, contributes its value to the error state of this
instance as reported by getErrors.
Defaults to:
null
When binding is used with a model, this maps to the underlying Ext.data.field.Field if it is available. This can be used to validate the value against the model field without needing to push the value back into the model.
Defaults to:
null
Sets the value of validationField
validationField : Ext.data.field.Field
A custom validation function to be called during field validation (getErrors). If specified, this function will be called first, allowing the developer to override the default validation process.
This function will be passed the following parameters:
value : Object
The current field value
return : Boolean/String
A value to initialize this field with.
Returns the current data value of the field. The type of value returned is particular to the type of the particular field (e.g. a Date object for Ext.form.field.Date), as the result of calling rawToValue on the field's processed String value. To return the raw String value, see getRawValue.
value The field value
Sets the value of the date field. You can pass a date object or any string that can be parsed into a valid date, using format as the date format, according to the same rules as Ext.Date#parse (the default format used is "m/d/Y").
Usage:
//All of these calls set the same date value (May 4, 2006)
//Pass a date object:
var dt = new Date('5/4/2006');
dateField.setValue(dt);
//Pass a date string (default format):
dateField.setValue('05/04/2006');
//Pass a date string (custom format):
dateField.format = 'Y-m-d';
dateField.setValue('2006-05-04');
date : String/Date
The date or valid date string
this
The event name(s) to use to publish the value bind for this field.
Defaults to:
'change'
Available since: 5.0.1
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
A custom error message to display in place of the default message provided for the vtype currently
set for this field. Note: only applies if vtype is set, else ignored.
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.
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:
false
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
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
true indicates an id was auto-generated rather than provided by configuration.
Defaults to:
false
Template method to do any pre-blur processing.
Defaults to:
Ext.emptyFn
e : Ext.event.Event
The event object
Template method to do any pre-focus processing.
Defaults to:
Ext.emptyFn
e : Ext.event.Event
The event object
The div Element wrapping the component's contents. Only available after the component has been rendered.
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:
'padding'
By default this method does nothing but return the position spec passed to it. In rtl mode it is overridden to convert "l" to "r" and vice versa when required.
Defaults to:
Ext.identityFn
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
The div Element that will contain the component's error message(s). Note that depending on the configured msgTarget, this element may be hidden in favor of some other form of presentation, but will always be present in the DOM for use by assistive technologies.
Initial suspended call count. Incremented when suspendEvents is called, decremented when resumeEvents is called.
Defaults to:
0
Only present for floating Components which were inserted as child items of Containers.
There are other similar relationships such as the Ext.button.Button which activates a menu, or the Ext.menu.Item which activated a submenu, or the Ext.grid.column.Column which activated the column menu.
These differences are abstracted away by the up method.
Floating Components that are programatically rendered will not have a floatParent
property.
See floating and zIndexManager
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);
}
Template method to do any Focusable related initialization that does not involve event listeners creation.
Defaults to:
Ext.emptyFn
A reference to the element that wraps the input element. Only set after the field has been rendered.
Defaults to:
me.inputWrap
Deprecated since version 5.0
use inputWrap instead
The input Element for this Field. Only available after the field has been rendered.
A reference to the element that wraps the input element. Only set after the field has been rendered.
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
Flag denoting that this object is labelable as a field. Always true.
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
The label Element for this component. Only available after the component has been rendered.
Components that achieve their internal layout results using solely CSS with no JS intervention must set this to true. Failure to set this property to true may result in setSize failing to work if the component opted out of the layout run.
Defaults to:
false
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
Tells the layout system that the height can be measured immediately because the width does not need setting.
Defaults to:
true
Called when the field's dirty state changes.
Defaults to:
Ext.emptyFn
isDirty : Boolean
The original value of the field as configured in the value configuration, or as loaded by the last
form load operation if the form's trackResetOnLoad setting is true.
Defaults to:
me.getValue()
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
Template method to do any post-blur processing.
Defaults to:
Ext.emptyFn
e : Ext.event.Event
The event object
Template method to do any post-focus processing.
Defaults to:
Ext.emptyFn
e : Ext.event.Event
The event object
Indicates whether or not the component has been rendered.
Defaults to:
false
Available since: 1.1.0
An object property which provides unified information as to which dimensions are scrollable based upon the autoScroll, overflowX and overflowY settings (And for views of trees and grids, the owning panel's scroll setting).
Note that if you set overflow styles using the style config or bodyStyle config, this object does not include that information; it is best to use autoScroll, overflowX and overflowY if you need to access these flags.
This object has the following properties:
Defaults to:
{
overflowX: ox,
overflowY: oy,
x: ox = (ox === 'auto' || ox === 'scroll'),
y: oy = (oy === 'auto' || oy === 'scroll'),
both: ox && oy
}
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
Transform the raw value before it is set
Defaults to:
Ext.identityFn
value : Object
The value
The value to set
Deprecated since version 5.0
A composite of all the trigger button elements. Only set after the field has
been rendered.
A reference to the element which encapsulates the input field and all trigger button(s). Only set after the field has been rendered.
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 which are added to a Container, the ZIndexManager is acquired from the first ancestor Container found which is floating. If no floating ancestor is found, the global Ext.WindowManager is used.
See Ext.Component#floating and zIndexParent
Only present for Ext.Component#floating Components which were inserted as child items of Containers, and which have a floating Container in their containment ancestry.
For Ext.Component#floating Components which are child items of a Container, the zIndexParent will be a floating ancestor Container which is responsible for the base z-index value of all its floating descendants. It provides a Ext.ZIndexManager which provides z-indexing services for all its descendant floating Components.
Floating Components that are programatically rendered will not have a zIndexParent
property.
For example, the dropdown Ext.view.BoundList of a ComboBox which is in a Window will have the
Window as its zIndexParent, and will always show above that Window, wherever the Window is placed in the z-index stack.
See Ext.Component#floating and zIndexManager
Adds declarative listeners as nested arrays of listener objects.
listeners : Array
true if any listeners 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 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).
This method applies a versioned, deprecation declaration to this class. This
is typically called by the deprecated config.
deprecations : Object
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.
The on method is shorthand for addListener.
Appends an event handler to this object. For example:
myGridPanel.on("mouseover", this.onMouseOver, this);
The method also allows for a single argument to be passed which is a config object containing properties which specify multiple events. For example:
myGridPanel.on({
cellClick: this.onCellClick,
mouseover: this.onMouseOver,
mouseout: this.onMouseOut,
scope: this // Important. Ensure "this" is correct during handler execution
});
One can also specify options for each event handler separately:
myGridPanel.on({
cellClick: {fn: this.onCellClick, scope: this, single: true},
mouseover: {fn: panel.onMouseOver, scope: panel}
});
Names of methods in a specified scope may also be used. Note that
scope MUST be specified to use this option:
myGridPanel.on({
cellClick: {fn: 'onCellClick', scope: this, single: true},
mouseover: {fn: 'onMouseOver', scope: panel}
});
eventName : String/Object
The name of the event to listen for. May also be an object who's property names are event names.
fn : Function (optional)
The method the event invokes, or if scope is specified, the name* of the method within
the specified scope. Will be called with arguments
given to Ext.util.Observable#fireEvent plus the options parameter described below.
scope : Object (optional)
The scope (this reference) in which the handler function is
executed. If omitted, defaults to the object which fired the event.
options : Object (optional)
An object containing handler configuration.
Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler.
This object may contain any of the following properties:
scope : Object
The scope (this reference) in which the handler function is executed. If omitted,
defaults to the object which fired the event.
delay : Number
The number of milliseconds to delay the invocation of the handler after the event fires.
single : Boolean
True to add a handler to handle just the next firing of the event, and then remove itself.
buffer : Number
Causes the handler to be scheduled to run in an Ext.util.DelayedTask delayed by the specified number of milliseconds. If the event fires again within that time, the original handler is not invoked, but the new handler is scheduled in its place.
onFrame : Number
Causes the handler to be scheduled to run at the next animation frame event. If the event fires again before that time, the handler is not rescheduled - the handler will only be called once when the next animation frame is fired, with the last set of arguments passed.
target : Ext.util.Observable
Only call the handler if the event was fired on the target Observable, not if the event was bubbled up from a child Observable.
element : String
This option is only valid for listeners bound to Ext.Component. The name of a Component property which references an element to add a listener to.
This option is useful during Component construction to add DOM event listeners to elements of Ext.Component which will exist only after the Component is rendered. For example, to add a click listener to a Panel's body:
new Ext.panel.Panel({
title: 'The title',
listeners: {
click: this.handlePanelClick,
element: 'body'
}
});
destroyable : Boolean (optional)
When specified as true, the function returns A Destroyable object. An object which implements the destroy method which removes all listeners added in this call.
Defaults to:
false
priority : Number (optional)
An optional numeric priority that determines the order in which event handlers are run. Event handlers with no priority will be run as if they had a priority of 0. Handlers with a higher priority will be prioritized to run sooner than those with a lower priority. Negative numbers can be used to set a priority lower than the default. Internally, the framework uses a range of 1000 or greater, and -1000 or lesser for handers that are intended to run before or after all others, so it is recommended to stay within the range of -999 to 999 when setting the priority of event handlers in application-level code.
Combining Options
Using the options argument, it is possible to combine different types of listeners:
A delayed, one-time listener.
myPanel.on('hide', this.handleClick, this, {
single: true,
delay: 100
});
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();
Adds listeners to any Observable object (or Ext.Element) which are automatically removed when this Component is destroyed.
item : Ext.util.Observable/Ext.dom.Element
The item to which to add a listener/listeners.
ename : Object/String
The event name, or an object containing event name properties.
fn : Function (optional)
If the ename parameter was an event name, this is the handler function.
scope : Object (optional)
If the ename parameter was an event name, this is the scope (this reference)
in which the handler function is executed.
options : Object (optional)
If the ename parameter was an event name, this is the
addListener options.
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();
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.
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.
uiCls : String
The UI class to add to the element.
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
Called by the layout system after the Component has been laid out.
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 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.
Allows addition of behavior after rendering is complete. At this stage the Component's Element will have been styled according to the configuration, will have had any configured CSS class names added, and will be in the configured visibility and the configured enable state.
This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.
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:
In addition to the anchor points, the position parameter also supports the "?" character. If "?" is passed at the end of the position string, the element will attempt to align as specified, but the position will be adjusted to constrain to the viewport if necessary. Note that the element being aligned might be swapped to align to a different position than that specified in order to enforce the viewport constraints. Following are all of the supported anchor positions:
Value Description ----- ----------------------------- tl The top left corner (default) t The center of the top edge tr The top right corner l The center of the left edge c In the center of the element r The center of the right edge bl The bottom left corner b The center of the bottom edge br The bottom right corner
Example Usage:
// align el to other-el using the default positioning
// ("tl-bl", non-constrained)
el.alignTo("other-el");
// align the top left corner of el with the top right corner of other-el
// (constrained to viewport)
el.alignTo("other-el", "tr?");
// align the bottom right corner of el with the center left edge of other-el
el.alignTo("other-el", "br-l?");
// align the center of el with the bottom left corner of other-el and
// adjust the x position by -6 pixels (and the y position by 0)
el.alignTo("other-el", "c-bl", [-6, 0]);
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
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.
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
A utility for grouping a set of modifications which may trigger value changes into a single transaction, to prevent excessive firing of change events. This is useful for instance if the field has sub-fields which are being updated as a group; you don't want the container field to check its own changed state for each subfield change.
fn : Function
The function to call with change checks suspended.
Occurs before componentLayout is run. Returning false from this method will prevent the componentLayout from
being executed.
adjWidth : Number
The box-adjusted width that was set.
adjHeight : Number
The box-adjusted height that was set.
This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.
Invoked before the Component is destroyed.
This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.
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.
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.
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
Calculates the new [x,y] position to move this Positionable into a constrain region.
By default, this Positionable is constrained to be within the container it was added to, or the element it was rendered to.
Priority is given to constraining the top and left within the constraint.
An alternative constraint may be passed.
constrainTo : String/HTMLElement/Ext.dom.Element/Ext.util.Region (optional)
The Element or Ext.util.Region into which this Component is to be constrained. Defaults to the element into which this Positionable was rendered, or this Component's {@link Ext.Component#constrainTo.
proposedPosition : Number[] (optional)
A proposed [X, Y] position to test for validity
and to coerce into constraints instead of using this Positionable's current position.
local : Boolean (optional)
The proposedPosition is local (relative to floatParent if a floating Component)
proposedSize : Number[] (optional)
A proposed [width, height] size to use when calculating
constraints instead of using this Positionable's current size.
If the element needs to be translated, the new [X, Y] position within
constraints if possible, giving priority to keeping the top and left edge in the constrain region.
Otherwise, false.
Call the "parent" method of the current method. That is the method previously overridden by derivation or by an override (see Ext#define).
Ext.define('My.Base', {
constructor: function (x) {
this.x = x;
},
statics: {
method: function (x) {
return x;
}
}
});
Ext.define('My.Derived', {
extend: 'My.Base',
constructor: function () {
this.callParent([21]);
}
});
var obj = new My.Derived();
alert(obj.x); // alerts 21
This can be used with an override as follows:
Ext.define('My.DerivedOverride', {
override: 'My.Derived',
constructor: function (x) {
this.callParent([x*2]); // calls original My.Derived constructor
}
});
var obj = new My.Derived();
alert(obj.x); // now alerts 42
This also works with static methods.
Ext.define('My.Derived2', {
extend: 'My.Base',
statics: {
method: function (x) {
return this.callParent([x*2]); // calls My.Base.method
}
}
});
alert(My.Base.method(10)); // alerts 10
alert(My.Derived2.method(10)); // alerts 20
Lastly, it also works with overridden static methods.
Ext.define('My.Derived2Override', {
override: 'My.Derived2',
statics: {
method: function (x) {
return this.callParent([x*2]); // calls My.Derived2.method
}
}
});
alert(My.Derived2.method(10); // now alerts 40
To override a method and replace it and also call the superclass method, use callSuper. This is often done to patch a method to fix a bug.
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 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
Checks whether the value of the field has changed since the last time it was checked. If the value has changed, it:
Checks the isDirty state of the field and if it has changed since the last time it was checked, fires the dirtychange event.
Clear any invalid styles/messages for this field.
Note: this method does not cause the Field's validate or isValid methods to return true
if the value does not pass validation. So simply clearing a field's errors will not necessarily allow
submission of forms submitted with the Ext.form.action.Submit#clientValidation option set.
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
Runs on mousewheel and mousedown of doc to check to see if we should collapse the picker
e : Object
ptype : String/Object
string or config object containing a ptype property.
Constructs a plugin according to the passed config object/ptype string.
Ensures that the constructed plugin always has a cmp reference back to this component.
The setting up of this is done in PluginManager. The PluginManager ensures that a reference to this
component is passed to the constructor. It also ensures that the plugin's setCmp method (if any) is called.
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:
Creates and returns the component to be used as this field's picker. Must be implemented by subclasses of Picker.
Creates an event handling function which refires the event from this object as the passed event name.
newName : String
The name under which to refire the passed parameters.
beginEnd : Array (optional)
The caller can specify on which indices to slice.
Destroys the Component. This method must not be overridden.
To add extra functionality to destruction time in a subclass, implement the template method or {@link #onDestroy. And do not forget to callParent() in your implementation.
Available since: 1.1.0
Checks if the value has changed. Allows subclasses to override for any more complex logic.
newVal : Object
oldVal : Object
Disable the component.
Available since: 1.1.0
silent : Boolean (optional)
Passing true will suppress the disable event from being fired.
Defaults to: false
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 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.
Continue to fire event.
eventName : String
args : Array
bubbles : Boolean
Enable the component
Available since: 1.1.0
silent : Boolean (optional)
Passing true will suppress the enable event from being fired.
Defaults to: false
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.
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
Only relevant if the instance's isFileUpload method returns true. Returns a reference to the file input DOM element holding the user's selected file. The input will be appended into the submission form and will not be returned, so this method should also create a replacement.
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.
ptype : String
The Plugin's ptype as specified by the class's alias configuration.
plugin instance.
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 (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.
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.
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.
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 updateLayout instead.
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 an Array of any active error messages currently applied to the field. This does not trigger validation on its own, it merely returns any messages that the component may already hold.
The active error messages on the component; if there are no errors, an empty Array is returned.
Gets the x,y coordinates to align this element with another element. See alignTo for more info on the supported position values.
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]
[x, y]
Gets the x,y coordinates of an element specified by the anchor position on the element.
el : Ext.dom.Element
The element
anchor : String (optional)
The specified anchor position. See alignTo for details on supported anchor positions.
Defaults to: 'tl'
local : Boolean (optional)
True to get the local (element top/left-relative) anchor position instead of page coordinates
size : Object (optional)
An object containing the size to use for calculating anchor position {width: (target width), height: (target height)} (defaults to the element's current size)
[x, y] An array containing the element's x and y coordinates
Gets the x,y coordinates specified by the anchor position on the element.
anchor : String (optional)
The specified anchor position. See alignTo for details on supported anchor positions.
Defaults to: 'tl'
local : Boolean (optional)
True to get the local (element top/left-relative) anchor position instead of page coordinates
size : Object (optional)
An object containing the size to use for calculating anchor position {width: (target width), height: (target height)} (defaults to the element's current size)
[x, y] An array containing the element's x and y coordinates
Returns the 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 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 [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.
Retrieves the top level element representing this component.
Available since: 1.1.0
Runs all of Date's validations and returns an array of any errors. Note that this first runs Text's validations, so the returned array is an amalgamation of all field errors. The additional validation checks are testing that the date format is valid, that the chosen date is within the min and max date constraints set, that the date chosen is not in the disabledDates regex and that the day chosed is not one of the disabledDays.
value : Object (optional)
The value to get errors for (defaults to the current field value)
All validation errors for this field
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 Focusable.
At the Focusable base mixin level, this function returns undefined.
Subclasses which use embedded focusable elements (such as Window, Field and Button) should override this for use by the focus method.
undefined because raw Focusables cannot by
default hold focus.
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.
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 constructor when instantiating this class.
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
Generates the arguments for the field decorations rendering template.
data : Object
optional object to use as the base data object. If provided, this method will add properties to the base object instead of creating a new one.
The template arguments
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 dicated by its own maskElement
Panels use "el" as their maskElement by default, but that could be overridden to be "body" to leave toolbars and the header
mouse-accessible.
Returns the value(s) that should be saved to the Ext.data.Model instance for this field, when Ext.form.Basic#updateRecord is called. Typically this will be an object with a single name-value pair, the name being this field's getName and the value being its current data value. More advanced field implementations may return more than one name-value pair. The returned values will be saved to the corresponding field names in the Model.
Note that the values returned from this method are not guaranteed to have been successfully validated.
includeEmptyText : Object
isSubmitting : Object
A mapping of submit parameter names to values; each value should be a string, or an array of strings if that particular name has multiple values. It can also return null if there are no parameters to be submitted.
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])
Returns the CSS style object which will set the Component's scroll styles. This must be applied to the target element.
Returns a reference to the picker component for this field, creating it if necessary by calling createPicker.
The picker component
Retrieves a plugin from this component's collection by its pluginId.
pluginId : String
plugin instance.
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])
Returns the raw String value of the field, without performing any normalization, conversion, or validation. Gets the current value of the input element if the field has been rendered, ignoring the value if it is the emptyText. To get a normalized and converted value see getValue.
The raw String value of the field
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 the "x" scroll position for this component. Only applicable for components
that have been configured with autoScroll or overflowX.
Returns the "y" scroll position for this component. Only applicable for components
that have been configured with autoScroll or overflowY.
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
Creates and returns the data object to be used when rendering the fieldSubTpl.
fieldData : Object
The template data
This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.
Gets the markup to be inserted into the outer template's bodyEl. For fields this is the actual input element.
fieldData : Object
Returns the parameter(s) that would be included in a standard form submit for this field. Typically this will be an object with a single name-value pair, the name being this field's getName and the value being its current stringified value. More advanced field implementations may return more than one name-value pair.
Note that the values returned from this method are not guaranteed to have been successfully validated.
A mapping of submit parameter names to values; each value should be a string, or an array of strings if that particular name has multiple values. It can also return null if there are no parameters to be submitted.
This is used to determine where to insert the 'html', 'contentEl' and 'items' in this component.
Returns the trigger with the given id
id : String
Get the total width of the trigger button area.
The total trigger width
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.
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
Tells whether the field currently has an active error message. This does not trigger validation on its own, it merely looks for any message that the component may already hold.
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
Checks if there is currently a specified uiCls.
cls : String
The cls to check.
Checks if the field has a visible label
True if the field has a visible label
Hides this Component, setting it to invisible using the configured 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
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 this Field mixin on the current instance. Components using this mixin should call this method during their own initialization process.
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
Performs initialization of this mixin. Component classes using this mixin should call this method during their own initialization.
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.
Applies padding, margin, border, top, left, height, and width configs to the appropriate elements.
targetEl : Object
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 the descendant of a particular container.
container : Ext.container.Container
true if the component is the descendant of a particular container, otherwise false.
Returns true if the value of this Field has been changed from its originalValue. Will always return false if the field is disabled.
Note that if the owning Ext.form.Basic was configured with trackResetOnLoad then the originalValue is updated when the values are loaded by Ext.form.Basic.setValues.
True if this field has been changed from its original value (and is not disabled), false otherwise.
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.
Override. Treat undefined and null values as equal to an empty string value.
value1 : Object
value2 : Object
Returns whether two values are logically equal. Similar to isEqual, however null or undefined values will be treated as empty strings.
value1 : Object
The first value to compare
value2 : Object
The second value to compare
True if the values are equal, false if inequal.
Returns whether this Field is a file upload field; if it returns true, forms will use special techniques for submitting the form via AJAX. See Ext.form.Basic#hasUpload for details. If this returns true, the extractFileInput method must also be implemented to return the corresponding file input element.
Method to determine whether this Component is floating.
the floating state of this component.
Method to determine whether this Component is currently set to hidden.
the hidden state of this Component.
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
Returns whether or not the field value is currently valid by validating the processed raw value of the field. Note: disabled fields are always treated as valid.
True if the value is valid, else false
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.
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 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
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.
Display one or more error messages associated with this field, using msgTarget to determine how to display the messages and applying invalidCls to the field's UI element.
Note: this method does not cause the Field's validate or isValid methods to return false
if the value does pass validation. So simply marking a Field as invalid will not prevent submission of forms
submitted with the Ext.form.action.Submit#clientValidation option set.
errors : String/String[]
The validation message(s) to display.
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 clas name to use on the message element in the center of the layer.
Shorthand for addManagedListener. Adds listeners to any Observable object (or Ext.Element) which are automatically removed when this Component is destroyed.
item : Ext.util.Observable/Ext.dom.Element
The item to which to add a listener/listeners.
ename : Object/String
The event name, or an object containing event name properties.
fn : Function (optional)
If the ename parameter was an event name, this is the handler function.
scope : Object (optional)
If the ename parameter was an event name, this is the scope (this reference)
in which the handler function is executed.
options : Object (optional)
If the ename parameter was an event name, this is the
addListener options.
Only when the destroyable option is specified.
A Destroyable object. An object which implements the destroy method which removes all listeners added in this call. For example:
this.btnListeners = myButton.mon({
destroyable: true
mouseover: function() { console.log('mouseover'); },
mouseout: function() { console.log('mouseout'); },
click: function() { console.log('click'); }
});
And when those listeners need to be removed:
Ext.destroy(this.btnListeners);
or
this.btnListeners.destroy();
Move the element relative to its current position.
direction : String
Possible values are:
"l" (or "left")"r" (or "right")"t" (or "top", or "up")"b" (or "bottom", or "down")distance : Number
How far to move the element in pixels
Shorthand for removeManagedListener. Removes listeners that were added by the mon method.
item : Ext.util.Observable/Ext.dom.Element
The item from which to remove a listener/listeners.
ename : Object/String
The event name, or an object containing event name properties.
fn : Function (optional)
If the ename parameter was an event name, this is the handler function.
scope : Object (optional)
If the ename parameter was an event name, this is the scope (this reference)
in which the handler function is executed.
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("mouseover", this.onMouseOver, this);
The method also allows for a single argument to be passed which is a config object containing properties which specify multiple events. For example:
myGridPanel.on({
cellClick: this.onCellClick,
mouseover: this.onMouseOver,
mouseout: this.onMouseOut,
scope: this // Important. Ensure "this" is correct during handler execution
});
One can also specify options for each event handler separately:
myGridPanel.on({
cellClick: {fn: this.onCellClick, scope: this, single: true},
mouseover: {fn: panel.onMouseOver, scope: panel}
});
Names of methods in a specified scope may also be used. Note that
scope MUST be specified to use this option:
myGridPanel.on({
cellClick: {fn: 'onCellClick', scope: this, single: true},
mouseover: {fn: 'onMouseOver', scope: panel}
});
eventName : String/Object
The name of the event to listen for. May also be an object who's property names are event names.
fn : Function (optional)
The method the event invokes, or if scope is specified, the name* of the method within
the specified scope. Will be called with arguments
given to Ext.util.Observable#fireEvent plus the options parameter described below.
scope : Object (optional)
The scope (this reference) in which the handler function is
executed. If omitted, defaults to the object which fired the event.
options : Object (optional)
An object containing handler configuration.
Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler.
This object may contain any of the following properties:
scope : Object
The scope (this reference) in which the handler function is executed. If omitted,
defaults to the object which fired the event.
delay : Number
The number of milliseconds to delay the invocation of the handler after the event fires.
single : Boolean
True to add a handler to handle just the next firing of the event, and then remove itself.
buffer : Number
Causes the handler to be scheduled to run in an Ext.util.DelayedTask delayed by the specified number of milliseconds. If the event fires again within that time, the original handler is not invoked, but the new handler is scheduled in its place.
onFrame : Number
Causes the handler to be scheduled to run at the next animation frame event. If the event fires again before that time, the handler is not rescheduled - the handler will only be called once when the next animation frame is fired, with the last set of arguments passed.
target : Ext.util.Observable
Only call the handler if the event was fired on the target Observable, not if the event was bubbled up from a child Observable.
element : String
This option is only valid for listeners bound to Ext.Component. The name of a Component property which references an element to add a listener to.
This option is useful during Component construction to add DOM event listeners to elements of Ext.Component which will exist only after the Component is rendered. For example, to add a click listener to a Panel's body:
new Ext.panel.Panel({
title: 'The title',
listeners: {
click: this.handlePanelClick,
element: 'body'
}
});
destroyable : Boolean (optional)
When specified as true, the function returns A Destroyable object. An object which implements the destroy method which removes all listeners added in this call.
Defaults to:
false
priority : Number (optional)
An optional numeric priority that determines the order in which event handlers are run. Event handlers with no priority will be run as if they had a priority of 0. Handlers with a higher priority will be prioritized to run sooner than those with a lower priority. Negative numbers can be used to set a priority lower than the default. Internally, the framework uses a range of 1000 or greater, and -1000 or lesser for handers that are intended to run before or after all others, so it is recommended to stay within the range of -999 to 999 when setting the priority of event handlers in application-level code.
Combining Options
Using the options argument, it is possible to combine different types of listeners:
A delayed, one-time listener.
myPanel.on('hide', this.handleClick, this, {
single: true,
delay: 100
});
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();
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.
Invoked when this component has first achieved size. Occurs after the componentLayout has completed its initial run.
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.
If grow=true, invoke the autoSize method when the field's value is changed.
newVal : Object
oldVal : Object
Allows addition of behavior to the destroy operation. After calling the superclass's onDestroy, the Component will be destroyed.
This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.
Called when the field's dirty state changes. Adds/removes the dirtyCls on the main element.
isDirty : Boolean
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.
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.
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)
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 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.
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.
Available since: 3.4.0
destroying : Boolean
Will be passed as true if the Container performing the remove operation will delete this
Component upon remove.
This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.
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.
Allows addition of behavior to the resize operation.
Called when Ext.resizer.Resizer#drag event is fired.
width : Object
height : Object
oldWidth : Object
oldHeight : Object
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.
Handles the trigger click; by default toggles between expanding and collapsing the picker component.
e : Object
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
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.
Performs any necessary manipulation of a raw String value to prepare it for conversion and/or validation. For text fields this applies the configured stripCharsRe to the raw value.
value : String
The unprocessed string value
The processed string value
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.
Converts a raw input field value into a mixed-type value that is suitable for this particular field type. This allows controlling the normalization and conversion of user-entered values into field-type-appropriate values, e.g. a Date object for Ext.form.field.Date, and is invoked by getValue.
It is up to individual implementations to decide how to handle raw values that cannot be successfully converted to the desired object type.
See valueToRaw for the opposite conversion.
The base implementation does no conversion, returning the raw value untouched.
rawValue : Object
The converted value.
Implementation which updates the scroll range of a touch scroller. Subclasses may change implementation.
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[]
Array of event names to relay.
prefix : String (optional)
A common prefix to prepend to the event names. For example:
this.relayEvents(this.getStore(), ['load', 'clear'], 'store');
Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'.
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 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.
cls : String/String[]
A string or an array of strings to remove to the uiCls.
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 Ext.util.Observable#addListener call.
scope : Object (optional)
The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable#addListener or the listener will not be removed.
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
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.
If the Container is already rendered when a new child Component is added, you may need to call the Container's doLayout to refresh the view which causes any unrendered child Components to be rendered. This is required so that you can add multiple child components if needed while only refreshing the layout once.
When creating complex UIs, it is important to remember that sizing and positioning of child items is the responsibility of the Container's layout manager. If you expect child items to be sized in response to user interactions, you must configure the Container with a layout manager which creates and manages the type of layout you have in mind.
Omitting the Container's layout config means that a basic layout manager is used which does nothing but render child components sequentially into the Container. No sizing or positioning will be performed in this situation.
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)
Overrides the method from the Ext.form.Labelable mixin to also add the invalidCls to the inputEl, as that is required for proper styling in IE with nested fields (due to lack of child selector)
Resets the current field value to the originally-loaded value and clears any validation messages. Also adds emptyText and emptyCls if the original value was blank.
Resets the field's originalValue property so it matches the current value. This is called by Ext.form.Basic.setValues if the form's trackResetOnLoad property is set to true.
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.
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.
Attempts to parse a given string value using a given date format.
value : String
The value to attempt to parse
format : String
A valid date format (see Ext.Date#parse)
The parsed Date object, or null if the value could not be successfully parsed.
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 components that have been configured with autoScroll or
overflowX and overflowY.
x : Number
y : Number
animate : Boolean/Object (optional)
true for the default animation or a standard Element animation config object
Selects text in this field
start : Number (optional)
The index where the selection should start
Defaults to: 0
end : Number (optional)
The index where the selection should end (defaults to the text length)
Ensures that all effects queued after sequenceFx is called on this object are run in sequence. This is the opposite of syncFx.
this
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
newActive : Ext.Component (optional)
If deactivating, the newly active Component which is taking over topmost zIndex position.
Set the active error message to an Array of error messages. The messages are formatted into a single message string using the activeErrorsTpl. Also see setActiveError which allows setting the entire error contents with a single string. Note that this only updates the error message element's text and attributes, you'll have to call doComponentLayout to actually update the field's layout to match. If the field extends Ext.form.field.Base you should call markInvalid instead.
errors : String[]
The error messages
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
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.
Applies a set of default configuration values to this Labelable instance. For each of the properties in the given object, check if this component hasOwnProperty that config; if not then it's inheriting a default value from its prototype and we should apply the default value.
defaults : Object
The defaults to apply to the object.
Sets the flex property of this component. Only applicable when this component is an item of a box layout
flex : Number
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 null for one of the values will erase the inline style.
Passing undefined will preserve the current value.
overflowX : String
The overflow-x value.
overflowY : String
The overflow-y value.
this
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 field's raw value directly, bypassing value conversion, change detection, and validation. To set the value with these additional inspections see setValue.
value : Object
The value to set
value The field value that is set
Sets the "x" scroll position for this component. Only applicable for components
that have been configured with autoScroll or overflowX.
x : Number
Sets the "y" scroll position for this component. Only applicable for components
that have been configured with autoScroll or overflowY.
y : Number
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.
The : Number
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.
The : Number
Y position
this
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 floating are true.
After being shown, a floating Component (such as a Ext.window.Window), is activated it and brought to the front of its z-index stack.
animateTarget : String/Ext.dom.Element (optional)
only valid for floating Components such as Ext.window.Windows or Ext.tip.ToolTips, or regular Components which have been configured
with floating: true. The target from which the Component should animate from while opening.
Defaults to: null
callback : Function (optional)
A callback function to call after the Component is displayed. Only necessary if animation was specified.
scope : Object (optional)
The scope (this reference) in which the callback is executed.
Defaults to this Component.
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 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.
offsets : Number[] (optional)
Alignment offsets as used by Ext.util.Positionable#getAlignToXY. See alignTo for possible values.
this
Get the reference to the class from which this object was instantiated. Note that unlike Ext.Base#self,
this.statics() is scope-independent and it always returns the class from which it was called, regardless of what
this points to during run-time
Ext.define('My.Cat', {
statics: {
totalCreated: 0,
speciesName: 'Cat' // My.Cat.speciesName = 'Cat'
},
constructor: function() {
var statics = this.statics();
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.
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
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
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)}
Returns the trimmed label by slicing off the label separator character. Can be overridden.
The trimmed field label, or empty string if not defined
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 Ext.util.Observable#addListener call.
scope : Object (optional)
The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable#addListener or the listener will not be removed.
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
Clears the active error message(s). Note that this only clears the error message element's text and attributes, you'll have to call doComponentLayout to actually update the field's layout to match. If the field extends Ext.form.field.Base you should call clearInvalid instead.
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/activater is returned.
limit : String/Number/Ext.Component (optional)
This may be a selector upon which to stop the upward scan, or a limit of the number of steps, or Component reference to stop on.
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.
Defaults to: false
callback : Function (optional)
Only legitimate when using the html configuration.
Callback to execute when scripts have finished loading.
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.
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 session config.
Available since: 5.0.0
session : Ext.data.Session
Updates the viewModel config.
Available since: 5.0.0
viewModel : Ext.app.ViewModel
Returns whether or not the field value is currently valid by validating the field's current value, and fires the validitychange event if the field's validity has changed since the last validation. Note: disabled fields are always treated as valid.
Custom implementations of this method are allowed to have side-effects such as triggering error message display. To validate without side-effects, use isValid.
True if the value is valid, else false
Uses getErrors to build an array of validation errors. If any errors are found, they are passed to markInvalid and false is returned, otherwise true is returned.
Previously, subclasses were invited to provide an implementation of this to process validations - from 3.2 onwards getErrors should be overridden instead.
value : Object
The value to validate
True if all validations passed, false if one or more failed
Converts a mixed-type value to a raw representation suitable for displaying in the field. This allows controlling how value objects passed to setValue are shown to the user, including localization. For instance, for a Ext.form.field.Date, this would control how a Date object passed to setValue would be converted to a String for display in the field.
See rawToValue for the opposite conversion.
The base implementation simply does a standard toString conversion, and converts empty values to an empty string.
value : Object
The mixed-type value to convert to the raw representation.
The converted raw value.
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 : 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 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 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 after the component rendering is finished.
The afterrender event is fired after this Component has been rendered, been postprocessed by any
afterRender method defined for the Component.
Available since: 3.4.0
this : Ext.Component
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when the autoSize function is triggered and the field is resized according to the grow/growMin/growMax configs as a result. This event provides a hook for the developer to apply additional logic at runtime to resize the field if needed.
this : Ext.form.field.Text
This text field
width : Number
The new field width
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 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.
Fires before the component is method-destroyed. Return false from an event handler to stop the
method-destroy.
Available since: 1.1.0
this : Ext.Component
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 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 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 : Ext.Component
width : Number
The initial width.
height : Number
The initial height.
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when the value of a field is changed via the setValue method.
this : Ext.form.field.Field
newValue : Object
The new value
oldValue : Object
The original value
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when the field's picker is collapsed.
field : Ext.form.field.Picker
This field instance
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.
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 when a change in the field's isDirty state is detected.
this : Ext.form.field.Field
isDirty : Boolean
Whether or not the field is now dirty
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 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 when the active error message is changed via setActiveError.
this : Ext.form.Labelable
error : String
The active error message
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when the field's picker is expanded.
field : Ext.form.field.Picker
This field instance
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
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 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.
Keydown input field event. This event only fires if enableKeyEvents is set to true.
this : Ext.form.field.Text
This text field
e : Ext.event.Event
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Keypress input field event. This event only fires if enableKeyEvents is set to true.
this : Ext.form.field.Text
This text field
e : Ext.event.Event
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Keyup input field event. This event only fires if enableKeyEvents is set to true.
this : Ext.form.field.Text
This text field
e : Ext.event.Event
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 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 : 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 value is selected via the picker.
field : Ext.form.field.Picker
This field instance
value : Object
The value that was selected. The exact type of this value is dependent on the individual field and picker implementations.
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.
Fires when any key related to navigation (arrows, tab, enter, esc, etc.) is pressed. To handle other keys see Ext.util.KeyMap. You can check Ext.event.Event#getKey to determine which key was pressed. For example:
var form = new Ext.form.Panel({
...
items: [{
fieldLabel: 'Field 1',
name: 'field1',
allowBlank: false
},{
fieldLabel: 'Field 2',
name: 'field2',
listeners: {
specialkey: function(field, e){
// e.HOME, e.END, e.PAGE_UP, e.PAGE_DOWN,
// e.TAB, e.ESC, arrow keys: e.LEFT, e.RIGHT, e.UP, e.DOWN
if (e.getKey() == e.ENTER) {
var form = field.up('form').getForm();
form.submit();
}
}
}
}
],
...
});
this : Ext.form.field.Base
e : Ext.event.Event
The event object
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 when a change in the field's validity is detected.
this : Ext.form.field.Field
isValid : Boolean
Whether or not the field is now valid
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
Fires when this field changes its read-only status.
this : Ext.form.field.Base
Read : Boolean
only flag
eOpts : Object
The options object passed to Ext.util.Observable.addListener.
The background image for error icons
Defaults to:
'form/exclamation'
Margin for error icons that are aligned to the side of the field
Defaults to:
0 1px
The text color of form error messages
Defaults to:
$form-field-invalid-border-color
The font-family of form error messages
Defaults to:
$font-family
The font-weight of form error messages
Defaults to:
$font-weight
The line-height of form error messages
Defaults to:
$form-error-icon-height
The space between the icon and the message for errors that display under the field
Defaults to:
4px
The padding on errors that display under the form field
Defaults to:
2px 2px 2px 0
In the default neptune color scheme this is the same as $base-highlight-color but it does not change automatically when one changes the $base-color. This is because checkboxes and radio buttons have this focus color hard coded into their background images. If this color is changed, you should also modify checkbox and radio button background images to match
Defaults to:
mix(#fff, #157fcc, 15%)
Background color for invalid form fields.
Defaults to:
#fff
Background image for invalid form fields.
Defaults to:
'grid/invalid_line'
Background position for invalid form fields.
Defaults to:
bottom
Background repeat for invalid form fields.
Defaults to:
repeat-x
The bottom margin to apply to form items when in auto, anchor, vbox, or table layout. This value is also used as the default border-spacing in a form-layout.
Defaults to:
5px
Horizontal space between the label and the field body when the label is left-aligned.
Defaults to:
5px
The line-height of form field labels
Defaults to:
round($form-label-font-size * 1.15)
Vertical space between the label and the field body when the label is top-aligned.
Defaults to:
5px
The background color of the text field's input element
Defaults to:
$form-field-background-color
The background image of the text field's input element
Defaults to:
$form-field-background-image
The default width of the text field's body element (the element that contains the input element and triggers) when the field is not sized explicitly using the width config, or sized by it's containing layout.
Defaults to:
150px
The border color of text fields
Defaults to:
$form-field-border-color
The border style of text fields
Defaults to:
$form-field-border-style
The border width of text fields
Defaults to:
$form-field-border-width
true to use classic-theme styled border for text fields.
Defaults to:
false
The color of the text field's input element
Defaults to:
$form-field-color
Text color for empty text fields.
Defaults to:
$form-field-empty-color
The border color of the focused text field
Defaults to:
$form-field-focus-border-color
Font family for text fields.
Defaults to:
$form-field-font-family
Font weight for text fields.
Defaults to:
$form-field-font-weight
Background color of the text field's input element when the field value is invalid.
Defaults to:
$form-field-invalid-background-color
Background image of the text field's input element when the field value is invalid.
Defaults to:
$form-field-invalid-background-image
Background position of the text field's input element when the field value is invalid.
Defaults to:
$form-field-invalid-background-position
Background repeat of the text field's input element when the field value is invalid.
Defaults to:
$form-field-invalid-background-repeat
Border color for invalid text fields.
Defaults to:
$form-field-invalid-border-color
The padding of the text field's input element
Defaults to:
$form-field-padding
The default width of the TextArea's body element (the element that contains the textarea html element when the field is not sized explicitly using the widthconfig, or sized by it's containing layout.
The background image for toolbar field error icons
Defaults to:
'form/exclamation'
Margin for toolbar field error icons that are aligned to the side of the field
Defaults to:
0 1px
The text color of toolbar form error messages
Defaults to:
$form-field-invalid-border-color
The font-family of toolbar form field error messages
Defaults to:
$font-family
The font-size of toolbar form field error messages
Defaults to:
$font-size
The font-weight of toolbar form field error messages
Defaults to:
$font-weight
The line-height of toolbar form field error messages
Defaults to:
$form-toolbar-error-icon-height
The space between the icon and the message for errors that display under a toolbar field
Defaults to:
4px
The padding on errors that display under the toolbar form field
Defaults to:
2px 2px 2px 0
Opacity of disabled toolbar form fields
Defaults to:
.3
Font family for toolbar form fields.
Defaults to:
$form-field-font-family
Font size for toolbar form fields.
Defaults to:
$form-field-font-size
Font weight for toolbar form fields.
Defaults to:
$form-field-font-weight
Height for form fields in toolbar.
Defaults to:
$form-field-height
Text color for toolbar file fields
Defaults to:
$form-file-field-color
The text color of toolbar form field labels
Defaults to:
$color
The font-family of toolbar form field labels
Defaults to:
$font-family
The font-size of toolbar form field labels
Defaults to:
$font-size
The font-weight of toolbar form field labels
Defaults to:
$font-weight
Horizontal space between the toolbar field's label and the field body when the label is left-aligned.
Defaults to:
5px
The line-height of toolbar form field labels
Defaults to:
round($form-toolbar-label-font-size * 1.15)
Vertical space between the toolbar field's label and the field body when the label is top-aligned.
Defaults to:
5px
The background color of the toolbar text field's input element
Defaults to:
$form-text-field-background-color
The background image of the toolbar text field's input element
Defaults to:
$form-text-field-background-image
The default width of the toolbar text field's body element (the element that contains the input element and triggers) when the field is not sized explicitly using the width config, or sized by it's containing layout.
Defaults to:
$form-text-field-body-width
The border color of toolbar text fields
Defaults to:
$form-text-field-border-color
Border radius for toolbar text fields
Defaults to:
$form-text-field-border-radius
The border style of toolbar text fields
Defaults to:
$form-text-field-border-style
The border width of toolbar text fields
Defaults to:
$form-text-field-border-width
true to use classic-theme styled border for toolbar text fields.
Defaults to:
$form-text-field-classic-border
The color of the toolbar text field's input element
Defaults to:
$form-text-field-color
Text color for empty toolbar text fields.
Defaults to:
$form-text-field-empty-color
The border color of the focused toolbar text field
Defaults to:
$form-text-field-focus-border-color
Font family for toolbar text fields.
Defaults to:
$form-text-field-font-family
Font size for toolbar text fields.
Defaults to:
$form-text-field-font-size
Font weight for toolbar text fields.
Defaults to:
$form-text-field-font-weight
The height of toolbar text fields
Defaults to:
$form-toolbar-field-height
Background color of the toolbar text field's input element when the field value is invalid.
Defaults to:
$form-text-field-invalid-background-color
Background image of the toolbar text field's input element when the field value is invalid.
Defaults to:
$form-text-field-invalid-background-image
Background position of the toolbar text field's input element when the field value is invalid.
Defaults to:
$form-text-field-invalid-background-position
Background repeat of the toolbar text field's input element when the field value is invalid.
Defaults to:
$form-text-field-invalid-background-repeat
Border color for invalid toolbar text fields.
Defaults to:
$form-text-field-invalid-border-color
The padding of the toolbar text field's input element
Defaults to:
$form-text-field-padding
The default width of the toolbar TextArea's body element (the element that contains the textarea html element when the field is not sized explicitly using the width config, or sized by it's containing layout.
Defaults to:
$form-textarea-body-height
The line-height to use for the toolbar TextArea's text
Defaults to:
$form-textarea-line-height
The background color of the toolbar text field's trigger element
Defaults to:
$form-text-field-background-color
The default background image for toolbar text field triggers
Defaults to:
$form-trigger-background-image
The color of the toolbar text field's trigger's border
Defaults to:
$form-trigger-border-color
The color of the toolbar text field's trigger's border when the field is focused
Defaults to:
$form-trigger-border-color-focus
The color of the toolbar text field's trigger's border when hovered
Defaults to:
$form-trigger-border-color
The color of the toolbar text field's trigger's border when the field is focused and the trigger is hovered
Defaults to:
$form-toolbar-trigger-border-color-over
The style of the toolbar text field's trigger's border
Defaults to:
$form-trigger-border-style
The width of the toolbar text field's trigger's border
Defaults to:
$form-trigger-border-width
The width of the toolbar text field's trigger element
Defaults to:
$form-trigger-width
The background color of the text field's trigger element
Defaults to:
$form-field-background-color
The default background image for text field triggers
Defaults to:
'form/trigger'
The color of the text field's trigger's border
Defaults to:
$form-field-border-color
The color of the text field's trigger's border when the field is focused
Defaults to:
$form-field-focus-border-color
The color of the text field's trigger's border when hovered
Defaults to:
$form-field-border-color
The color of the text field's trigger's border when the field is focused and the trigger is hovered
Defaults to:
$form-trigger-border-color-over
The style of the text field's trigger's border
Defaults to:
$form-field-border-style
The width of the text field's trigger's border
Defaults to:
0
The font-family of the grid field text
Defaults to:
$grid-row-cell-font-family
The font size of the grid field text
Defaults to:
$grid-row-cell-font-size
The font-weight of the grid field text
Defaults to:
$grid-row-cell-font-weight
The height of text fields rendered in the context of a grid cell. Defaults to $form-field-height. If grid row height is smaller than $form-field-height, defaults to the grid row height. Grid row height is calculated by adding $grid-row-cell-line-height to the top and bottom values of $grid-cell-inner-padding.
Defaults to:
if($grid-row-height < $form-field-height, $grid-row-height, $form-field-height)
The background color of a text field's trigger element when rendered in the context of a grid cell
Defaults to:
$form-trigger-background-color
The default background image for text field triggers when rendered in the context of a grid cell
Defaults to:
$form-trigger-background-image
The color of a text field's trigger's border when rendered in the context of a grid cell
Defaults to:
$form-trigger-border-color
The color of a text field's trigger's border when rendered in the context of a grid cell and the field is focused
Defaults to:
$form-trigger-border-color-focus
The color of a text field's trigger's border when rendered in the context of a grid cell and hovered
Defaults to:
$form-trigger-border-color
The color of a text field's trigger's border when rendered in the context of a grid cell and the field is focused and the trigger is hovered
Defaults to:
$grid-cell-field-trigger-border-color-over
The style of a text field's trigger's border when rendered in the context of a grid cell
Defaults to:
$form-trigger-border-style
The width of a text field's trigger's border when rendered in the context of a grid cell
Defaults to:
$form-trigger-border-width
The width of a text field's trigger element when rendered in the context of a grid cell
Defaults to:
$form-trigger-width
Text color for file fields rendered in the context of a grid cell
Defaults to:
$form-file-field-color
The background color of a text field's input element when endered in the context of a grid cell
Defaults to:
$form-text-field-background-color
The background image of a text field's input element when rendered in the context of a grid cell
Defaults to:
$form-text-field-background-image
The default width of a text field's body element (the element that contains the input element and triggers) when the field is rendered in the context of a grid cell and not sized explicitly using the width config, or sized by it's containing layout.
Defaults to:
$form-text-field-body-width
The border color of text fields rendered in the context of a grid cell
Defaults to:
$form-text-field-border-color
Border radius for text fields rendered in the context of a grid cell.
Defaults to:
$form-text-field-border-radius
The border style of text fields rendered in the context of a grid cell
Defaults to:
$form-text-field-border-style
The border width of text fields endered in the context of a grid cell
Defaults to:
$form-text-field-border-width
true to use classic-theme styled border for text fields rendered in the context of a grid cell.
Defaults to:
$form-text-field-classic-border
The color of a text field's input element when rendered in the context of a grid cell
Defaults to:
$grid-cell-field-color
Text color for empty text fields rendered in the context of a grid cell.
Defaults to:
$form-text-field-empty-color
The border color of the focused text fields rendered in the context of a grid cell
Defaults to:
$form-text-field-focus-border-color
Font family for text fields rendered in the context of a grid cell.
Defaults to:
$grid-cell-field-font-family
Font size for text fields rendered in the context of a grid cell.
Defaults to:
$grid-cell-field-font-size
Font weight for text fields rendered in the context of a grid cell.
Defaults to:
$grid-cell-field-font-weight
The height of text fields rendered in the context of a grid cell
Defaults to:
$grid-cell-field-height
Background color of a text field's input element when rendered in the context of a grid cell and the field value is invalid.
Defaults to:
$form-text-field-invalid-background-color
Background image of a grid field text field's input element when the field value is invalid.
Defaults to:
$form-text-field-invalid-background-image
Background position of the grid field text field's input element when rendered in the context of a grid cell and the field value is invalid.
Defaults to:
$form-text-field-invalid-background-position
Background repeat of the grid field text field's input element when the field value is invalid.
Defaults to:
$form-text-field-invalid-background-repeat
Border color for invalid text fields rendered in the context of a grid cell.
Defaults to:
$form-text-field-invalid-border-color
The padding of a text field's input element when rendered in the context of a grid cell
Defaults to:
$grid-cell-field-padding
The default width of the grid field TextArea's body element (the element that contains the textarea html element when the field is rendered in the context of a grid cell and not sized explicitly using the width config, or sized by it's containing layout.
Defaults to:
$form-textarea-body-height
The line-height to use for the TextArea's text when rendered in the context of a grid cell
Defaults to:
$form-textarea-line-height
True to include the "default" field UI
Defaults to:
$include-default-uis
True to include the "grid-cell" form field UIs input fields rendered in the context of a grid cell.
This defaults to true. It is required if either grid editors are being used,
or if a Ext.grid.column.Widget is being used to house an input field.
Defaults to:
false
True to include the "default" label UI
Defaults to:
$include-field-default-ui
True to include the "default" label UI
Defaults to:
$include-field-toolbar-ui
True to include the "default" text field UI
Defaults to:
$include-field-default-ui
True to include the "grid-cell" text field UI
Defaults to:
$include-grid-cell-field-ui
True to include the "toolbar" text field UI
Defaults to:
$include-field-toolbar-ui
The background color of scroll indicators when touch scrolling is enabled
Defaults to:
#000
The border-radius of scroll indicators when touch scrolling is enabled
Defaults to:
3px
The space between scroll indicators and the edge of their container
Defaults to:
2px
The opacity of scroll indicators when touch scrolling is enabled
Defaults to:
.5
The background color of scroll indicators when touch scrolling is enabled
Defaults to:
6px
Creates a visual theme for "labelable" form items. Provides visual styling for the Label and error message that can be shared between many types of form fields.
$ui : String
The name of the UI being created. Can not included spaces or special punctuation (used in CSS class names).
$ui-font-color : color (optional)
The text color the label
Defaults to: $form-label-font-color
$ui-font-weight : String (optional)
The font-weight of the label
Defaults to: $form-label-font-weight
$ui-font-size : Number (optional)
The font-size of the label
Defaults to: $form-label-font-size
$ui-font-family : String (optional)
The font-family the label
Defaults to: $form-label-font-family
$ui-height : Number (optional)
The height of the label. This should be the same height as the height of fields that this label ui will be used with. This does not actually set the height of the label but is used to ensure that the label is centered within the given height.
Defaults to: $form-field-height
$ui-line-height : Number (optional)
The line-height of the label
Defaults to: $form-label-line-height
$ui-horizontal-spacing: $form-label-horizontal-spacing : Number (optional)
Horizontal space between the label and the field body when the label is left-aligned.
$ui-vertical-spacing: $form-label-vertical-spacing : Number (optional)
Vertical space between the label and the field body when the label is top-aligned.
$ui-error-icon-background-image : Number (optional)
The background-image of the error icon
Defaults to: $form-error-icon-background-image
$ui-error-icon-width : Number (optional)
The width of the error icon
Defaults to: $form-error-icon-width
$ui-error-icon-height : Number (optional)
The height of the error icon
Defaults to: $form-error-icon-height
$ui-error-icon-side-margin : Number/list (optional)
Margin for error icons when aligned to the side of the field
Defaults to: $form-error-icon-side-margin
$ui-error-under-icon-spacing : Number (optional)
The space between the icon and the message for errors that display under the field
Defaults to: $form-error-under-icon-spacing
$ui-error-under-padding : Number/list (optional)
The padding on errors that display under the form field
Defaults to: $form-error-under-padding
$ui-error-msg-color : color (optional)
The text color of form error messages
Defaults to: $form-error-msg-color
$ui-error-msg-font-weight : String (optional)
The font-weight of form error messages
Defaults to: $form-error-msg-font-weight
$ui-error-msg-font-size : Number (optional)
The font-size of form error messages
Defaults to: $form-error-msg-font-size
$ui-error-msg-font-family : String (optional)
The font-family of form error messages
Defaults to: $form-error-msg-font-family
$ui-error-msg-line-height : Number (optional)
The line-height of form error messages
Defaults to: $form-error-msg-line-height
$ui-disabled-opacity : Number (optional)
Opacity of disabled form fields
Defaults to: $form-field-disabled-opacity
Creates a visual theme for text fields. Note this mixin only provides styling for the form field body, The label and error are styled by extjs-label-ui.
$ui : String
The name of the UI being created. Can not included spaces or special punctuation (used in CSS class names).
$ui-height : Number (optional)
The height of the text field
Defaults to: $form-text-field-height
$ui-font-size : Number (optional)
The font-size of the text field
Defaults to: $form-text-field-font-size
$ui-font-family : String (optional)
The font-family of the text field
Defaults to: $form-text-field-font-family
$ui-font-weight : String (optional)
The font-weight of the text field
Defaults to: $form-text-field-font-weight
$ui-color : color (optional)
The color of the text field's input element
Defaults to: $form-text-field-color
$ui-background-color : color (optional)
The background color of the text field's input element
Defaults to: $form-text-field-background-color
$ui-border-width : Number/list (optional)
The border width of the text field
Defaults to: $form-text-field-border-width
$ui-border-style : String/list (optional)
The border style of the text field
Defaults to: $form-text-field-border-style
$ui-border-color : color/list (optional)
The border color of text fields
Defaults to: $form-text-field-border-color
$ui-focus-border-color : color/list (optional)
The border color of the text field when focused
Defaults to: $form-text-field-focus-border-color
$ui-invalid-border-color : color (optional)
The border color of the text field when the field value is invalid.
Defaults to: $form-text-field-invalid-border-color
$ui-border-radius : Number/list (optional)
The border radius of the text field
Defaults to: $form-text-field-border-radius
$ui-background-image : String (optional)
The background image of the text field's input element
Defaults to: $form-text-field-background-image
$ui-padding : Number/list (optional)
The padding of the text field's input element
Defaults to: $form-text-field-padding
$ui-empty-color : color (optional)
Text color for of the text field when empty
Defaults to: $form-text-field-empty-color
$ui-body-width : Number (optional)
The default width of the text field's body element (the element that contains the input element and triggers) when the field is not sized explicitly using the width config, or sized by it's containing layout.
Defaults to: $form-text-field-body-width
$ui-invalid-background-color : color (optional)
Background color of the input element when the field value is invalid.
Defaults to: $form-field-invalid-background-color
$ui-invalid-background-image : String (optional)
Background image of the input element when the field value is invalid.
Defaults to: $form-field-invalid-background-image
$ui-invalid-background-repeat : String (optional)
Background repeat of the input element when the field value is invalid.
Defaults to: $form-field-invalid-background-repeat
$ui-invalid-background-position : String/list (optional)
Background position of the input element when the field value is invalid.
Defaults to: $form-field-invalid-background-position
$ui-trigger-width : Number (optional)
The width of the trigger element
Defaults to: $form-trigger-width
$ui-trigger-border-width : Number/list (optional)
The width of the trigger's border
Defaults to: $form-trigger-border-width
$ui-trigger-border-color : color/list (optional)
The color of the trigger's border
Defaults to: $form-trigger-border-color
$ui-trigger-border-style : String/list (optional)
The style of the trigger's border
Defaults to: $form-trigger-border-style
$ui-trigger-border-color-over : color (optional)
The color of the trigger's border when hovered
Defaults to: $form-trigger-border-color-over
$ui-trigger-border-color-focus : color (optional)
The color of the trigger's border when the field is focused
Defaults to: $form-trigger-border-color-focus
$ui-trigger-border-color-pressed : color (optional)
The color of the trigger's border when the field is focused and the trigger is hovered
Defaults to: $form-trigger-border-color-pressed
$ui-trigger-background-image : String (optional)
The default background image for the trigger
Defaults to: $form-trigger-background-image
$ui-trigger-background-color : color (optional)
The background color of the trigger element
Defaults to: $form-trigger-background-color
$ui-textarea-line-height : Number (optional)
The line-height of the textarea element when this mixin is used to style a Ext.form.field.TextArea
Defaults to: $form-textarea-line-height
$ui-textarea-body-height : Number (optional)
The default width of the TextArea's body element (the element that contains the textarea html element when the field is not sized explicitly using the widthconfig, or sized by it's containing layout.
Defaults to: $form-textarea-body-height
$ui-file-field-color : color (optional)
The text color of the input element when this mixin is used to style a Ext.form.field.File
Defaults to: $form-file-field-color
$ui-classic-border : Boolean (optional)
true to use classic-theme styled border.
Defaults to: $form-text-field-classic-border
Ext JS | Terms of Use