Docs Help

Terms, Icons, and Labels

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

Access Levels

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

Member Types

Member Syntax

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

lookupComponent ( item ) : Ext.Component
protected

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

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

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

Parameters

item :  Object

The config object being added.

Returns
Ext.Component

The component to be added.

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

Member Flags

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

Class Icons

- Indicates a framework class

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

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

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

Member Icons

- Indicates a class member of type config

- Indicates a class member of type property

- Indicates a class member of type method

- Indicates a class member of type event

- Indicates a class member of type theme variable

- Indicates a class member of type theme mixin

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

Class Member Quick-Nav Menu

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

Getter and Setter Methods

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

History Bar

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

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

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

Search and Filters

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

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

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

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

API Doc Class Metadata

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

Expanding and Collapsing Examples and Class Members

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

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

Desktop -vs- Mobile View

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

Viewing the Class Source

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

Ext JS 6.5.0 - Classic Toolkit


top

Ext.form.field.Tag xtype: tagfield

Summary

tagfield provides a combobox that removes the hassle of dealing with long and unruly select options. The selected list is visually maintained in the value display area instead of within the picker itself. Users may easily add or remove tags from the display value area.

History

Inspired by the SuperBoxSelect component for ExtJS 3, which in turn was inspired by the BoxSelect component for ExtJS 2.

Various contributions and suggestions made by many members of the ExtJS community which can be seen in the user extension forum post.

By: kvee_iv http://www.sencha.com/forum/member.php?29437-kveeiv

No members found using the current filters

configs

Required Configs

store : Ext.data.Store / String / Array / Object
bindable bind required req

The data source to which the combo / tagfield is bound. Acceptable values for this property are:

  • any Ext.data.Store class / subclass
  • an ID of a store
  • an Array : Arrays will be converted to a Ext.data.Store internally, automatically generating field names to work with all data components.

    • 1-dimensional array : (e.g., ['Foo','Bar'])

      A 1-dimensional array will automatically be expanded (each array item will be used for both the combo valueField and displayField)

    • 2-dimensional array : (e.g., [['f','Foo'],['b','Bar']])

      For a multi-dimensional array, the value in index 0 of each item will be assumed to be the combo valueField, while the value at index 1 is assumed to be the combo displayField.

  • a Ext.data.Store config object. When passing a config you can specify the store type by alias. Passing a config object with a store type will dynamically create a new store of that type when the combo / tagfield is instantiated.

    Ext.define('MyApp.store.States', {

    extend: 'Ext.data.Store',
    alias: 'store.states',
    fields: ['name']
    

    });

    Ext.create({

    xtype: 'combobox',
    renderTo: document.body,
    store: {
        type: 'states',
        data: [{
            name: 'California'
        }]
    },
    queryMode: 'local',
    displayField: 'name',
    valueField: 'name'
    

    });

See also queryMode.

getStore Ext.data.AbstractStore

Gets the current store instance.

Returns

:Ext.data.AbstractStore

The store, null if one does not exist.

setStore ( store )

Sets the store to the specified store.

Available since: 5.0.0

Parameters

store :  Object

valueField : String
required req

The underlying data value name to bind to this ComboBox.

Note: use of a valueField requires the user to make a selection in order for a value to be mapped. See also displayField.

Defaults to match the value of the displayField config.

Optional Configs

activeCounter : Number
bindable bind private pri

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

Defaults to:

0

getActiveCounter : Number

Returns the value of activeCounter

Returns

Number

setActiveCounter (activeCounter)

Sets the value of activeCounter

Parameters

activeCounter :  Number

activeError : String
bindable bind

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.

getActiveError String

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.

Returns

:String

The active error message on the component; if there is no error, an empty string is returned.

setActiveError ( msg )

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.

Parameters

msg :  String

The error message

activeErrorsTpl : String / String[] / Ext.XTemplate

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

afterBodyEl : String / Array / Ext.XTemplate

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.

afterLabelTextTpl : String / Array / Ext.XTemplate

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.

afterLabelTpl : String / Array / Ext.XTemplate

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.

afterSubTpl : String / Array / Ext.XTemplate

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.

alignOnScroll : Boolean

By default, when the alignTo method is called, a floating component will scroll to keep aligned with the anchoring element if the anchoring element is part of the scroll.

If this is not necessary, and the alignTo is a one-off operation then set this config to false.

Defaults to:

true

alignTarget : String

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

Only applicable if this component is cfg-floating

Used upon first show.

Defaults to:

null

allowBlank : Boolean

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

allQuery : String

The text query to send to the server to return all records for the list with no filtering

Defaults to:

''

alwaysOnTop : Boolean / Number
bindable bind

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

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

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

Defaults to:

false

getAlwaysOnTop : Boolean / Number

Returns the value of alwaysOnTop

Returns

Boolean / Number

setAlwaysOnTop (alwaysOnTop)

Sets the value of alwaysOnTop

Parameters

alwaysOnTop :  Boolean / Number

anchor : String

This configuration option is to be applied to child items of a container managed by an Ext.layout.container.Anchor.

This value is what tells the layout how an item should be anchored to the container. items added to an AnchorLayout accept an anchoring-specific config property of anchor which is a string containing two values: the horizontal anchor value and the vertical anchor value (for example, '100% 50%'). The following types of anchor values are supported:

  • Percentage : Any value between 1 and 100, expressed as a percentage.

    The first anchor is the percentage width that the item should take up within the container, and the second is the percentage height. For example:

    // two values specified
    anchor: '100% 50%' // render item complete width of the container and
                       // 1/2 height of the container
    // one value specified
    anchor: '100%'     // the width value; the height will default to auto
    
  • Offsets : Any positive or negative integer value.

    This is a raw adjustment where the first anchor is the offset from the right edge of the container, and the second is the offset from the bottom edge. For example:

    // two values specified
    anchor: '-50 -100' // render item the complete width of the container
                       // minus 50 pixels and
                       // the complete height minus 100 pixels.
    // one value specified
    anchor: '-50'      // anchor value is assumed to be the right offset value
                       // bottom offset will default to 0
    
  • Sides : Valid values are right (or r) and bottom (or b).

    Either the container must have a fixed size or an anchorSize config value defined at render time in order for these to have any effect.

  • Mixed :

    Anchor values can also be mixed as needed. For example, to render the width offset from the container right edge by 50 pixels and 75% of the container's height use:

    anchor:   '-50 75%'
    

animateShadow : Boolean

true to animate the shadow along with the component while the component is animating. By default the shadow is hidden while the component is animating

Defaults to:

false

anyMatch : Boolean

Configure as true to allow matching of the typed characters at any position in the valueField's value.

Defaults to:

false

ariaAttributes : Object
bindable bind

An object containing ARIA attributes to be set on this Component's ARIA element. Use this to set the attributes that cannot be determined by the Component's state, such as aria-live, aria-flowto, etc.

Note that this config is only meaningful at the Component rendering time, and setting it after that will do nothing.

Defaults to:

null

getAriaAttributes : Object

Returns the value of ariaAttributes

Returns

Object

setAriaAttributes (ariaAttributes)

Sets the value of ariaAttributes

Parameters

ariaAttributes :  Object

ariaAvailableListLabel : String

Label to be announced to screen reader users when they use Up and Down arrow keys to navigate the list of available values.

Defaults to:

'Available values'

ariaDescribedBy : String

DOM selector for a child element that is to be used as description for this Component, set in aria-describedby attribute. The selector works the same way as ariaLabelledBy.

ariaDeselectedText : String

Template text for announcing deselected values to screen reader users. '{0}' will be replaced with the list of values removed from selected list.

Defaults to:

'{0} removed from selection.'

ariaErrorText : String

Localized announcement text for validation errors. This text will be used by Assistive Technologies such as screen readers to alert the users when field validation fails.

This config is used with Ext.String.format. '{0}' will be replaced with the actual error message(s), '{1}' will be replaced with field label.

Defaults to:

'Input error. {0}.'

ariaHelp : String

Optional text description for this object. This text will be announced to Assistive Technology users when the object is focused.

Defaults to:

undefined

ariaHelpText : String

The text to be announced by screen readers when input element is focused. This text is used when this component is configured not to allow creating new values; when createNewOnEnter is set to true, ariaHelpTextEditable will be used instead.

Defaults to:

'Use Up and Down arrows to view available values, Enter to select. ' + 'Use Left and Right arrows to view selected values, Delete key to deselect.'

ariaHelpTextEditable : String

The text to be announced by screen readers when input element is focused. This text is used when createNewOnEnter is set to true; see also ariaHelpText.

Defaults to:

'Use Up and Down arrows to view available values, Enter to select. ' + 'Type and press Enter to create a new value. ' + 'Use Left and Right arrows to view selected values, Delete key to deselect.'

ariaLabel : String

ARIA label for this Component. It is best to use ariaLabelledBy option instead, because screen readers prefer aria-labelledby attribute to aria-label. ariaLabel and ariaLabelledBy config options are mutually exclusive.

ariaLabelledBy : String

DOM selector for a child element that is to be used as label for this Component, set in aria-labelledby attribute. If the selector is by id, the label element can be any existing element, not necessarily a child of the main Component element.

ariaLabelledBy and ariaLabel config options are mutually exclusive, and ariaLabelledBy has the higher precedence.

ariaNoneSelectedText : String

Text to announce to screen reader users when no values are currently selected. This text is used when Tag field is focused.

Defaults to:

'No value selected.'

ariaSelectedListLabel : String

Label to be announced to screen reader users when they use Left and Right arrow keys to navigate the list of currently selected values.

Defaults to:

'Selected values'

ariaSelectedText : String

Template text for announcing selected values to screen reader users. '{0}' will be replaced with the list of selected values.

Defaults to:

'Selected {0}.'

autoEl : String / Object

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

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

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

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

Available since: 2.3.0

autoFitErrors : Boolean

Whether to adjust the component's body width to make room for 'side' error messages.

Defaults to:

true

autoHideInputMask : Boolean
bindable bind

Specify as false to always show the inputMask.

Defaults to:

true

Available since: 6.5.0

getAutoHideInputMask : Boolean

Returns the value of autoHideInputMask

Returns

Boolean

setAutoHideInputMask (autoHideInputMask)

Sets the value of autoHideInputMask

Parameters

autoHideInputMask :  Boolean

autoLoadOnValue : Boolean

This option controls whether to initially load the store when a value is set so that the display value can be determined from the appropriate record. The store will only be loaded in a limited set of circumstances:

  • The store is not currently loading.
  • The store does not have a pending Ext.data.Store#autoLoad.
  • The store has not been loaded before.

Defaults to:

false

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

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

autoScroll : Boolean
deprecated dep bindable bind

true to use overflow:'auto' on the components layout element and show scroll bars automatically when necessary, false to clip any overflowing content.

This should not be combined with overflowX or overflowY.

Defaults to:

false

Deprecated since version 5.1.0
Use scrollable instead

setAutoScroll ( scroll ) : Ext.Component
chainable ch deprecated dep

Sets the overflow on the content element of the component.

Parameters

scroll :  Boolean

True to allow the Component to auto scroll.

Returns

:Ext.Component

this

Deprecated since version 5.0.0
Use setScrollable instead

autoSelect : Boolean

true to automatically highlight the first result gathered by the data store in the dropdown list when it is opened. A false value would cause nothing in the list to be highlighted automatically, so the user would have to manually highlight an item before pressing the enter or tab key to select it (unless the value of (typeAhead) were true), or use the mouse to select a value.

Defaults to:

true

autoSelectLast : Boolean

When true, the last selected record in the dropdown list will be re-selected upon autoSelect. Set to false to always select the first record in the drop-down list. For accessible applications it is recommended to set this option to false.

Defaults to:

true

autoShow : Boolean

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

Defaults to:

false

Available since: 2.3.0

baseBodyCls : String

The CSS class to be applied to the body content element.

Defaults to:

Ext.baseCSSPrefix + 'form-item-body'

baseCls : String

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

Defaults to:

'x-component'

beforeBodyEl : String / Array / Ext.XTemplate

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.

beforeLabelTextTpl : String / Array / Ext.XTemplate

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.

beforeLabelTpl : String / Array / Ext.XTemplate

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.

beforeSubTpl : String / Array / Ext.XTemplate

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.

bind : Object / String
bindable bind

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

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

To dynamically add bindings:

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

To remove bindings:

 panel.setBind({
     title: null
 });

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

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

Defaults to:

null

getBind : Object / String

Returns the value of bind

Returns

Object / String

setBind (bind)

Sets the value of bind

Parameters

bind :  Object / String

blankText : String

The error text to display if the allowBlank validation fails.

Defaults to:

'This field is required'

border : Number / String / Boolean
bindable bind

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.

setBorder ( border )

Parameters

border :  String/Number

The border, see border. If a falsey value is passed

caseSensitive : Boolean

Configure as true to make the filtering match with exact case matching

Defaults to:

false

checkChangeBuffer : Number

Defines a timeout in milliseconds for buffering checkChangeEvents that fire in rapid succession. Defaults to 50 milliseconds.

Defaults to:

50

checkChangeEvents : String[]

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:

  • Safari 3.2 and older: cut/paste in textareas via the context menu, and dragging text into textareas
  • Opera 10 and 11: dragging text into text fields and textareas, and cut via the context menu in text fields and textareas
  • Opera 9: Same as Opera 10 and 11, plus paste from context menu in text fields and textareas

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

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

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

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

For example:

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

The above is translated into the following complete form:

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

The above can be provided as an array like so:

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

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

Note: childEls in the renderTpl must be referenced in a data-ref attribute. Notice in the above example that the "title" childEl is set in the renderTpl using data-ref="title".

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

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

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

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

Defaults to:

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

getChildEls : Object / String[] / Object[]

Returns the value of childEls

Returns

Object / String[] / Object[]

setChildEls (childEls)

Sets the value of childEls

Parameters

childEls :  Object / String[] / Object[]

clearFilterOnBlur : Boolean

When queryMode is 'local' only

As text is entered, the underlying store is filtered to match the value. When this option is true, any filtering applied by this field will be cleared when focus is removed & reinstated on focus. If false, the filters will be left in place.

Defaults to:

true

clearOnBackspace : Boolean

Set to false to disable clearing selected values with Backspace key. This mode is recommended for accessible applications.

Defaults to:

true

cls : String / String[]

An optional extra CSS class that will be added to this component's Element. The value can be a string, a list of strings separated by spaces, or an array of strings. This can be useful for adding customized styles to the component or any of its children using standard CSS rules.

Defaults to:

''

Available since: 1.1.0

collapseOnSelect : Boolean
deprecated dep

Has no effect if multiSelect is false

Configure as true to automatically collapse the pick list after a selection is made.

Defaults to:

false

Deprecated since version 5.1.0
For multiple selection use Ext.form.field.Tag or Ext.view.MultiSelector

columnWidth : Number

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

The columnWidth property is always evaluated as a percentage and must be a decimal value greater than 0 and less than 1 (e.g., .25). See the description at the top of Ext.layout.container.Column for additional usage details when combining width and columnWidth configs within the layout.

componentCls : String

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

componentLayout : String / Object
bindable bind

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

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

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

Defaults to:

'autocomponent'

setComponentLayout ( layout )
private pri

Parameters

layout :  Object

constrain : Boolean

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

constraintInsets : Object / String

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

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

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

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

contentEl : String

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

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

Notes:

The specified HTML element is appended to the layout element of the component after any configured HTML has been inserted, and so the document will not contain this element at the time the 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

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

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

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

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

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

Defaults to:

null

getController Ext.app.ViewController

Returns the Ext.app.ViewController instance associated with this component via the controller config or setController method.

Returns

:Ext.app.ViewController

Returns this component's ViewController or null if one was not configured

setController (controller)

Sets the value of controller

Parameters

controller :  String / Object / Ext.app.ViewController

createNewOnBlur : Boolean

Has no effect if forceSelection is true.

With this set to true, the creation described in forceSelection will also be triggered when the field loses focus.

Please note that this behavior is also affected by the configuration options autoSelect and selectOnTab. If those are true and an existing item would have been selected as a result, the partial text the user has entered will be discarded and the existing item will be added to the selection.

Setting this option to true is not recommended for accessible applications.

Defaults to:

false

createNewOnEnter : Boolean

Has no effect if forceSelection is true.

With this set to true, the creation described in forceSelection will also be triggered by the 'enter' key.

Defaults to:

false

data : Object
bindable bind

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

Defaults to:

null

Available since: 3.4.0

getData : Object

Returns the value of data

Returns

Object

setData (data)

Sets the value of data

Parameters

data :  Object

defaultAlign : String

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

Only applicable if this component is cfg-floating

Used upon first show.

Defaults to:

"c-c"

defaultListConfig : Object

Set of options that will be used as defaults for the user-configured listConfig object.

Defaults to:

{
    loadingHeight: 70,
    minWidth: 70,
    maxHeight: 300,
    shadow: 'sides'
}

defaultListenerScope : Boolean
bindable bind

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

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

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

Defaults to:

false

getDefaultListenerScope : Boolean

Returns the value of defaultListenerScope

Returns

Boolean

setDefaultListenerScope (defaultListenerScope)

Sets the value of defaultListenerScope

Parameters

defaultListenerScope :  Boolean

delimiter : String
bindable bind

The character(s) used to separate new values to be added when createNewOnEnter or createNewOnBlur are set. multiSelect = true.

Defaults to:

','

getDelimiter : String

Returns the value of delimiter

Returns

String

setDelimiter (delimiter)

Sets the value of delimiter

Parameters

delimiter :  String

dirtyCls : String

The CSS class to use when the field value is dirty.

Defaults to:

Ext.baseCSSPrefix + 'form-dirty'

disabled : Boolean
bindable bind

true to disable the component.

Defaults to:

false

Available since: 2.3.0

setDisabled ( disabled )
chainable ch

Enable or disable the component.

Parameters

disabled :  Boolean

true to disable.

disabledCls : String

CSS class to add when the Component is disabled.

Defaults to:

'x-item-disabled'

disableKeyFilter : Boolean

Specify true to disable input keystroke filtering. This will ignore the maskRe field.

Defaults to:

false

displayField : String
bindable bind

The underlying data field name to bind to this ComboBox.

See also valueField.

Defaults to:

'text'

getDisplayField : String

Returns the value of displayField

Returns

String

setDisplayField (displayField)

Sets the value of displayField

Parameters

displayField :  String

displayTpl : String / String[] / Ext.XTemplate
bindable bind

The template to be used to display selected records inside the text field. An array of the selected records' data will be passed to the template. Defaults to:

'<tpl for=".">' +
    '{[typeof values === "string" ? values : values["' + me.displayField + '"]]}' +
    '<tpl if="xindex < xcount">' + me.delimiter + '</tpl>' +
'</tpl>'

By default only the immediate data of the record is passed (no associated data). The getRecordDisplayData can be overridden to extend this.

Defaults to:

null

getDisplayTpl : String / String[] / Ext.XTemplate

Returns the value of displayTpl

Returns

String / String[] / Ext.XTemplate

setDisplayTpl (displayTpl)

Sets the value of displayTpl

Parameters

displayTpl :  String / String[] / Ext.XTemplate

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

The side of the Ext.panel.Panel where this component is to be docked when specified in the panel's dockedItems config.

Possible values are:

  • top
  • bottom
  • left
  • right

setDock ( dock ) : Ext.Component
chainable ch

Sets the dock position of this component in its parent panel. Note that this only has effect if this item is part of the dockedItems collection of a parent that has a DockLayout (note that any Panel has a DockLayout by default)

Parameters

dock :  Object

The dock position.

Returns

:Ext.Component

this

draggable : Boolean / Object

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

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

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

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

Defaults to:

false

editable : Boolean
bindable bind

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

getEditable : Boolean

Returns the value of editable

Returns

Boolean

setEditable (editable)

Sets the value of editable

Parameters

editable :  Boolean

emptyCls : String

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'

emptyText : String
bindable bind

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.

Defaults to:

''

getEmptyText String

Returns the value of this field's cfg-emptyText

Returns

:String

The value of this field's emptyText

setEmptyText ( value ) : Ext.form.field.Text
chainable ch

Sets the default text to place into an empty field

Parameters

value :  String

The cfg-emptyText value for this field

Returns

:Ext.form.field.Text

this

enableKeyEvents : Boolean

true to enable the proxying of key events for the HTML input field

Defaults to:

false

enableRegEx : Boolean

When queryMode is 'local' only

Set to true to have the ComboBox use the typed value as a RegExp source to filter the store to get possible matches. Invalid regex values will be ignored.

encodeSubmitValue : Boolean

Has no effect if multiSelect is false.

Controls the formatting of the form submit value of the field as returned by getSubmitValue

  • true for the field value to submit as a json encoded array in a single GET/POST variable
  • false for the field to submit as an array of GET/POST variables

Defaults to:

false

enforceMaxLength : Boolean

True to set the maxLength property on the underlying input field. Defaults to false

errorMsgCls : String

The CSS class to be applied to the error message element.

Defaults to:

Ext.baseCSSPrefix + 'form-error-msg'

fieldBodyCls : String

An extra CSS class to be applied to the body content element in addition to baseBodyCls.

Defaults to:

''

fieldCls : String

The default CSS class for the field input

Defaults to:

'x-form-field'

fieldLabel : String
bindable bind

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

getFieldLabel String
template tpl

Returns the label for the field. Defaults to simply returning the fieldLabel config. Can be overridden to provide a custom generated label.

Returns

:String

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.

setFieldLabel ( label )

Set the label of this field.

Parameters

label :  String

The new label. The labelSeparator will be automatically appended to the label string.

fieldStyle : String
bindable bind

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.

setFieldStyle ( style )

Set the CSS style of the field input element.

Parameters

style :  String/Object/Function

The style(s) to apply. Should be a valid argument to Ext.dom.Element#applyStyles.

fieldSubTpl
private pri

Defaults to:

[
    // listWrapper div is tabbable in Firefox, for some unfathomable reason
    '<div id="{cmpId}-listWrapper" data-ref="listWrapper"' + (Ext.isGecko ? ' tabindex="-1"' : ''),
    '<tpl foreach="ariaElAttributes"> {$}="{.}"</tpl>',
    ' class="' + Ext.baseCSSPrefix + 'tagfield {fieldCls} {typeCls} {typeCls}-{ui}"<tpl if="wrapperStyle"> style="{wrapperStyle}"</tpl>>',
    '<span id="{cmpId}-selectedText" data-ref="selectedText" aria-hidden="true" class="' + Ext.baseCSSPrefix + 'hidden-clip"></span>',
    '<ul id="{cmpId}-itemList" data-ref="itemList" role="presentation" class="' + Ext.baseCSSPrefix + 'tagfield-list{itemListCls}">',
    '<li id="{cmpId}-inputElCt" data-ref="inputElCt" role="presentation" class="' + Ext.baseCSSPrefix + 'tagfield-input">',
    '<input id="{cmpId}-inputEl" data-ref="inputEl" type="{type}" ',
    '<tpl if="name">name="{name}" </tpl>',
    '<tpl if="value"> value="{[Ext.util.Format.htmlEncode(values.value)]}"</tpl>',
    '<tpl if="size">size="{size}" </tpl>',
    '<tpl if="tabIdx != null">tabindex="{tabIdx}" </tpl>',
    '<tpl if="disabled"> disabled="disabled"</tpl>',
    '<tpl foreach="inputElAriaAttributes"> {$}="{.}"</tpl>',
    'class="' + Ext.baseCSSPrefix + 'tagfield-input-field {inputElCls} {emptyCls} {fixCls}" autocomplete="off">',
    '</li>',
    '</ul>',
    '<ul id="{cmpId}-ariaList" data-ref="ariaList" role="listbox"',
    '<tpl if="ariaSelectedListLabel"> aria-label="{ariaSelectedListLabel}"</tpl>',
    '<tpl if="multiSelect"> aria-multiselectable="true"</tpl>',
    ' class="' + Ext.baseCSSPrefix + 'tagfield-arialist">',
    '</ul>',
    '</div>',
    {
        disableFormats: true
    }
]

filterPickList : Boolean

True to hide the currently selected values from the drop down list.

Setting this option to true is not recommended for accessible applications.

  • true to hide currently selected values from the drop down pick list
  • false to keep the item in the pick list as a selected item

Defaults to:

false

fixed : Boolean

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

Defaults to:

false

flex : Number
bindable bind

Flex may be applied to child items of a box layout (Ext.layout.container.VBox or Ext.layout.container.HBox). Each child item with a flex property will fill space (horizontally in hbox, vertically in vbox) according to that item's relative flex value compared to the sum of all items with a flex value specified.

Any child items that have either a flex of 0 or undefined will not be 'flexed' (the initial size will not be changed).

setFlex ( flex )
private pri

Sets the flex property of this component. Only applicable when this component is an item of a box layout

Parameters

flex :  Number

floating : Boolean

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

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

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

Floating Components as child items of a Container

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

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

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

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

Floating components do not participate in the Container's layout. Because of this, they are not rendered until you explicitly 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

focusCls : String

The CSS class to use when the field receives focus

Defaults to:

'x-form-focus'

focusOnToFront : Boolean

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

Defaults to:

true

forceSelection : Boolean

true to restrict the selected value to one of the values in the list, false to allow the user to set arbitrary text into the field.

When forceSelection is false, new records can be created by the user as they are typed. These records are not added to the combo's store. Multiple new values may be added by separating them with the delimiter, and can be further configured using the createNewOnEnter and createNewOnBlur configuration options.

This functionality is primarily useful for things such as an email address.

Defaults to:

true

formatText : String

Helpful text describing acceptable format for field values. This text will be announced by Assistive Technologies such as screen readers when the field is focused.

This option is superseded by ariaHelp.

formBind : Boolean

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

Defaults to:

false

formItemCls : String

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'

frame : Boolean

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.

grow : Boolean

true if this field should automatically grow and shrink vertically to its content. Note that this overrides the natural trigger grow functionality, which is used to size the field horizontally.

Defaults to:

true

growMax : Number / Boolean

Has no effect if grow is false

The maximum height to allow when grow is true, or false to allow for natural vertical growth based on the current selected values. See also growMin.

Defaults to:

false

growMin : Number / Boolean

Has no effect if grow is false

The minimum height to allow when grow is true, or false to allow for natural vertical growth based on the current selected values. See also growMax.

Defaults to:

false

height : Number / String
bindable bind

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

getHeight Number

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

Returns

:Number

setHeight ( height ) : Ext.Component

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

Parameters

height :  Number

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

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

Returns

:Ext.Component

this

hidden : Boolean
bindable bind

true to hide the component.

Defaults to:

false

Available since: 2.3.0

setHidden ( hidden ) : Ext.Component

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

Parameters

hidden :  Boolean

Returns

:Ext.Component

hiddenDataCls : String
private pri

CSS class used to find the hiddenDataEl

Defaults to:

Ext.baseCSSPrefix + 'hidden-display ' + Ext.baseCSSPrefix + 'form-data-hidden'

hiddenName : String

The name of an underlying hidden field which will be synchronized with the underlying value of the combo. This option is useful if the combo is part of a form element doing a regular form post. The hidden field will not be created unless a hiddenName is specified.

Defaults to:

""

hideEmptyLabel : Boolean

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

hideLabel : Boolean

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

hideMode : String

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

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

Defaults to:

'display'

Available since: 1.1.0

hideTrigger : Boolean
bindable bind

true to hide all triggers

Defaults to:

false

getHideTrigger : Boolean

Returns the value of hideTrigger

Returns

Boolean

setHideTrigger (hideTrigger)

Sets the value of hideTrigger

Parameters

hideTrigger :  Boolean

html : String / Object
bindable bind

An HTML fragment, or a Ext.dom.Helper specification to use as the layout element content. The HTML content is added after the component is rendered, so the document will not contain this HTML at the time the 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

setHtml ( htmlOrData, [loadScripts], [callback], [scriptScope] )

Update the content area of a component.

Available since: 3.4.0

Parameters

htmlOrData :  String/Object

If this component has been configured with a template via the tpl config then it will use this argument as data to populate the template. If this component was not configured with a template, the components content area will be updated via Ext.Element update.

loadScripts :  Boolean (optional)

Only legitimate when using the html configuration. Causes embedded script tags to be executed. Inline source will be executed with this Component as the scope (this reference).

Defaults to: false

callback :  Function (optional)

Only legitimate when using the html configuration. Callback to execute when scripts have finished loading.

scriptScope :  Object (optional)

The scope (this reference) in which to execute inline script elements content. Scripts with a src attribute cannot be executed with this scope.

Defaults to: `this`

id : String

The unique id of this component instance.

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

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

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

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

Defaults to an auto-assigned id.

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

Available since: 1.1.0

getId String

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

Returns

:String

inputAttrTpl : String / Array / Ext.XTemplate

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.

inputId : String

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.

getInputId

Returns the input id for this field. If none was specified via the inputId config, then an id will be automatically generated.

inputMask : String / Ext.field.InputMask
bindable bind

Important: To use this config you must require Ext.field.InputMask or use a complete framework build. The logic to implement an inputMask is not automatically included in a build.

Defaults to:

null

Available since: 6.5.0

getInputMask : String / Ext.field.InputMask

Returns the value of inputMask

Returns

String / Ext.field.InputMask

setInputMask (inputMask)

Sets the value of inputMask

Parameters

inputMask :  String / Ext.field.InputMask

inputType : String

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'

inputWrapCls : String

The CSS class that is added to the element wrapping the input element

Defaults to:

Ext.baseCSSPrefix + 'form-text-wrap'

invalidCls : String

The CSS class to use when marking the component invalid.

Defaults to:

Ext.baseCSSPrefix + 'form-invalid'

invalidText : String

The error text to use when marking a field invalid and no message is provided

Defaults to:

'The value in this field is invalid'

isTextInput : Boolean
private pri

true if this field renders as a text input.

Defaults to:

true

Available since: 5.0.1

itemId : String

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

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

var c = new Ext.panel.Panel({ //
    height: 300,
    renderTo: document.body,
    layout: 'auto',
    items: [{
        itemId: 'p1',
        title: 'Panel 1',
        height: 150
    },{
        itemId: 'p2',
        title: 'Panel 2',
        height: 150
    }]
});

p1 = c.getComponent('p1'); // not the same as Ext.getCmp()
console.log(p1);
p2 = p1.ownerCt.getComponent('p2'); // reference via a sibling
console.log(p2);

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

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

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

Available since: 3.4.0

getItemId String

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

Returns

:String

keyMap : Object
bindable bind

An object containing handlers for keyboard events. The property names of this object are the key name and any modifiers. The values of the properties are the descriptors of how to handle each event.

The handler descriptor can be simply the handler function (either the literal function or the method name), or it can be an object with these properties:

  • handler: The function or its name to call to handle the event.
  • scope: The this pointer context (can be "this" or "controller").
  • event: An optional override of the key event to which to listen.

Important: Calls to setKeyMap do not replace the entire keyMap but instead update the provided mappings. That is, unless null is passed as the value of the keyMap which will clear the keyMap of all entries.

Defaults to:

null

Properties

scope : String

The default scope to apply to key handlers which do not specify a scope. This is processed the same way as the scope of cfg-listeners. It defaults to the "controller", but using 'this' means that an instance method will be used.

getKeyMap : Object

Returns the value of keyMap

Returns

Object

setKeyMap (keyMap)

Sets the value of keyMap

Parameters

keyMap :  Object

keyMapEnabled : Boolean
bindable bind

Enables or disables processing keys in the keyMap. This value starts as null and if it is null when initKeyMap is called, it will automatically be set to true. Since initKeyMap is called by Ext.Component at the proper time, this is not something application code normally handles.

Defaults to:

null

getKeyMapEnabled : Boolean

Returns the value of keyMapEnabled

Returns

Boolean

setKeyMapEnabled (keyMapEnabled)

Sets the value of keyMapEnabled

Parameters

keyMapEnabled :  Boolean

keyMapTarget : String
protected pro

The name of the member that should be used to listen for keydown/keypress events. This is intended to be controlled at the class level not per instance.

Defaults to:

'el'

labelableRenderTpl : String / String[] / Ext.XTemplate
private pri

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} ',
    '{childElCls} {unselectableCls}" style="{labelStyle}"',
    '<tpl if="inputId && !skipLabelForAttribute"> for="{inputId}"</tpl>',
    ' {labelAttrTpl}>',
    '<span class="{labelInnerCls} {labelInnerCls}-{ui}" style="{labelInnerStyle}">',
    '{beforeLabelTextTpl}',
    '<span id="{id}-labelTextEl" data-ref="labelTextEl" class="{labelTextCls}">',
    '<tpl if="fieldLabel">{fieldLabel}',
    '<tpl if="labelSeparator">{labelSeparator}</tpl>',
    '</tpl>',
    '</span>',
    '{afterLabelTextTpl}',
    '</span>',
    '</label>',
    '{afterLabelTpl}',
    '<div id="{id}-bodyEl" data-ref="bodyEl" role="presentation"',
    ' 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}',
    // ARIA elements serve different purposes:
    // - ariaHelpEl may contain optional hints about the field, such as
    //   expected format. This text is static and usually does not change
    //   once rendered. It is also optional.
    // - ariaStatusEl is used to convey status of the field. Validation errors
    //   are rendered here, as well as other information that might be helpful
    //   to Assistive Technology users exploring the app in browse mode.
    // - ariaErrorEl is used for announcing dynamic changes in the field state,
    //   so that AT users receive updates while in forms mode.
    //
    // Both ariaHelpEl and ariaStatusEl are referenced by the field's input element
    // via aria-describedby.
    '<tpl if="renderAriaElements">',
    '<tpl if="ariaHelp">',
    '<span id="{id}-ariaHelpEl" data-ref="ariaHelpEl"',
    ' class="' + Ext.baseCSSPrefix + 'hidden-offsets">',
    '{ariaHelp}',
    '</span>',
    '</tpl>',
    '<span id="{id}-ariaStatusEl" data-ref="ariaStatusEl" aria-hidden="true"',
    ' class="' + Ext.baseCSSPrefix + 'hidden-offsets">',
    '{ariaStatus}',
    '</span>',
    '<span id="{id}-ariaErrorEl" data-ref="ariaErrorEl" aria-hidden="true" aria-live="assertive"',
    ' class="' + Ext.baseCSSPrefix + 'hidden-clip">',
    '</span>',
    '</tpl>',
    '</div>',
    '<tpl if="renderError">',
    '<div id="{id}-errorWrapEl" data-ref="errorWrapEl" class="{errorWrapCls} {errorWrapCls}-{ui}',
    ' {errorWrapExtraCls}" style="{errorWrapStyle}">',
    '<div role="presentation" id="{id}-errorEl" data-ref="errorEl" ',
    'class="{errorMsgCls} {invalidMsgCls} {invalidMsgCls}-{ui}" ',
    'data-anchorTarget="{tipAnchorTarget}">',
    '</div>',
    '</div>',
    '</tpl>',
    {
        disableFormats: true
    }
]

labelAlign : String

Controls the position and alignment of the fieldLabel. Valid values are:

  • "left" (the default) - The label is positioned to the left of the field, with its text aligned to the left. Its width is determined by the labelWidth config.
  • "top" - The label is positioned above the field.
  • "right" - The label is positioned to the left of the field, with its text aligned to the right. Its width is determined by the labelWidth config.

Defaults to:

'left'

labelAttrTpl : String / Array / Ext.XTemplate

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.

labelCls : String

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'

labelClsExtra : String

An optional string of one or more additional CSS classes to add to the label element. Defaults to empty.

labelPad : Number

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

labelSeparator : String

Character(s) to be inserted at the end of the label text.

Set to empty string to hide the separator completely.

Defaults to:

':'

labelStyle : String

A CSS style specification string to apply directly to this field's label.

labelTpl : String / Ext.XTemplate

The Ext.XTemplate to use for the inner markup of the labeled items. Defaults to the configured displayField

labelWidth : Number

The width of the fieldLabel in pixels. Only applicable if labelAlign is set to "left" or "right".

Defaults to:

100

liquidLayout : Boolean

Components that achieve their internal layout results using solely CSS with no JS intervention must set this to true. This allows the component to opt out of the layout run when used inside certain container layouts such as Ext.layout.container.Form and Ext.layout.container.Auto resulting in a performance gain. The following components currently use liquid layout (liquidLayout: true):

It is important to keep in mind that components using liquidLayout do not fire the following events:

In addition liquidLayout components do not call the following template methods:

Any component that needs to fire these events or to have these methods called during its life cycle needs to set liquidLayout to false. The following example demonstrates how to enable the resize event for a Ext.form.field.TextArea:

Use caution when setting liquidLayout to false as it carries a performance penalty since it means the layout system must perform expensive DOM reads to determine the Component's size.

Defaults to:

false

listConfig : Object

An optional set of configuration properties that will be passed to the Ext.view.BoundList's constructor. Any configuration that is valid for BoundList can be included. Some of the more useful ones are:

listeners : Object
bindable bind

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

setListeners ( listeners )

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

Parameters

listeners :  Object

The listeners

liveDrag : Boolean

True to drag the component itself. Else a lightweight version of the component will be shown (using the component's ghost() method).

Note: This config is only relevant when used with dragging implemented via Ext.util.ComponentDragger.

Defaults to:

false

loader : Ext.ComponentLoader / Object

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

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

getLoader Ext.ComponentLoader

Gets the Ext.ComponentLoader for this Component.

Returns

:Ext.ComponentLoader

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

margin : Number / String
bindable bind

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

setMargin ( margin )

Sets the margin on the target element.

Parameters

margin :  Number/String

The margin to set. See the margin config.

maskDefaults : Object

Default LoadMask configuration for method-setLoading.

maskElement : String

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

maskRe : RegExp

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.

matchFieldWidth : Boolean

Whether the picker dropdown's width should be explicitly set to match the width of the field. Defaults to true.

Defaults to:

true

maxHeight : Number
bindable bind

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

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

Defaults to:

null

getMaxHeight : Number

Returns the value of maxHeight

Returns

Number

setMaxHeight (maxHeight)

Sets the value of maxHeight

Parameters

maxHeight :  Number

maxLength : Number

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

maxLengthText : String

Error text to display if the maximum length validation fails.

Defaults to:

'The maximum length for this field is {0}'

maxWidth : Number
bindable bind

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

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

Defaults to:

null

getMaxWidth : Number

Returns the value of maxWidth

Returns

Number

setMaxWidth (maxWidth)

Sets the value of maxWidth

Parameters

maxWidth :  Number

minChars : Number

The minimum number of characters the user must type before autocomplete and typeAhead activate.

Defaults to 4 if queryMode = 'remote' or 0 if queryMode = 'local', does not apply if editable = false.

minHeight : Number
bindable bind

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

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

Defaults to:

null

getMinHeight : Number

Returns the value of minHeight

Returns

Number

setMinHeight (minHeight)

Sets the value of minHeight

Parameters

minHeight :  Number

minLength : Number

Minimum input field length required

Defaults to:

0

minLengthText : String

Error text to display if the minimum length validation fails.

Defaults to:

'The minimum length for this field is {0}'

minWidth : Number
bindable bind

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

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

Defaults to:

null

getMinWidth : Number

Returns the value of minWidth

Returns

Number

setMinWidth (minWidth)

Sets the value of minWidth

Parameters

minWidth :  Number

modal : Boolean

True to make the floated component modal and mask everything behind it when displayed, false to display it without restricting access to other UI elements.

Defaults to:

false

modelValidation : Boolean

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

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

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

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

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

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

msgTarget : String

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'

multiSelect : Boolean

If set to true, allows the combo field to hold more than one value at a time, and allows selecting multiple items from the dropdown list. The combo's text field will show all selected values using the template defined by labelTpl.

Defaults to:

true

name : String

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.

getName String

Returns the name attribute of the field. This is used as the parameter name when including the field value in a form submit().

Returns

:String

name The field name

nameable : Boolean

Set to true for this component's name property to be tracked by its containing nameHolder.

Defaults to:

false

openCls : String

A class to be added to the field's bodyEl element when the picker is opened.

Defaults to:

'x-pickerfield-open'

overCls : String

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

Defaults to:

''

Available since: 2.3.0

overflowX : String
deprecated dep

Possible values are:

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

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

Deprecated since version 5.1.0
Use scrollable instead

overflowY : String
deprecated dep

Possible values are:

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

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

Deprecated since version 5.1.0
Use scrollable instead

padding : Number / String

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

pageSize : Number

If greater than 0, a Ext.toolbar.Paging is displayed in the footer of the dropdown list and the filter queries will execute with page start and limit parameters. Only applies when queryMode = 'remote'.

Defaults to:

0

pickerAlign : String

The alignment position with which to align the picker. Defaults to "tl-bl?"

Defaults to:

'tl-bl?'

pickerOffset : Number[]

An offset [x,y] to use in addition to the pickerAlign when positioning the picker. Defaults to undefined.

pinList : Boolean
deprecated dep

Has no effect if multiSelect is false

Configure as false to automatically collapse the pick list after a selection is made.

Defaults to:

true

Deprecated since version 5.1.0
For multiple selection use Ext.form.field.Tag or Ext.view.MultiSelector

plugins : Array / Ext.enums.Plugin / Object / Ext.plugin.Abstract

This config describes one or more plugin config objects used to create plugin instances for this component.

Plugins are a way to bundle and reuse custom functionality. Plugins should extend Ext.plugin.Abstract but technically the only requirement for a valid plugin is that it contain an init method that accepts a reference to its owner. Once a plugin is created, the owner will call the init method, passing a reference to itself. Each plugin can then call methods or respond to events on its owner as needed to provide its functionality.

This config's value can take several different forms.

The value can be a single string with the plugin's Ext.enums.Plugin:

plugins: 'cellediting',

It can also be an array of plugin aliases:

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

An array can also contain elements that are config objects with a ptype property holding the type alias:

 plugins: ['gridviewdragdrop', {
     ptype: 'cellediting',
     clicksToEdit: 1
 }],

A final form (new in version 6.5) is the keyed-object form:

 plugins: {
     gridviewdragdrop: true,
     cellediting: {
         clicksToEdit: 1
     }
 },

In this last form, the keys are id's as well as the default type alias.

Available since: 2.3.0

getPlugins
private pri

Returns an array of current fully constructed plugin instances.

preventMark : Boolean

true to disable displaying any error message set on this object.

Defaults to:

false

publishes : String / String[] / Object
bindable bind

One or more names of config properties that this component should publish to its ViewModel. Generally speaking, only properties defined in a class config block (including ancestor config blocks and mixins) are eligible for publishing to the viewModel. Some components override this and publish their most useful configs by default.

Note: We'll discuss publishing properties not found in the config block below.

Values determined to be invalid by component (often form fields and model validations) will not be published to the ViewModel.

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

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

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

Classes must provide this config as an Object:

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

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

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

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

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

In some cases, users may want to publish a property to the viewModel that is not found in a class config block. In these situations, you may utilize publishState if the property has a setter method. Let's use setFieldLabel as an example:

  setFieldLabel: function(fieldLabel) {
      this.callParent(arguments);
      this.publishState('fieldLabel', fieldLabel);
  }

With the above chunk of code, fieldLabel may now be published to the viewModel.

Defaults to:

null

Available since: 5.0.0

getPublishes : String / String[] / Object

Returns the value of publishes

Returns

String / String[] / Object

setPublishes (publishes)

Sets the value of publishes

Parameters

publishes :  String / String[] / Object

queryCaching : Boolean

When true, this prevents the combo from re-querying (either locally or remotely) when the current query is the same as the previous query.

Defaults to:

true

queryDelay : Number

The length of time in milliseconds to delay between the start of typing and sending the query to filter the dropdown list.

Defaults to 500 if queryMode = 'remote' or 10 if queryMode = 'local'

queryMode : String

The mode in which the ComboBox uses the configured Store. Acceptable values are:

  • 'remote' :

    In queryMode: 'remote', the ComboBox loads its Store dynamically based upon user interaction.

    This is typically used for "autocomplete" type inputs, and after the user finishes typing, the Store is loaded.

    A parameter containing the typed string is sent in the load request. The default parameter name for the input string is query, but this can be configured using the queryParam config.

    In queryMode: 'remote', the Store may be configured with remoteFilter: true, and further filters may be programatically added to the Store which are then passed with every load request which allows the server to further refine the returned dataset.

    Typically, in an autocomplete situation, hideTrigger is configured true because it has no meaning for autocomplete.

  • 'local' :

    ComboBox loads local data

    var combo = new Ext.form.field.ComboBox({
        renderTo: document.body,
        queryMode: 'local',
        store: new Ext.data.ArrayStore({
            id: 0,
            fields: [
                'myId',  // numeric value is the key
                'displayText'
            ],
            data: [[1, 'item1'], [2, 'item2']]  // data is local
        }),
        valueField: 'myId',
        displayField: 'displayText',
        triggerAction: 'all'
    });
    

Defaults to:

'remote'

queryParam : String

Name of the parameter used by the Store to pass the typed string when the ComboBox is configured with queryMode: 'remote'. If explicitly set to a falsy value it will not be sent.

Defaults to:

'query'

readOnly : Boolean
bindable bind

true to prevent the user from changing the field, and hide all triggers.

setReadOnly ( readOnly )

Sets the read-only state of this field.

Parameters

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.

readOnlyCls : String

The CSS class applied to the component's main element when it is readOnly.

Defaults to:

Ext.baseCSSPrefix + 'form-readonly'

reference : String

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

regex : RegExp

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.

regexText : String

The error text to display if regex is used and the test fails during validation

Defaults to:

''

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

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

Possible values:

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

Defaults to:

undefined

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

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

Parameters

contentBox :  Boolean (optional)

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

local :  Boolean (optional)

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

Returns

:Ext.util.Region

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

renderConfig : Object

renderConfig wraps configs that do not get applied until after the component is rendered. Unlike normal config system properties, renderConfigs use a special setter method to store values on the instance instead of running the apply and update methods if it is called before the component is rendered. Then, after the component has been rendered, these values are processed by the normal apply and update method for the config.

This means that calling the get method for the config prior to render will return whatever raw value has been set, while calling the getter after render will return the value after processing by the config's apply method. If this distinction needs to be made, it is the caller's responsibility to check for the rendered state and handle such intermediate config values.

renderData : Object

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

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

See renderSelectors and cfg-childEls for usage examples.

renderSelectors : Object
deprecated dep

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

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

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

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

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

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

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

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

Deprecated since version 5.0
Use cfg-childEls instead.

renderTo : String / HTMLElement / Ext.dom.Element

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

Notes:

Do not use this option if the Component is to be a child item of a Ext.container.Container. It is the responsibility of the Ext.container.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

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

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

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

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

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

Defaults to:

'{%this.renderContent(out,values)%}'

repeatTriggerClick : Boolean

true to attach a Ext.util.ClickRepeater to the trigger(s). Click repeating behavior can also be configured on the individual trigger instances using the trigger's repeatClick config.

Defaults to:

false

requiredCls : String

The CSS class to apply to a required field, i.e. a field where allowBlank is false.

Defaults to:

'x-form-required-field'

resizable : Boolean / Object

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

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

resizeHandles : String

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

Defaults to:

'all'

saveDelay : Number

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

Defaults to:

100

scrollable : Boolean / String / Object
bindable bind

Configuration options to make this Component scrollable. Acceptable values are:

  • true to enable auto scrolling.
  • false (or null) to disable scrolling - this is the default.
  • x or horizontal to enable horizontal scrolling only
  • y or vertical to enable vertical scrolling only

Also accepts a configuration object for a Ext.scroll.Scroller if if advanced configuration is needed.

The getter for this config returns the Ext.scroll.Scroller instance. You can use the Scroller API to read or manipulate the scroll position:

// scrolls the component to 5 on the x axis and 10 on the y axis
component.getScrollable().scrollTo(5, 10);

Defaults to:

null

getScrollable : Boolean / String / Object

Returns the value of scrollable

Returns

Boolean / String / Object

setScrollable (scrollable)

Sets the value of scrollable

Parameters

scrollable :  Boolean / String / Object

selection : Ext.data.Model
bindable bind

The selected model. Typically used with binding.

Defaults to:

null

getSelection Ext.data.Model

Returns the combobox's selection.

Returns

:Ext.data.Model

The selected record

setSelection (selection)

Sets the value of selection

Parameters

selection :  Ext.data.Model

selectOnFocus : Boolean

true to automatically select any existing field text when the field receives input focus. Only applies when editable = true

Defaults to:

true

selectOnTab : Boolean

Whether the Tab key should select the currently highlighted item.

Defaults to:

true

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

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

To create a new session you can specify true:

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

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

Alternatively, a config object can be provided:

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

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

Defaults to:

null

getSession : Boolean / Object / Ext.data.Session

Returns the value of session

Returns

Boolean / Object / Ext.data.Session

setSession (session)

Sets the value of session

Parameters

session :  Boolean / Object / Ext.data.Session

shadow : String / Boolean

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

Defaults to:

'sides'

shadowOffset : Number

Number of pixels to offset the shadow.

shareableName : Boolean

Set to true to allow this component's name to be shared by other items in the same nameHolder. Such items will be returned in an array from lookupName.

Defaults to:

false

shim : Boolean

true to enable an iframe shim for this Component to keep windowed objects from showing through.

shrinkWrap : Boolean / Number

The possible values for shrinkWrap are:

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

In CSS terms, shrink-wrap width is analogous to an inline-block element as opposed to a block-level element.

Non-Panel Components

The shrinkWrap config is a class-level config and should be used when defining a subclass. It is not intended to be set as a config on instances of a given component.

For non-Panel components, shrinkWrap is a descriptive config only. It should be set when defining your own custom class including the DOM elements used to construct the component. The shrinkWrap property does not itself apply styling on the component elements. Rather, it should describe the CSS styling you've applied to your custom component (refer to the numeric matrix above).

When a component is owned by a container the layout of that container will inspect the component's shrinkWrap property during layout. The layout then uses the content-wrapping policy described by shrinkWrap to correctly size and position the container's child items.

Defaults to:

2

simulatePlaceholder : Boolean
private pri

Defaults to:

true

size : Number
deprecated dep bindable bind

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.

getSize ( [contentSize] ) : Object

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

Parameters

contentSize :  Boolean (optional)

true to get the width/size minus borders and padding

Returns

:Object

An object containing the element's size:

width :  Number

height :  Number

setSize ( width, height ) : Ext.Component
chainable ch

Sets the width and height of this Component. This method fires the resize event. This method can accept either width and height as separate arguments, or you can pass a size object like {width:10, height:20}.

Parameters

width :  Number/String/Object

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

  • A Number specifying the new width in pixels.
  • A String used to set the CSS width style.
  • A size object in the format {width: widthValue, height: heightValue}.
  • undefined to leave the width unchanged.

height :  Number/String

The new height to set (not required if a size object is passed as the first arg). This may be one of:

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

Returns

:Ext.Component

this

stacked : Boolean

  • true to have each selected value fill to the width of the form field
  • `false to have each selected value size to its displayed contents

Defaults to:

false

stateEvents : String[]

An array of events that, when fired, should trigger this object to save its state. stateEvents defaults to the stateEvents associated with the component you are using. Any events you statically set will be appended to that list. stateEvents may be any type of event supported by this object, including browser or custom events (e.g., ['click', 'customerchange']).

See stateful for an explanation of saving and restoring object state. By default the following stateEvents are added:

stateful : Boolean / Object
bindable bind

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

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

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

To set the state provider for the current page:

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

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

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

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

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

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

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

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

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

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

You can perform extra processing on state save and restore by attaching handlers to the beforestaterestore, staterestore, beforestatesave and statesave events. In some simple cases, passing an object for the stateful config may suffice. If an object is provided, the properties of that object are used to include or exclude stateful properties returned by getState. For example:

 stateful: {
     height: false, // never persist the height
     width: true    // always persist the width
 }

The above is roughly equivalent to the following:

 getState: function () {
     var state = this.callParent();

     delete state.height;
     state.width = this.width;

     return state;
 }

Defaults to:

false

getStateful : Boolean / Object

Returns the value of stateful

Returns

Boolean / Object

setStateful (stateful)

Sets the value of stateful

Parameters

stateful :  Boolean / Object

stateId : String

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

See stateful for an explanation of saving and restoring state.

getStateId String
private pri

Gets the state id for this object.

Returns

:String

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

stripCharsRe : RegExp

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.

style : String / Object
bindable bind

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

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

Available since: 1.1.0

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

Sets the style for this Component's primary element.

Styles should be a valid DOM element style property. Valid style property names (along with the supported CSS version for each)

var name = Ext.create({
    xtype: 'component',
    renderTo: Ext.getBody(),
    html: 'Phineas Flynn'
});

// two-param syntax
name.setStyle('color', 'white');

// single-param syntax
name.setStyle({
    fontWeight: 'bold',
    backgroundColor: 'gray',
    padding: '10px'
});

Parameters

property :  String/Object

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

value :  String (optional)

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

Returns

:Ext.Component

this

submitValue : Boolean

Setting this to false will prevent the field from being submitted even when it is not disabled.

Defaults to:

true

getSubmitValue String

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.

Returns

:String

The value to be submitted, or null.

tabIndex : Number
bindable bind

Sets a DOM tabIndex for this field. tabIndex may be set to -1 in order to remove the field from the tab rotation.

Note: tabIndex only applies to fields that are rendered. It does not effect fields built via applyTo

getTabIndex Number

Return the actual tabIndex for this Focusable.

Returns

:Number

tabIndex attribute value

setTabIndex ( newTabIndex )

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

Parameters

newTabIndex :  Number

new tabIndex to set

tipTpl : String / Ext.XTemplate

The Ext.XTemplate to use for the tip of the labeled items.

Defaults to:

undefined

Available since: 5.1.1

toFrontOnShow : Boolean

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

Defaults to:

true

touchAction : Object
bindable bind

Emulates the behavior of the CSS touch-action property in a cross-browser compatible manner.

Keys in this object are touch action names, and values are false to disable a touch action or true to enable it. Accepted keys are:

  • panX
  • panY
  • pinchZoom
  • doubleTapZoom

All touch actions are enabled (true) by default, so it is usually only necessary to specify which touch actions to disable. For example, the following disables only horizontal scrolling and pinch-to-zoom on the component's main element:

touchAction: {
    panX: false,
    pinchZoom: false
}

Touch actions can be specified on child elements using the child element name, for example:

// disables horizontal scrolling on the main element, and double-tap-zoom
// on the child element named "body"
touchAction: {
    panY: false
    body: {
        doubleTapZoom: false
    }
}

The primary motivation for setting the touch-action of an element is to prevent the browser's default handling of a gesture such as pinch-to-zoom, or drag-to-scroll, so that the application can implement its own handling of that gesture on the element. Suppose, for example, a component has a custom drag handler on its element and wishes to prevent horizontal scrolling of its container while it is being dragged:

Ext.create('Ext.Component', {
    touchAction: {
        panX: false
    },
    listeners: {
        drag: function(e) {
            // implement drag logic
        }
    }
});

Defaults to:

null

getTouchAction : Object

Returns the value of touchAction

Returns

Object

setTouchAction (touchAction)

Sets the value of touchAction

Parameters

touchAction :  Object

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

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

Available since: 3.4.0

getTpl ( name )
private pri

Parameters

name :  Object

tplWriteMode : String

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

Defaults to:

'overwrite'

Available since: 3.4.0

transform : String / HTMLElement / Ext.dom.Element

The id, DOM node or Ext.dom.Element of an existing HTML <select> element to convert into a ComboBox. The target select's options will be used to build the options in the ComboBox dropdown; a configured store will take precedence over this.

transformInPlace : Boolean

true to automatically render this combo box in place of the select element that is being transformed. If false, this combo will be rendered using the normal rendering, either as part of a layout, or using renderTo or method-render.

Defaults to:

true

triggerAction : String

The action to execute when the trigger is clicked.

See also queryParam.

Defaults to:

'all'

triggerCls : String

An additional CSS class used to style the trigger button. The trigger will always get the Ext.form.trigger.Trigger#baseCls by default and triggerCls will be appended if specified.

Defaults to:

'x-form-arrow-trigger'

triggerOnClick : Boolean

true to activate the trigger when clicking in empty space in the field. Note that the subsequent behavior of this is controlled by the field's triggerAction. This behavior is similar to that of a basic ComboBox with editable false.

Defaults to:

true

triggers : Object
bindable bind

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.

Ext.create('Ext.form.field.Text', {
    renderTo: document.body,
    fieldLabel: 'My Custom Field',
    triggers: {
        foo: {
            cls: 'my-foo-trigger',
            handler: function() {
                console.log('foo trigger clicked');
            }
        },
        bar: {
            cls: 'my-bar-trigger',
            handler: function() {
                console.log('bar trigger clicked');
            }
        }
    }
});

The weight value may be a negative value in order to position custom triggers ahead of default triggers like that of ComboBox.

Ext.create('Ext.form.field.ComboBox', {
    renderTo: Ext.getBody(),
    fieldLabel: 'My Custom Field',
    triggers: {
        foo: {
            cls: 'my-foo-trigger',
            weight: -2, // negative to place before default triggers
            handler: function() {
                console.log('foo trigger clicked');
            }
        },
        bar: {
            cls: 'my-bar-trigger',
            weight: -1,
            handler: function() {
                console.log('bar trigger clicked');
            }
        }
    }
});

Defaults to:

undefined

getTriggers : Object

Returns the value of triggers

Returns

Object

setTriggers (triggers)

Sets the value of triggers

Parameters

triggers :  Object

triggerWrapCls : String

The CSS class that is added to the div wrapping the input element and trigger button(s).

Defaults to:

Ext.baseCSSPrefix + 'form-trigger-wrap'

twoWayBindable : String / String[] / Object
bindable bind

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

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

Defaults to:

null

getTwoWayBindable : String / String[] / Object

Returns the value of twoWayBindable

Returns

String / String[] / Object

setTwoWayBindable (twoWayBindable)

Sets the value of twoWayBindable

Parameters

twoWayBindable :  String / String[] / Object

typeAhead : Boolean

true to populate and autoselect the remainder of the text being typed after a configurable delay (typeAheadDelay) if it matches a known value.

Defaults to:

false

typeAheadDelay : Number

The length of time in milliseconds to wait until the typeahead text is displayed if typeAhead = true

Defaults to:

250

ui : String
bindable bind

A UI style for a component.

Defaults to:

'default'

setUI ( ui )

Sets the UI for the component. This will remove any existing UIs on the component. It will also loop through any uiCls set on the component and rename them so they include the new UI.

Parameters

ui :  String

The new UI for the component.

uiCls : String[]
private pri

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

Defaults to:

[]

userCls : String / String[]
bindable bind

One or more CSS classes to add to the component's primary element. This config is intended solely for use by the component instantiator (the "user"), not by derived classes.

For example:

 items: [{
     xtype: 'button',
     userCls: 'my-button'
 ...
 }]

Defaults to:

null

getUserCls : String / String[]

Returns the value of userCls

Returns

String / String[]

setUserCls (userCls)

Sets the value of userCls

Parameters

userCls :  String / String[]

validateBlank : Boolean

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

validateOnBlur : Boolean

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

validateOnChange : Boolean

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

validation : Boolean / String
bindable bind

This property, when a String, contributes its value to the error state of this instance as reported by getErrors.

Defaults to:

null

getValidation : Boolean / String

Returns the value of validation

Returns

Boolean / String

setValidation (validation)

Sets the value of validation

Parameters

validation :  Boolean / String

validationField : Ext.data.field.Field
bindable bind private pri

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

getValidationField : Ext.data.field.Field

Returns the value of validationField

Returns

Ext.data.field.Field

setValidationField ( value, record )
private pri

Parameters

value :  Object

record :  Object

validator : Function

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.

Ext.create('Ext.form.field.Text', {
    renderTo: document.body,
    name: 'phone',
    fieldLabel: 'Phone Number',
    validator: function (val) {
        // remove non-numeric characters
        var tn = val.replace(/[^0-9]/g,''),
            errMsg = "Must be a 10 digit telephone number";
        // if the numeric value is not 10 digits return an error message
        return (tn.length === 10) ? true : errMsg;
    }
});

Parameters

value :  Object

The current field value

Returns

:Boolean/String

response

  • True if the value is valid
  • An error message if the value is invalid

value : Object
bindable bind

A value to initialize this field with.

getValue Object

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.

Returns

:Object

value The field value

setValue ( value ) : Ext.form.field.Field/Boolean

Sets the specified value(s) into the field. The following value formats are recognized:

  • Single Values

  • Multiple Values

    • If multiSelect is true, a string containing multiple strings as specified in the Single Values section above, concatenated in to one string with each entry separated by this field's configured delimiter
    • An array of strings as specified in the Single Values section above
    • An array of records as specified in the Single Values section above

In any of the string formats above, the following occurs if an associated record cannot be found:

  1. If forceSelection is false, a new record of the store's configured model type will be created using the given value as the displayField and valueField. This record will be added to the current value, but it will not be added to the store.
  2. If forceSelection is true and queryMode is remote, the list of unknown values will be submitted as a call to the store's load as a parameter named by the valueParam with values separated by the configured delimiter. This process will cause setValue to asynchronously process. This will only be attempted once. Any unknown values that the server does not return records for will be removed.
  3. Otherwise, unknown values will be removed.

Parameters

value :  Mixed

The value(s) to be set, see method documentation for details

Returns

:Ext.form.field.Field/Boolean

this, or false if asynchronously querying for unknown values

valueNotFoundText : String
bindable bind

When using a name/value combo, if the value passed to setValue is not found in the store, valueNotFoundText will be displayed as the field text if defined. If this default text is used, it means there is no value set and no validation will occur on this field.

Defaults to:

null

getValueNotFoundText : String

Returns the value of valueNotFoundText

Returns

String

setValueNotFoundText (valueNotFoundText)

Sets the value of valueNotFoundText

Parameters

valueNotFoundText :  String

valueParam : String

The name of the parameter used to load unknown records into the store. If left unspecified, valueField will be used.

valuePublishEvent : String[] / String

The event name(s) to use to publish the value Ext.form.field.Base#bind for this field.

Defaults to:

'change'

Available since: 5.0.1

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

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

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

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

Defaults to:

null

getViewModel : String / Object / Ext.app.ViewModel

Returns the value of viewModel

Returns

String / Object / Ext.app.ViewModel

setViewModel (viewModel)

Sets the value of viewModel

Parameters

viewModel :  String / Object / Ext.app.ViewModel

vtype : String

A validation type name as defined in Ext.form.field.VTypes

vtypeText : String

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.

weight : Number

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

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

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

If docked items, the weight will order how the items are laid out. Here is an example to put a Ext.toolbar.Toolbar above a Ext.panel.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

width : Number / String
bindable bind

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

getWidth Number

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

Returns

:Number

setWidth ( width ) : Ext.Component

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

Parameters

width :  Number

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

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

Returns

:Ext.Component

this

xtype : Ext.enums.Widget

Note: Only applies to Ext.Component derived classes when used as a config in Ext.define.

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

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

But by using xtype, the above becomes:

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

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

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

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

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

 // or alternatively:

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

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

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

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

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

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

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

Available since: 2.3.0

properties

Instance Properties

$className
private pri

Defaults to:

'Ext.Base'

$configPrefixed : Boolean
private pri

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

Defaults to:

true

Available since: 5.0.0

$configStrict : Boolean
private pri

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

Defaults to:

true

Available since: 5.0.0

$eventOptions
private pri

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

Defaults to:

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

$vetoClearingPrototypeOnDestroy
private pri

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

Defaults to:

true

_isLayoutRoot : Boolean
protected pro

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

Defaults to:

false

_renderState : Number
readonly ro private pri

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

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

Defaults to:

0

Available since: 5.0.0

allowDomMove
private pri

Defaults to:

true

ariaEl : String
readonly ro private pri

The name of the Component property that holds a reference to the Element that serves as that Component's ARIA element. This property will be replaced with the actual Element reference after rendering.

Most of the simple Components will have their main element as ariaEl.

Defaults to:

'el'

Available since: 6.0.0

ariaRenderAttributes : Object
private pri

Instance specific ARIA attributes to render into Component's ariaEl. This object is only used during rendering, and is discarded afterwards.

ariaRole : String
readonly ro

ARIA role for this Component, defaults to no role. With no role, no other ARIA attributes are set.

autoDestroyBoundStore : Boolean

This property allows the object to destroy bound stores that have Ext.data.AbstractStore#autoDestroy option set to true.

Defaults to:

false

autoGenId : Boolean
private pri

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

Defaults to:

false

bodyEl : Ext.dom.Element

The div Element wrapping the component's contents. Only available after the component has been rendered.

borderBoxCls
private pri

Defaults to:

Ext.baseCSSPrefix + 'border-box'

childEls
private pri

Defaults to:

[
    'listWrapper',
    'itemList',
    'inputEl',
    'inputElCt',
    'selectedText',
    'ariaList'
]

clearPropertiesOnDestroy : Boolean / "async"
protected pro

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

Defaults to:

true

Available since: 6.2.0

clearPrototypeOnDestroy : Boolean
private pri

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

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

Defaults to:

false

Available since: 6.2.0

clearValueOnEmpty
private pri

Defaults to:

false

componentLayoutCounter : Number
private pri

The number of component layout calls made on this object.

Defaults to:

0

containsFocus : Boolean
readonly ro

true if this currently focused element is within this Component's or Container's hierarchy. This property is set separately from hasFocus, and can be true when hasFocus is false.

Examples:

  • Text field with input element focused would be: focusable: true, hasFocus: true, containsFocus: true

  • Date field with drop-down picker currently focused would be: focusable: true, hasFocus: false, containsFocus: true

  • Form Panel with a child input field currently focused would be: focusable: false, hasFocus: false, containsFocus: true

See also hasFocus.

Defaults to:

false

contentPaddingProperty : String

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

Defaults to:

'padding'

defaultBindProperty : String
protected pro

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

 bind: '{name}'

Is equivalent to this object form:

 bind: {
     value: '{name}'
 }

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

Defaults to:

null

deferLayouts
private pri

Defaults to:

false

destroyed : Boolean
protected pro

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

Defaults to:

false

dirty : Boolean
private pri

The dirty state of the field.

Defaults to:

false

errorEl : Ext.dom.Element

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.

eventsSuspended
private pri

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

Defaults to:

0

filtered : Boolean
readonly ro private pri

True if there are extra filters appllied to this component.

Defaults to:

false

Available since: 5.0.0

floating : Boolean
readonly ro private pri

The value true indicates that this Component is floating.

floatParent : Ext.container.Container
readonly ro

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

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

These differences are abstracted away by the up method.

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

See cfg-floating and zIndexManager

focusable : Boolean
readonly ro

true for keyboard interactive Components or Widgets, false otherwise. For Containers, this property reflects interactiveness of the Container itself, not its children. See isFocusable.

Note: It is not enough to set this property to true to make a component keyboard interactive. You also need to make sure that the component's focusEl is reachable via Tab key (tabbable). See also tabIndex.

Defaults to:

false

focusClsEl : Ext.dom.Element

The element that will have the focusCls applied when component's focusEl is focused.

focusEl : Ext.dom.Element

The element that will be focused when focus method is called on this component. Usually this is the same element that receives focus via mouse clicks, taps, and pressing Tab key.

Defaults to:

'el'

frameSize : Object
readonly ro

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

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

Defaults to:

null

Properties

top : Number

The width of the top framing element in pixels.

Defaults to: 0

right : Number

The width of the right framing element in pixels.

Defaults to: 0

bottom : Number

The width of the bottom framing element in pixels.

Defaults to: 0

left : Number

The width of the left framing element in pixels.

Defaults to: 0

width : Number

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

Defaults to: 0

height : Number

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

Defaults to: 0

hasFocus
private pri

Defaults to:

false

hasListeners : Object
readonly ro

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

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

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

horizontalPosProp
private pri

Defaults to:

'left'

initFocusable
protected pro

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

Defaults to:

Ext.emptyFn

initialConfig : Object
readonly ro

The config object passed to the constructor during Component creation.

Defaults to:

config

inputCell : Ext.dom.Element
deprecated dep

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

inputEl : Ext.dom.Element

The input Element for this Field. Only available after the field has been rendered.

inputWrap : Ext.dom.Element

A reference to the element that wraps the input element. Only set after the field has been rendered.

isComponent : Boolean

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

Defaults to:

true

isConfiguring : Boolean
readonly ro protected pro

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

Defaults to:

false

Available since: 5.0.0

isExpanded : Boolean

True if the picker is currently expanded, false if not.

Defaults to:

false

isFieldLabelable : Boolean

Flag denoting that this object is labelable as a field. Always true.

Defaults to:

true

isFirstInstance : Boolean
readonly ro protected pro

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

Defaults to:

false

Available since: 5.0.0

isFormField : Boolean

Flag denoting that this component is a Field. Always true.

Defaults to:

true

isInstance : Boolean
readonly ro protected pro

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

Defaults to:

true

isObservable : Boolean

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

Defaults to:

true

isPickerField : Boolean

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

Defaults to:

true

labelEl : Ext.dom.Element

The label Element for this component. Only available after the component has been rendered.

lastQuery : String

The value of the match string used to filter the store. Delete this property to force a requery. Example use:

var combo = new Ext.form.field.ComboBox({
    ...
    queryMode: 'remote',
    listeners: {
        // delete the previous query in the beforequery event or set
        // combo.lastQuery = null (this will reload the store the next time it expands)
        beforequery: function(qe){
            delete qe.combo.lastQuery;
        }
    }
});

To make sure the filter in the store is not cleared the first time the ComboBox trigger is used configure the combo with lastQuery=''. Example use:

var combo = new Ext.form.field.ComboBox({
    ...
    queryMode: 'local',
    triggerAction: 'all',
    lastQuery: ''
});

layoutSuspendCount
private pri

Defaults to:

0

maskOnDisable : Boolean

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

Defaults to:

true

msgTargets
private pri

Map for msg target lookup, if target is not in this map it is assumed to be an element id

Defaults to:

{
    qtip: 1,
    title: 1,
    under: 1,
    side: 1,
    none: 1
}

noWrap
private pri

Tells the layout system that the height can be measured immediately because the width does not need setting.

Defaults to:

true

onFocusMove
protected pro

Called when focus moves within this Component's hierarchy

Defaults to:

Ext.emptyFn

Parameters

e :  Ext.event.Event

event :  Ext.event.Event

The underlying DOM event.

target :  HTMLElement

The element gaining focus.

relatedTarget :  HTMLElement

The element losing focus.

toComponent :  Ext.Component

The Component gaining focus.

fromComponent :  Ext.Component

The Component losing focus.

originalValue : Object

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

ownerCt : Ext.container.Container
readonly ro

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

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

These differences are abstracted away by the up method.

Note: to access items within the Container see itemId.

Available since: 2.3.0

placeholderCoverCls
private pri

The default CSS class for the placeholder label cover need when the browser does not support a Placeholder.

Defaults to:

Ext.baseCSSPrefix + 'placeholder-label'

rendered : Boolean
readonly ro

Indicates whether or not the component has been rendered.

Defaults to:

false

Available since: 1.1.0

rootCls
private pri

Defaults to:

Ext.baseCSSPrefix + 'body'

scrollerCls
private pri

Defaults to:

Ext.baseCSSPrefix + 'scroll-scroller'

scrollFlags : Object
readonly ro private pri

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

Note that if you set overflow styles using the style config or bodyStyle config, this object does not include that information. Use scrollable if you need to access these flags.

This object has the following properties:

Defaults to:

{
    auto: {
        // x:auto, y:auto
        auto: {
            overflowX: 'auto',
            overflowY: 'auto',
            x: true,
            y: true,
            both: true
        },
        // x:auto, y:false
        'false': {
            overflowX: 'auto',
            overflowY: 'hidden',
            x: true,
            y: false,
            both: false
        },
        // x:auto, y:scroll
        scroll: {
            overflowX: 'auto',
            overflowY: 'scroll',
            x: true,
            y: true,
            both: true
        }
    },
    'false': {
        // x:false, y:auto
        auto: {
            overflowX: 'hidden',
            overflowY: 'auto',
            x: false,
            y: true,
            both: false
        },
        // x:false, y:false
        'false': {
            overflowX: 'hidden',
            overflowY: 'hidden',
            x: false,
            y: false,
            both: false
        },
        // x:false, y:scroll
        scroll: {
            overflowX: 'hidden',
            overflowY: 'scroll',
            x: false,
            y: true,
            both: false
        }
    },
    scroll: {
        // x:scroll, y:auto
        auto: {
            overflowX: 'scroll',
            overflowY: 'auto',
            x: true,
            y: true,
            both: true
        },
        // x:scroll, y:false
        'false': {
            overflowX: 'scroll',
            overflowY: 'hidden',
            x: true,
            y: false,
            both: false
        },
        // x:scroll, y:scroll
        scroll: {
            overflowX: 'scroll',
            overflowY: 'scroll',
            x: true,
            y: true,
            both: true
        }
    },
    none: {
        overflowX: '',
        overflowY: '',
        x: false,
        y: false,
        both: false
    }
}

Properties

x : Boolean

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

y : Boolean

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

both : Boolean

true if this Component is scrollable both horizontally and vertically.

overflowX : String

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

overflowY : String

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

self : Ext.Class
protected pro

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

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

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

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


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

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

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

Defaults to:

Base

synthetic : Boolean
private pri

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

Defaults to:

false

topLabelCls
private pri

Defaults to:

Ext.baseCSSPrefix + 'form-item-label-top'

triggerEl : Ext.dom.CompositeElement
deprecated dep

Deprecated since version 5.0
A composite of all the trigger button elements. Only set after the field has been rendered.

triggerWrap : Ext.dom.Element

A reference to the element which encapsulates the input field and all trigger button(s). Only set after the field has been rendered.

validRefRe : RegExp
private pri

Regular expression used for validating reference values.

Defaults to:

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

zIndexManager : Ext.ZIndexManager
readonly ro

Only present for floating Components after they have been rendered.

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

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

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

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

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

See Ext.Component#cfg-floating and zIndexParent

zIndexParent : Ext.container.Container
readonly ro

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

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

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

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

See Ext.Component#cfg-floating and zIndexManager

Static Properties

$onExtended
static sta private pri

Defaults to:

[]

methods

Instance Methods

_addDeclaredListeners ( listeners ) : Boolean
private pri

Adds declarative listeners as nested arrays of listener objects.

Parameters

listeners :  Array

Returns

:Boolean

true if any listeners were added

_fixReference
private pri

Sets up a reference on our current reference holder.

addBindableUpdater ( property )
private pri

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

Available since: 5.0.0

Parameters

property :  String

The name of the config property.

addChildEl ( childEl )
private pri

Add a childEl specific to this instance. This must be called before render.

Available since: 6.0.0

Parameters

childEl :  Object

addClass ( cls ) : Ext.Component
deprecated dep

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

Available since: 2.3.0

Parameters

cls :  String/String[]

The CSS class name to add.

Returns

:Ext.Component

Returns the Component to allow method chaining.

Deprecated since version 4.1
Use addCls instead.

addCls ( cls ) : Ext.Component
chainable ch

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

Parameters

cls :  String/String[]

The CSS class name to add.

Returns

:Ext.Component

Returns the Component to allow method chaining.

addClsWithUI ( classes, [skip] )

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

Parameters

classes :  String/String[]

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

skip :  Boolean (optional)

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

addDelegatedListener ( eventName, fn, scope, options, order, caller, manager )
private pri

Adds a listeners with the "delegate" event option. Users should not invoke this method directly. Use the "delegate" event option of addListener instead.

Parameters

eventName :  Object

fn :  Object

scope :  Object

options :  Object

order :  Object

caller :  Object

manager :  Object

addDeprecations ( deprecations )
private pri

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

Parameters

deprecations :  Object

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

The on method is shorthand for addListener.

Appends an event handler to this object. For example:

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

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

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

One can also specify options for each event handler separately:

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

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

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

Parameters

eventName :  String/Object

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

fn :  Function/String (optional)

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

scope :  Object (optional)

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

options :  Object (optional)

An object containing handler configuration.

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

This object may contain any of the following properties:

scope :  Object

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

delay :  Number

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

single :  Boolean

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

buffer :  Number

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

onFrame :  Number

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

target :  Ext.util.Observable

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

element :  String

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

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

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

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

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

 panel.body.un(...)

delegate :  String (optional)

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

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

See the delegate example below.

capture :  Boolean (optional)

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

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

stopPropagation :  Boolean (optional)

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

preventDefault :  Boolean (optional)

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

stopEvent :  Boolean (optional)

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

args :  Array (optional)

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

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

destroyable :  Boolean (optional)

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

Defaults to:

false

priority :  Number (optional)

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

order :  String (optional)

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

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

Defaults to:

'current'

order :  String (optional)

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

Combining Options

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

A delayed, one-time listener.

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

Attaching multiple handlers in 1 call

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

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

Delegate

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

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

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

Defaults to: 'current'

Returns

:Object

Only when the destroyable option is specified.

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

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

And when those listeners need to be removed:

Ext.destroy(this.btnListeners);

or

this.btnListeners.destroy();

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

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

Example:

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

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

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

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

Parameters

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

The item to which to add a listener/listeners.

ename :  Object/String

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

fn :  Function/String (optional)

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

scope :  Object (optional)

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

options :  Object (optional)

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

Returns

:Object

Only when the destroyable option is specified.

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

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

And when those listeners need to be removed:

Ext.destroy(this.btnListeners);

or

this.btnListeners.destroy();

addPlugin ( plugin )
protected pro

Adds a plugin. May be called at any time in the component's life cycle.

Parameters

plugin :  Object

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

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

Parameters

state :  Object

The state object.

propName :  String

The name of the property on this object to save.

value :  String (optional)

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

Returns

:Object

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

addStateEvents ( events )

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

Parameters

events :  String/String[]

The event name or an array of event names.

addUIClsToElement ( uiCls )
protected pro

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.

Parameters

uiCls :  String

The UI class to add to the element.

addUIToElement
private pri

Method which adds a specified UI to the components element.

addValue ( value )

Adds a value or values to the current value of the field

Parameters

value :  Mixed

The value or values to add to the current value, see setValue

adjustForConstraints ( xy, parent )
private pri

Parameters

xy :  Object

parent :  Object

adjustPosition ( x, y )
private pri

Parameters

x :  Object

y :  Object

afterClassMixedIn ( targetClass )
private pri

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

Parameters

targetClass :  Ext.Class

afterComponentLayout

Track height change to fire event-autosize event, when applicable.

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

Invoked after the Component has been hidden.

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

Parameters

callback :  Function (optional)

scope :  Object (optional)

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

afterQuery ( queryPlan )
template tpl

A method called when the filtering caused by the doQuery call is complete and the store has been either filtered locally (if queryMode is "local"), or has been loaded using the specified filtering.

Parameters

queryPlan :  Object

An object containing details about the query was executed.

query :  String

The query value to be used to match against the ComboBox's valueField.

forceAll :  Boolean

If true, causes the query to be executed even if the minChars threshold is not met.

cancel :  Boolean

A boolean value which, if set to true upon return, causes the query not to be executed.

rawQuery :  Boolean

If true indicates that the raw input field value is being used, and upon store load, the input field value should not be overwritten.

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

afterRender
template tpl protected pro

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

Note: If the Component has a ViewController and the controller has an afterRender method it will be called passing the Component as the single param.

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

afterSetPosition ( x, y )
template tpl protected pro

Template method called after a Component has been positioned.

Parameters

x :  Number

y :  Number

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

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

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

Gets passed the same parameters as #show.

Parameters

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

callback :  Function (optional)

scope :  Object (optional)

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

alignPicker
protected pro

Aligns the picker to the input element

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

Aligns the element with another element relative to the specified anchor points. If the other element is the document it aligns it to the viewport. The position parameter is optional, and can be specified in any one of the following formats:

  • Blank: Defaults to aligning the element's top-left corner to the target's bottom-left corner ("tl-bl").
  • Two anchors: If two values from the table below are passed separated by a dash, the first value is used as the element's anchor point, and the second value is used as the target's anchor point.
  • Two edge/offset descriptors: An edge/offset descriptor is an edge initial (t/r/b/l) followed by a percentage along that side. This describes a point to align with a similar point in the target. So 't0-b0' would be the same as 'tl-bl', 'l0-r50' would place the top left corner of this item halfway down the right edge of the target item. This allows more flexibility and also describes which two edges are considered adjacent when positioning a tip pointer.

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

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

Example Usage:

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

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

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

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

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

Parameters

element :  Ext.util.Positionable/HTMLElement/String

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

position :  String (optional)

The position to align to

Defaults to: "tl-bl?"

offsets :  Number[] (optional)

Offset the positioning by [x, y] Element animation config object

Returns

:Ext.util.Positionable

this

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

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

Parameters

anchorToEl :  Ext.util.Positionable/HTMLElement/String

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

alignment :  String (optional)

The position to align to

Defaults to: "tl-bl?"

offsets :  Number[] (optional)

Offset the positioning by [x, y]

animate :  Boolean/Object (optional)

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

monitorScroll :  Boolean/Number (optional)

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

Defaults to: 50

callback :  Function (optional)

The function to call after the animation finishes

Returns

:Ext.util.Positionable

this

anim ( config )
private pri

Process the passed fx configuration.

Parameters

config :  Object

animate ( config ) : Object
chainable ch

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.

Animating a Ext.Component

When animating a Component, the following properties may be specified in from, to, and keyframe objects:

  • x - The Component's page X position in pixels.

  • y - The Component's page Y position in pixels

  • left - The Component's left value in pixels.

  • top - The Component's top value in pixels.

  • width - The Component's width value in pixels.

  • height - The Component's height value in pixels.

The following property may be set on the animation config root:

  • dynamic - Specify as true to update the Component's layout (if it is a Container) at every frame of the animation. Use sparingly as laying out on every intermediate size change is an expensive operation.

For example, to animate a Window to a new size, ensuring that its internal layout and any shadow is correct:

myWindow = Ext.create('Ext.window.Window', {
    title: 'Test Component animation',
    width: 500,
    height: 300,
    layout: {
        type: 'hbox',
        align: 'stretch'
    },
    items: [{
        title: 'Left: 33%',
        margin: '5 0 5 5',
        flex: 1
    }, {
        title: 'Left: 66%',
        margin: '5 5 5 5',
        flex: 2
    }]
});
myWindow.show();
myWindow.header.el.on('click', function() {
    myWindow.animate({
        to: {
            width: (myWindow.getWidth() == 500) ? 700 : 500,
            height: (myWindow.getHeight() == 300) ? 400 : 300
        }
    });
});

For performance reasons, by default, the internal layout is only updated when the Window reaches its final "to" size. If dynamic updating of the Window's child Components is required, then configure the animation with dynamic: true and the two child items will maintain their proportions during the animation.

Parameters

config :  Object

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

Returns

:Object

this

applyBind ( binds, currentBindings ) : Object
private pri

Available since: 5.0.0

Parameters

binds :  String/Object

currentBindings :  Object

Returns

:Object

applyMultiselectItemMarkup
private pri

Update the labeled items rendering

applyRenderSelectors
private pri

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

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

Transforms a Session config to a proper instance.

Available since: 5.0.0

Parameters

session :  Object

Returns

:Ext.data.Session

applyState ( state )

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.

Parameters

state :  Object

The state

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

Transforms a ViewModel config to a proper instance.

Available since: 5.0.0

Parameters

viewModel :  String/Object/Ext.app.ViewModel

Returns

:Ext.app.ViewModel

assertValue

Overridden to handle partial-input selections more directly

attachChildEls ( el, owner )
private pri

Sets references to elements inside the component.

Parameters

el :  Object

owner :  Object

autoSize
chainable ch

Initiate auto-sizing for height based on grow, if applicable.

Returns

:

batchChanges ( fn )

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.

Parameters

fn :  Function

The function to call with change checks suspended.

beforeDestroy
deprecated dep template tpl protected pro

Invoked before the Component is destroyed. This method is deprecated, override onDestroy instead.

Deprecated since version 6.2.0
Please override onDestroy instead

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

beforeLayout
template tpl protected pro

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

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

beforeQuery ( queryPlan )
template tpl

A method which may modify aspects of how the store is to be filtered (if queryMode is "local") of loaded (if queryMode is "remote").

This is called by the doQuery method, and may be overridden in subclasses to modify the default behaviour.

This method is passed an object containing information about the upcoming query operation which it may modify before returning.

Parameters

queryPlan :  Object

An object containing details about the query to be executed.

query :  String

The query value to be used to match against the ComboBox's valueField.

lastQuery :  String

The query value used the last time a store query was made.

forceAll :  Boolean

If true, causes the query to be executed even if the minChars threshold is not met.

cancel :  Boolean

A boolean value which, if set to true upon return, causes the query not to be executed.

rawQuery :  Boolean

If true indicates that the raw input field value is being used, and upon store load, the input field value should not be overwritten.

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

beforeRender
template tpl protected pro

Allows additional behavior before rendering.

Note: If the Component has a ViewController and the controller has a beforeRender method it will be called passing the Component as the single param.

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

beforeReset
protected pro

Template method before a field is reset.

beforeSetPosition ( x, y, animate )
private pri

Template method called before a Component is positioned.

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

Parameters

x :  Object

y :  Object

animate :  Object

beforeShow
template tpl protected pro

Invoked before the Component is shown.

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

bindStore ( [store], [preventFilter] )

Binds a store to this instance.

Parameters

store :  Ext.data.AbstractStore/String (optional)

The store to bind or ID of the store. When no store given (or when null or undefined passed), unbinds the existing store.

preventFilter :  Boolean (optional)

true to prevent any active filter from being activated on the newly bound store. This is only valid when used with queryMode 'local'.

bindStoreListeners ( store )
protected pro

Binds listeners for this component to the store. By default it will add anything bound by the getStoreListeners method, however it can be overridden in a subclass to provide any more complicated handling.

Parameters

store :  Ext.data.AbstractStore

The store to bind to

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

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

Parameters

fn :  Function

The function to call

scope :  Object (optional)

The scope of the function. Defaults to current node.

args :  Array (optional)

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

Returns

:Ext.Component

this

cacheRefEls ( el )
private pri

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

Parameters

el :  Object

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

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

Parameters

anchor :  String (optional)

The specified anchor position. See alignTo for details on supported anchor positions.

Defaults to: 'tl'

extraX :  Number (optional)

value to be added to the x coordinate

extraY :  Number (optional)

value to be added to the y coordinate

size :  Object (optional)

An object containing the size to use for calculating anchor position {width: (target width), height: (target height)} (defaults to the element's current size)

Returns

:Number[]

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

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

Calculates the new [x,y] position to move this Positionable into a constrain region.

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

Priority is given to constraining the top and left within the constraint.

An alternative constraint may be passed.

Parameters

constrainTo :  String/HTMLElement/Ext.dom.Element/Ext.util.Region (optional)

The Element or Ext.util.Region into which this Component is to be constrained. Defaults to the element into which this Positionable was rendered, or this Component's {@link Ext.Component#constrainTo.

proposedPosition :  Number[] (optional)

A proposed [X, Y] position to test for validity and to coerce into constraints instead of using this Positionable's current position.

local :  Boolean (optional)

The proposedPosition is local (relative to floatParent if a floating Component)

proposedSize :  Number[] (optional)

A proposed [width, height] size to use when calculating constraints instead of using this Positionable's current size.

Returns

:Number[]

If the element needs to be translated, the new [X, Y] position within constraints if possible, giving priority to keeping the top and left edge in the constrain region. Otherwise, false.

callOverridden ( args ) : Object
deprecated dep protected pro

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

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

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

        this.callOverridden();

        alert("Meeeeoooowwww");
    }
});

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

Parameters

args :  Array/Arguments

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

Returns

:Object

Returns the result of calling the overridden method

Deprecated since version 4.1.0
Use method-callParent instead.

callParent ( args ) : Object
protected pro

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

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

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

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

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

 var obj = new My.Derived();

 alert(obj.x);  // alerts 21

This can be used with an override as follows:

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

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

 var obj = new My.Derived();

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

This also works with static and private methods.

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

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

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

Lastly, it also works with overridden static methods.

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

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

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

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

Parameters

args :  Array/Arguments

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

Returns

:Object

Returns the result of calling the parent method

callSuper ( args ) : Object
protected pro

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

Consider:

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

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

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

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

         this.callParent();
     }
 });

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

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

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

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

         this.callSuper();
     }
 });

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

Parameters

args :  Array/Arguments

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

Returns

:Object

Returns the result of calling the superclass method

center Ext.Component
chainable ch

Center this Component in its container.

Returns

:Ext.Component

this

changeConstraint ( newValue, oldValue, constrainMethod, styleName, sizeName )
private pri

Parameters

newValue :  Object

oldValue :  Object

constrainMethod :  Object

styleName :  Object

sizeName :  Object

checkChange

Checks whether the value of the field has changed since the last time it was checked. If the value has changed, it:

  1. Fires the change event,
  2. Performs validation if the validateOnChange config is enabled, firing the validitychange event if the validity has changed, and
  3. Checks the dirty state of the field and fires the dirtychange event if it has changed.

checkDirty

Checks the isDirty state of the field and if it has changed since the last time it was checked, fires the dirtychange event.

cleanupField

Cleans up values initialized by this Field mixin on the current instance. Components using this mixin should call this method before being destroyed.

clearClip
private pri

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

clearDelegatedListeners
private pri

Clears all listeners that were attached using the "delegate" event option. Users should not invoke this method directly. It is called automatically as part of normal clearListeners processing.

clearInvalid

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.

clearListeners

Removes all listeners for this object including the managed listeners

clearManagedListeners

Removes all managed listeners for this object.

clearValue

Clears any value currently set in the ComboBox.

clipTo ( clippingEl, sides )
private pri

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

Parameters

clippingEl :  Ext.Component/Ext.dom.Element/Ext.util.Region

The Component or element or Region which should clip this element even if this element is outside the bounds of that region.

sides :  Number

The sides to clip 1=top, 2=right, 4=bottom, 8=left.

This is to support components being clipped to their logical owner, such as a grid row editor when the row being edited scrolls out of sight. The editor should be clipped at the edge of the scrolling element.

clipToScroller ( scroller )
private pri

Clips this floating element to the scrolling element in line with how its topmost anchoring element is clipped.

Parameters

scroller :  Object

cloneConfig ( overrides ) : Ext.Component

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

Parameters

overrides :  Object

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

Returns

:Ext.Component

clone The cloned copy of this component

collapse

Collapses this field's picker dropdown.

collapseIf ( e )
private pri

Runs on touchstart of doc to check to see if we should collapse the picker.

Parameters

e :  Object

completeEdit
protected pro

Called when focus leaves this input field. Used to postprocess raw values and perform conversion and validation.

constrainBox ( box )
private pri

Parameters

box :  Object

constructPlugin ( plugin )
private pri

Parameters

plugin :  String/Object

string or config object containing a ptype property.

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

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

constructPlugins
private pri

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

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

constructor ( config )

Creates new Component.

Parameters

config :  Ext.dom.Element/String/Object

The configuration options may be specified as either:

  • an element : it is set as the internal element and its id used as the component id
  • a string : it is assumed to be the id of an existing element and is used as the component id
  • anything else : it is assumed to be a standard config object and is applied to the component

convertPositionSpec ( posSpec )
private pri

This function converts a legacy alignment string such as 't-b' into a pair of edge, offset objects which describe the alignment points of the two regions.

So tl-br becomes {myEdge:'t', offset:0}, {otherEdge:'b', offset:100}

This not only allows more flexibility in the alignment possibilities, but it also resolves any ambiguity as to chich two edges are desired to be adjacent if an anchor pointer is required.

Parameters

posSpec :  Object

createPicker

Creates and returns the component to be used as this field's picker. Must be implemented by subclasses of Picker.

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

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

Parameters

newName :  String

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

beginEnd :  Array (optional)

The caller can specify on which indices to slice.

Returns

:Function

destroy

Destroys the Component. This method must not be overridden because Component destruction sequence is conditional; if a beforedestroy handler returns false we must abort destruction.

To add extra functionality to destruction time in a subclass, override the doDestroy method.

Available since: 1.1.0

destroyMembers ( args )

Destroys member properties by name.

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

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

Parameters

args :  String...

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

didValueChange ( newVal, oldVal )
private pri

Checks if the value has changed. Allows subclasses to override for any more complex logic.

Parameters

newVal :  Object

oldVal :  Object

disable ( [silent] ) :
chainable ch

Disable the component.

Available since: 1.1.0

Parameters

silent :  Boolean (optional)

Passing true will suppress the disable event from being fired.

Defaults to: false

Returns

:

doAlign
private pri

Performs the alignment on the picker using the class defaults

doApplyRenderTpl ( out, values )
private pri

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

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

Parameters

out :  Object

values :  Object

doAutoRender
private pri

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

doAutoSelect
private pri

If the autoSelect config is true, and the picker is open, highlights the first item.

doComponentLayout Ext.Component
chainable ch deprecated dep

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

Returns

:Ext.Component

this

Deprecated since version 4.1
Use Ext.Component#method-updateLayout instead.

doConstrain ( [constrainTo] )

Moves this floating Component into a constrain region.

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

An alternative constraint may be passed.

Parameters

constrainTo :  String/HTMLElement/Ext.dom.Element/Ext.util.Region (optional)

The Element or Ext.util.Region into which this Component is to be constrained. Defaults to the element into which this floating Component was rendered.

doDestroy
private pri

Perform the actual destruction sequence.

As a rule of thumb, subclasses should destroy their child Components and/or other objects before calling parent method. Any object references will be nulled after this method has finished, to prevent the possibility of memory leaks.

Available since: 6.2.0

doFireDelegatedEvent ( eventName, args )
private pri

Fires a delegated event. Users should not invoke this method directly. It is called automatically by the framework as needed (see the "delegate" event option of addListener for more details.

Parameters

eventName :  Object

args :  Object

doFireEvent ( eventName, args, bubbles )
private pri

Continue to fire event.

Parameters

eventName :  String

args :  Array

bubbles :  Boolean

doQuery ( queryString, [forceAll], [rawQuery] ) : Boolean

Executes a query to filter the dropdown list. Fires the beforequery event prior to performing the query allowing the query action to be canceled if needed.

Parameters

queryString :  String

The string to use to filter available items by matching against the configured valueField.

forceAll :  Boolean (optional)

true to force the query to execute even if there are currently fewer characters in the field than the minimum specified by the minChars config option. It also clears any filter previously saved in the current store.

Defaults to: false

rawQuery :  Boolean (optional)

Pass as true if the raw typed value is being used as the query string. This causes the resulting store load to leave the raw value undisturbed.

Defaults to: false

Returns

:Boolean

true if the query was permitted to run, false if it was cancelled by a beforequery handler.

doRawQuery
private pri

Execute the query with the raw contents within the textfield.

doSetValue ( value, add ) :
chainable ch private pri

Sets or adds a value/values

Parameters

value :  Object

add :  Object

Returns

:

enable ( [silent] ) :
chainable ch

Enable the component

Available since: 1.1.0

Parameters

silent :  Boolean (optional)

Passing true will suppress the enable event from being fired.

Defaults to: false

Returns

:

enableBubble ( eventNames )

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

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

Example:

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

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

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

Parameters

eventNames :  String/String[]

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

ensureAttachedToBody ( [runLayout] )

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

Parameters

runLayout :  Boolean (optional)

True to run the component's layout.

Defaults to: false

expand

Expands this field's picker dropdown.

extractFileInput HTMLElement

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.

Returns

:HTMLElement

filterKeys ( e )
private pri

Parameters

e :  Object

findFocusTarget Ext.Component
private pri

Finds an alternate Component to focus if this Component is disabled while focused, or focused while disabled, or otherwise unable to focus.

In both cases, focus must not be lost to document.body, but must move to an intuitively connectible Component, either a sibling, or uncle or nephew.

This is both for the convenience of keyboard users, and also for when focus is tracked within a Component tree such as for ComboBoxes and their dropdowns.

For example, a ComboBox with a PagingToolbar in is BoundList. If the "Next Page" button is hit, the LoadMask shows and focuses, the next page is the last page, so the "Next Page" button is disabled. When the LoadMask hides, it attempt to focus the last focused Component which is the disabled "Next Page" button. In this situation, focus should move to a sibling within the PagingToolbar.

Returns

:Ext.Component

A closely related focusable Component to which focus can move.

findParentBy ( fn ) : Ext.container.Container

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

See also the up method.

Parameters

fn :  Function

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

Returns

:Ext.container.Container

The first Container for which the custom function returns true

findParentByType ( xtype ) : Ext.container.Container

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

See also the up method.

Parameters

xtype :  String/Ext.Class

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

Returns

:Ext.container.Container

The first Container which matches the given xtype or class

findPlugin ( ptype ) : Ext.plugin.Abstract

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

var grid = Ext.create('Ext.grid.Panel', {
    store: {
        fields: ['name'],
        data: [{
            name: 'Scott Pilgrim'
        }]
    },
    columns: [{
        header: 'Name',
        dataIndex: 'name',
        editor: 'textfield',
        flex: 1
    }],
    selType: 'cellmodel',
    plugins: [{
        ptype: 'cellediting',
        clicksToEdit: 1,
        id: 'myplugin'
    }],
    height: 200,
    width: 400,
    renderTo: Ext.getBody()
});

grid.findPlugin('cellediting');  // the cellediting plugin

Note: See also getPlugin

Parameters

ptype :  String

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

Returns

:Ext.plugin.Abstract

plugin instance or undefined if not found

findRecord ( field, value ) : Ext.data.Model

Finds the record by searching for a specific field/value combination.

Parameters

field :  String

The name of the field to test.

value :  Object

The value to match the field against.

Returns

:Ext.data.Model

The matched record or false.

findRecordByDisplay ( value ) : Ext.data.Model

Finds the record by searching values in the displayField.

Parameters

value :  Object

The value to match the field against.

Returns

:Ext.data.Model

The matched record or false.

findRecordByValue ( value ) : Ext.data.Model

Finds the record by searching values in the valueField.

Parameters

value :  Object

The value to match the field against.

Returns

:Ext.data.Model

The matched record or false.

finishRender ( containerIdx )
private pri

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

Parameters

containerIdx :  Number

The index into the Container items of this Component.

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

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

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

Parameters

eventName :  String

The name of the event to fire.

args :  Array

Arguments to pass to handlers and to the action function.

fn :  Function

The action function.

scope :  Object (optional)

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

options :  Object (optional)

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

order :  String (optional)

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

Defaults to: 'before'

Deprecated since version 5.5
Use fireEventedAction instead.

fireEvent ( eventName, args ) : Boolean

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

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

Parameters

eventName :  String

The name of the event to fire.

args :  Object...

Variable number of parameters are passed to handlers.

Returns

:Boolean

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

fireEventArgs ( eventName, args ) : Boolean

Fires the specified event with the passed parameter list.

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

Parameters

eventName :  String

The name of the event to fire.

args :  Object[]

An array of parameters which are passed to handlers.

Returns

:Boolean

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

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

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

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

Parameters

eventName :  String

The name of the event to fire.

args :  Array

Arguments to pass to handlers and to the action function.

fn :  Function/String

The action function.

scope :  Object (optional)

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

fnArgs :  Array/Boolean (optional)

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

Returns

:Boolean

fireHierarchyEvent ( eventName )
private pri

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

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

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

Available since: 4.2.0

Parameters

eventName :  String

The event name.

fireKey ( e, eOpts )
private pri

Parameters

e :  Object

eOpts :  Object

fitContainer ( animate )
private pri

Parameters

animate :  Object

focus ( [selectText] ) : Boolean

Try to focus this component.

If this component is disabled or otherwise not focusable, a close relation will be targeted for focus instead to keep focus localized for keyboard users.

Parameters

selectText :  Boolean/Number[] (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.

Returns

:Boolean

true if focus target was found and focusing was attempted, false if no focusing attempt was made.

forceComponentLayout ( [options] )
deprecated dep

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

Parameters

options :  Object (optional)

An object with layout options.

defer :  Boolean

true if this layout should be deferred.

isRoot :  Boolean

true if this layout should be the root of the layout.

Deprecated since version 4.1
Use Ext.Component#method-updateLayout instead.

getActiveAnimation Ext.fx.Anim/Boolean

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

Returns

:Ext.fx.Anim/Boolean

Anim if element has active effects, else false

getActiveErrors String[]

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.

Returns

:String[]

The active error messages on the component; if there are no errors, an empty Array is returned.

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

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

Parameters

alignToEl :  Ext.util.Positionable/HTMLElement/String

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

position :  String (optional)

The position to align to

Defaults to: "tl-bl?"

offsets :  Number[] (optional)

Offset the positioning by [x, y]

Returns

:Number[]

[x, y]

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

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

Parameters

el :  Ext.dom.Element

The element

anchor :  String (optional)

The specified anchor position. See alignTo for details on supported anchor positions.

Defaults to: 'tl'

local :  Boolean (optional)

True to get the local (element top/left-relative) anchor position instead of page coordinates

size :  Object (optional)

An object containing the size to use for calculating anchor position {width: (target width), height: (target height)} (defaults to the element's current size)

Returns

:Number[]

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

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

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

Parameters

anchor :  String (optional)

The specified anchor position. See alignTo for details on supported anchor positions.

Defaults to: 'tl'

local :  Boolean (optional)

True to get the local (element top/left-relative) anchor position instead of page coordinates

size :  Object (optional)

An object containing the size to use for calculating anchor position {width: (target width), height: (target height)} (defaults to the element's current size)

Returns

:Number[]

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

getAnimationProps
private pri

Get animation properties

getAriaLabelEl ( [reference] ) : Ext.dom.Element
private pri

Find component(s) that label or describe this component, and return the id(s) of their ariaEl elements.

Parameters

reference :  Function/String/String[] (optional)

Component reference, or array of component references, or a function that should return the proper attribute string. The function will be called in the context of the labelled component.

Returns

:Ext.dom.Element

Element id string, or null

getAriaListMarkup
private pri

Build the markup for ARIA listbox.

getBorderPadding Object
private pri

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

Returns

:Object

an object with the following numeric properties

  • beforeX
  • afterX
  • beforeY
  • afterY

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

Return an object defining the area of this Element which can be passed to setBox to set another Element's size/location to match this element.

Parameters

contentBox :  Boolean (optional)

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

local :  Boolean (optional)

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

Returns

:Object

An object in the format

x :  Number

The element's X position.

y :  Number

The element's Y position.

width :  Number

The element's width.

height :  Number

The element's height.

bottom :  Number

The element's lower bound.

right :  Number

The element's rightmost bound.

The returned object may also be addressed as an Array where index 0 contains the X position and index 1 contains the Y position. The result may also be used for setXY

getBubbleParent Ext.util.Observable
private pri

Gets the bubbling parent for an Observable

Returns

:Ext.util.Observable

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

getBubbleTarget
protected pro

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

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

getClientRegion Ext.util.Region

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

That is, the area within any scrollbars.

Returns

:Ext.util.Region

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

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

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

Parameters

name :  String (optional)

The name of the config property to get.

peek :  Boolean (optional)

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

Defaults to: false

ifInitialized :  Boolean (optional)

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

Defaults to: false

Returns

:Object

The config property value.

getConstrainRegion Ext.util.Region

Returns the content region of this element for purposes of constraining or clipping floating children. That is the region within the borders and scrollbars, but not within the padding.

Returns

:Ext.util.Region

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

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

Returns the [X, Y] vector by which this Positionable's element must be translated to make a best attempt to constrain within the passed constraint. Returns false if the element does not need to be moved.

Priority is given to constraining the top and left within the constraint.

The constraint may either be an existing element into which the element is to be constrained, or a Ext.util.Region into which this element is to be constrained.

By default, any extra shadow around the element is not included in the constrain calculations - the edges of the element are used as the element bounds. To constrain the shadow within the constrain region, set the constrainShadow property on this element to true.

Parameters

constrainTo :  Ext.util.Positionable/HTMLElement/String/Ext.util.Region (optional)

The Positionable, HTMLElement, element id, or Region into which the element is to be constrained.

proposedPosition :  Number[] (optional)

A proposed [X, Y] position to test for validity and to produce a vector for instead of using the element's current position

proposedSize :  Number[] (optional)

A proposed [width, height] size to constrain instead of using the element's current size

Returns

:Number[]/Boolean

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

getCursorPosition
private pri

Get the current cursor position in the input field, for key-based navigation

getDisplayValue ( tplData )
private pri

Generates the string value to be displayed in the text field for the currently stored value

Parameters

tplData :  Object

getEl Ext.dom.Element

Retrieves the top level element representing this component.

Available since: 1.1.0

Returns

:Ext.dom.Element

getErrors ( value ) : String[]

Validates a value according to the field's validation rules and returns an array of errors for any failing validations. Validation rules are processed in the following order:

  1. Field specific validator

    A validator offers a way to customize and reuse a validation specification. If a field is configured with a validator function, it will be passed the current field value. The validator function is expected to return either:

    • Boolean true if the value is valid (validation continues).
    • a String to represent the invalid message if invalid (validation halts).
  2. Basic Validation

    If the validator has not halted validation, basic validation proceeds as follows:

  3. Preconfigured Validation Types (VTypes)

    If none of the prior validation steps halts validation, a field configured with a vtype will utilize the corresponding Ext.form.field.VTypes validation function. If invalid, either the field's vtypeText or the VTypes vtype Text property will be used for the invalid message. Keystrokes on the field will be filtered according to the VTypes vtype Mask property.

  4. Field specific regex test

    If none of the prior validation steps halts validation, a field's configured regex test will be processed. The invalid message for this test is configured with regexText

Parameters

value :  Object

The value to validate. The processed raw value will be used if nothing is passed.

Returns

:String[]

Array of any validation errors

getFilters ( [autoCreate] ) : Ext.util.FilterCollection

Returns the Ext.util.FilterCollection. Unless autoCreate is explicitly passed as false this collection will be automatically created if it does not yet exist.

Parameters

autoCreate :  Object (optional)

Pass false to disable auto-creation of the collection.

Defaults to: true

Returns

:Ext.util.FilterCollection

The collection of filters.

getFocusClsEl ( [focusEl] ) : Ext.dom.Element
protected pro

Returns the element used to apply focus styling CSS class when Focusable's focusEl becomes focused. By default it is focusEl.

Parameters

focusEl :  Ext.dom.Element (optional)

Return focus styling element for the given focused element. This is used by Components implementing multiple focusable elements.

Returns

:Ext.dom.Element

The focus styling element.

getFocusEl Ext.dom.Element
protected pro

Returns the main focus holder element associated with this Focusable, i.e. the element that will be focused when Focusable's focus method is called. For most Focusables, this will be the focusEl.

Returns

:Ext.dom.Element

getFrameInfo Boolean
private pri

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

Returns

:Boolean

getFrameTpl ( table )
private pri

Parameters

table :  Object

getInherited ( [inner] ) : Object

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

Available since: 5.0.0

Parameters

inner :  Boolean (optional)

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

Defaults to: false

Returns

:Object

The inheritedState object containing inherited properties.

getInheritedConfig ( property, [skipThis] ) : Mixed

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

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

Available since: 5.0.0

Parameters

property :  String

The name of the config property to return.

skipThis :  Boolean (optional)

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

Defaults to: false

Returns

:Mixed

The value of the requested property.

getInitialConfig ( [name] ) : Object/Mixed

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

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

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

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

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

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

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

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

Parameters

name :  String (optional)

Name of the config option to return.

Returns

:Object/Mixed

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

getInsertPosition ( position ) : HTMLElement

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

Parameters

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

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

Returns

:HTMLElement

DOM element that you can use in the insertBefore

getLabelableRenderData ( data ) : Object
protected pro

Generates the arguments for the field decorations rendering template.

Parameters

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.

Returns

:Object

The template arguments

getLocalX Number

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

Returns

:Number

The local x coordinate

getLocalXY Number[]

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

Returns

:Number[]

The local XY position of the element

getLocalY Number

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

Returns

:Number

The local y coordinate

getMaskTarget
protected pro

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

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

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

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

getModelData ( includeEmptyText ) : Object

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

Parameters

includeEmptyText :  Boolean

Whether or not to include empty text

Returns

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

getMultiSelectItemMarkup
private pri

Build the markup for the labeled items. Template must be built on demand due to ComboBox initComponent life cycle for the creation of on-demand stores (to account for automatic valueField/displayField setting)

getOffsetsTo ( offsetsTo ) : Number[]

Returns the offsets of this element from the passed element. The element must both be part of the DOM tree and not have display:none to have page coordinates.

Parameters

offsetsTo :  Ext.util.Positionable/HTMLElement/String

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

Returns

:Number[]

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

getOverflowEl
private pri

Get an el for overflowing, defaults to the target el

getOverflowStyle
private pri

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

getParams ( queryString )
private pri

Parameters

queryString :  Object

getPicker Ext.Component

Returns a reference to the picker component for this field, creating it if necessary by calling createPicker.

Returns

:Ext.Component

The picker component

getPlugin ( id ) : Ext.plugin.Abstract

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

var grid = Ext.create('Ext.grid.Panel', {
    store: {
        fields: ['name'],
        data: [{
            name: 'Scott Pilgrim'
        }]
    },
    columns: [{
        header: 'Name',
        dataIndex: 'name',
        editor: 'textfield',
        flex: 1
    }],
    selType: 'cellmodel',
    plugins: [{
        ptype: 'cellediting',
        clicksToEdit: 1,
        id: 'myplugin'
    }],
    height: 200,
    width: 400,
    renderTo: Ext.getBody()
});

grid.getPlugin('myplugin');  // the cellediting plugin

Note: See also findPlugin. Prior to 6.2.0 the plugin had to have a pluginId property but this can now be just id. Both are supported (so plugins with a matching pluginId are still found) but id is preferred.

Parameters

id :  String

The id set on the plugin config object.

Returns

:Ext.plugin.Abstract

plugin instance or null if not found

getPosition ( [local] ) : Number[]

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

Parameters

local :  Boolean (optional)

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

Defaults to: false

Returns

:Number[]

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

getRawValue String

Returns the raw value of the field, without performing any normalization, conversion, or validation. To get a normalized and converted value see getValue. Intercept calls to getRawValue to pretend there is no inputEl for rawValue handling, so that we can use inputEl for user input of just the current value.

Returns

:String

value The raw String value of the field

getRecordByListItemNode ( itemEl )

Returns the record from valueStore for the labeled item node

Parameters

itemEl :  Object

getRecordDisplayData ( record ) : Object
protected pro

Gets data for each record to be used for constructing the display value with the displayTpl. This may be overridden to provide access to associated records.

Parameters

record :  Ext.data.Model

The record.

Returns

:Object

The data to be passed for each record to the displayTpl.

getRefItems
private pri

The CQ interface. Allow drilling down into the picker when it exists. Important for determining whether an event took place in the bounds of some higher level containing component. See AbstractComponent#owns

getRefOwner
protected pro

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.

getScrollX Number

Returns the "x" scroll position for this component. Only applicable for scrollable components

Returns

:Number

getScrollY Number

Returns the "y" scroll position for this component. Only applicable for scrollable components

Returns

:Number

getScrollableClientRegion Ext.util.Region
private pri

This method is required by the Scroller to return the scrollable client region

Returns

:Ext.util.Region

The scrolling viewport region.

getSizeModel ( ownerCtSizeModel ) : Object
protected pro

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

Parameters

ownerCtSizeModel :  Object

Returns

:Object

The size model for this component.

width :  Ext.layout.SizeModel

The Ext.layout.SizeModel for the width.

height :  Ext.layout.SizeModel

The Ext.layout.SizeModel for the height.

getState Object

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

:Object

getStoreListeners ( store ) : Object
protected pro

Gets the listeners to bind to a new store.

Parameters

store :  Ext.data.Store

The Store which is being bound to for which a listeners object should be returned.

Returns

:Object

The listeners to be bound to the store in object literal form. The scope may be omitted, it is assumed to be the current instance.

getStyleProxy ( cls )
private pri

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

Parameters

cls :  Object

getSubTplData ( fieldData ) : Object
template tpl

Creates and returns the data object to be used when rendering the fieldSubTpl.

Parameters

fieldData :  Object

Returns

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

getSubTplMarkup ( fieldData )
protected pro

Gets the markup to be inserted into the outer template's bodyEl. For fields this is the actual input element.

Parameters

fieldData :  Object

getSubmitData

Private override to use getSubmitValue() as a convenience Overridden to optionally allow for submitting the field as a json encoded array.

getTargetEl
private pri

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

getTdCls
private pri

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

getTdType String
private pri

Returns

:String

getTextSelection Array

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

 [ start, end, direction ]

These have the same meaning as the parameters to selectText.

Available since: 6.5.0

Returns

:Array

getTopAlignTarget Ext.dom.Element/Ext.Component
private pri

Gets the topmost non floating alignTo target if there are multiple aligns such as a menu stack hanging off a button or grid column header.

Returns

:Ext.dom.Element/Ext.Component

The topmost, non floating alignTo target.

getTrigger ( id ) : Ext.form.trigger.Trigger

Returns the trigger with the given id

Parameters

id :  String

Returns

:Ext.form.trigger.Trigger

getTriggerWidth Number

Get the total width of the trigger button area.

Returns

:Number

The total trigger width

getValueRecords Array

Returns the records for the field's current value

Returns

:Array

The records for the field's current value

getViewRegion Ext.util.Region

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

Returns

:Ext.util.Region

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

getX Number

Gets the current X position of the DOM element based on page coordinates.

Returns

:Number

The X position of the element

getXType String

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

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

Returns

:String

The xtype

getXTypes String

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

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

Example usage:

Available since: 2.3.0

Returns

:String

The xtype hierarchy string

getXY Number[]

Gets the current position of the DOM element based on page coordinates.

Returns

:Number[]

The XY position of the element

getY Number

Gets the current Y position of the DOM element based on page coordinates.

Returns

:Number

The Y position of the element

handleBlurEvent ( e )
private pri

Parameters

e :  Object

handleFocusEvent ( e )
private pri

Parameters

e :  Object

hasActiveError Boolean

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

:Boolean

hasActiveFx Ext.fx.Anim/Boolean
deprecated dep

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

Returns

:Ext.fx.Anim/Boolean

Anim if element has active effects, else false

Deprecated since version 4.0
Replaced by getActiveAnimation

hasCls ( className ) : Boolean

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

Parameters

className :  String

The CSS class to check for.

Returns

:Boolean

true if the class exists, else false.

hasConfig ( name )
private pri

Parameters

name :  String

hasListener ( eventName ) : Boolean

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

Parameters

eventName :  String

The name of the event to check for

Returns

:Boolean

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

hasSelectedText
private pri

Check to see if the input field has selected text, for key-based navigation

hasUICls ( cls )

Checks if there is currently a specified uiCls.

Parameters

cls :  String

The cls to check.

hasVisibleLabel Boolean

Checks if the field has a visible label

Returns

:Boolean

True if the field has a visible label

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

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

Parameters

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.

Returns

:Ext.Component

this

initBindable
private pri

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

Available since: 5.0.0

initComponent
template tpl protected pro

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.

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

Initialize configuration for this class. a typical example:

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

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

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

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

Parameters

instanceConfig :  Object

Returns

:Ext.Base

this

initEvents
protected pro

Initialize any events on this component

initField

Initializes this Field mixin on the current instance. Components using this mixin should call this method during their own initialization process.

initFocusableElement ( force )
private pri

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

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

Parameters

force :  Object

initFocusableEvents ( force )
protected pro

Template method to do any event listener initialization for a Focusable. This generally happens after the focusEl is available.

Parameters

force :  Object

initInheritedState ( inheritedState )
protected pro

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

Parameters

inheritedState :  Object

initKeyMap
protected pro

This method should be called when the instance is ready to start listening for keyboard events. This is called automatically for Ext.Component and derived classes. This is done after the component is rendered.

initLabelable

Performs initialization of this mixin. Component classes using this mixin should call this method during their own initialization.

initPadding ( targetEl )
private pri

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

Parameters

targetEl :  Object

initPlugin ( plugin )
private pri

Parameters

plugin :  Object

initRenderData Object
protected pro

Initialized the renderData to be used when rendering the renderTpl.

Returns

:Object

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

initRenderTpl Ext.XTemplate
private pri

Initializes the renderTpl.

Returns

:Ext.XTemplate

The renderTpl XTemplate instance.

initState
private pri

Initializes the state of the object upon construction.

initStyles ( targetEl )
private pri

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

Parameters

targetEl :  Object

initValue

Initializes the field's value based on the initial config.

invalidateInheritedState
private pri

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

Available since: 5.0.0

invokeTriggers ( methodName )
private pri

Invokes a method on all triggers.

Parameters

methodName :  String

is ( selector ) : Boolean

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

Parameters

selector :  String

The selector string to test against.

Returns

:Boolean

true if this Component matches the selector.

isAncestor ( possibleDescendant ) : Boolean

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

Parameters

possibleDescendant :  Ext.Component

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

Returns

:Boolean

isBlurring ( e ) : Boolean
private pri

Parameters

e :  Object

Returns

:Boolean

isBound ( [name] ) : Boolean

Determines if the passed property name is bound to ViewModel data.

Available since: 6.5.0

Parameters

name :  String (optional)

The property name to test. Defaults to the defaultBindProperty

Returns

:Boolean

true if the passed property receives data from a ViewModel.

isDescendantOf ( ancestor ) : Boolean

Determines whether this component is the descendant of a passed component.

Parameters

ancestor :  Ext.Component

A Component which may contain this Component.

Returns

:Boolean

true if the component is the descendant of the passed component, otherwise false.

isDestructing Boolean
private pri

Determines if this Component is inside a Component tree which is destroyed, or is being destroyed.

Returns

:Boolean

true if this Component, or any ancestor is destroyed, or is being destroyed.

isDirty Boolean

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.

Returns

:Boolean

True if this field has been changed from its original value (and is not disabled), false otherwise.

isDisabled Boolean

Method to determine whether this Component is currently disabled.

Returns

:Boolean

the disabled state of this Component.

isDraggable Boolean

Method to determine whether this Component is draggable.

Returns

:Boolean

the draggable state of this component.

isDroppable Boolean

Method to determine whether this Component is droppable.

Returns

:Boolean

the droppable state of this component.

isEqual ( v1, v2 ) : Boolean

Overridden to be more accepting of varied value types

Parameters

v1 :  Object

v2 :  Object

Returns

:Boolean

isEqualAsString ( value1, value2 ) : Boolean
private pri

Returns whether two values are logically equal. Similar to isEqual, however null or undefined values will be treated as empty strings.

Parameters

value1 :  Object

The first value to compare

value2 :  Object

The second value to compare

Returns

:Boolean

True if the values are equal, false if inequal.

isFileUpload Boolean

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.

Returns

:Boolean

isFloating Boolean

Method to determine whether this Component is floating.

Returns

:Boolean

the floating state of this component.

isFocusable ( [deep] ) : Boolean

Determine if this Focusable can receive focus at this time.

Note that Containers can be non-focusable themselves while delegating focus treatment to a child Component; see defaultFocus for more information.

Parameters

deep :  Boolean (optional)

Optionally determine if the container itself is focusable, or if container's focus is delegated to a child component and that child is focusable.

Defaults to: false

Returns

:Boolean

True if component is focusable, false if not.

isFocusing ( e ) : Boolean
private pri

Parameters

e :  Object

Returns

:Boolean

isHidden Boolean

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

Returns

:Boolean

the hidden state of this Component.

isLayoutChild ( ownerCandidate ) : Boolean
private pri

Checks if this component will be contained by the passed component as part of its layout run. If true, then the layout on this can be skipped because it will be encompassed when the layout for comp runs. Typical cases where this may be be false is when asking about floaters nested in containers.

Parameters

ownerCandidate :  Ext.Component

The potential owner.

Returns

:Boolean

true if this component is a layout child of comp.

isLayoutRoot Boolean
protected pro

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

:Boolean

isLayoutSuspended Boolean

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

Returns

:Boolean

true layout of this component is suspended.

isMasked ( [deep] ) : Boolean

Returns masked state for this Component.

Parameters

deep :  Boolean (optional)

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

Defaults to: false

Returns

:Boolean

True if masked, false otherwise.

isSuspended ( [event] ) : Boolean

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

Parameters

event :  String (optional)

The name of the specific event to check

Returns

:Boolean

true if events are suspended

isSyncing ( name ) : Boolean
private pri

Checks if a particular binding is synchronizing the value.

Parameters

name :  String

The name of the property being bound to.

Returns

:Boolean

true if the binding is syncing.

isValid Boolean

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.

Returns

:Boolean

True if the value is valid, else false

isVisible ( [deep] ) : Boolean

Returns true if this component is visible.

Available since: 1.1.0

Parameters

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

Returns

:Boolean

true if this component is visible, false otherwise.

isXType ( xtype, [shallow] ) : Boolean

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

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

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

Example usage:

Available since: 2.3.0

Parameters

xtype :  String

The xtype to check for this Component

shallow :  Boolean (optional)

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

Defaults to: false

Returns

:Boolean

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

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

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

Available since: 5.0.1

Parameters

skipThis :  Boolean (optional)

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

Defaults to: false

Returns

:Ext.app.ViewController

The controller. null if no controller is found.

lookupNameHolder ( [skipThis] ) : Ext.Component
private pri

Gets the Form or Component that is used as the name holder for this component.

Available since: 6.5.0

Parameters

skipThis :  Boolean (optional)

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

Defaults to: true

Returns

:Ext.Component

The name holder.

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

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

Available since: 5.0.0

Parameters

skipThis :  Boolean (optional)

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

Defaults to: true

Returns

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

The reference holder.

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

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

Available since: 5.0.0

Parameters

skipThis :  Boolean (optional)

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

Defaults to: false

Returns

:Ext.data.Session

lookupTpl ( name ) : Ext.XTemplate

Gets a named template instance for this class. See Ext.XTemplate#getTpl.

Available since: 6.2.0

Parameters

name :  String

The name of the property that holds the template.

Returns

:Ext.XTemplate

The template, null if not found.

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

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

Available since: 5.0.0

Parameters

skipThis :  Boolean (optional)

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

Defaults to: false

Returns

:Ext.app.ViewModel

makeBindableUpdater ( cfg ) : Function
private pri

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

Available since: 5.0.0

Parameters

cfg :  Ext.Config

Returns

:Function

The updater function.

markInvalid ( errors )

Display one or more error messages associated with this field, using Ext.form.Labelable#msgTarget to determine how to display the messages and applying Ext.form.Labelable#invalidCls to the field's UI element.

var formPanel = Ext.create('Ext.form.Panel', {
    title: 'Contact Info',
    width: 300,
    bodyPadding: 10,
    renderTo: Ext.getBody(),
    items: [{
        xtype: 'textfield',
        name: 'name',
        id: 'nameId',
        fieldLabel: 'Name'
    }],
    bbar: [{
        text: 'Mark both fields invalid',
        handler: function() {
            var nameField = formPanel.getForm().findField('name');
            nameField.markInvalid('Name invalid message');

            // multiple error string syntax
            // nameField.markInvalid(['First message', 'Second message']);
        }
    }]
});

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.

Parameters

errors :  String/String[]

The validation message(s) to display.

mask ( [msg], [msgCls] )

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

See unmask.

Parameters

msg :  String (optional)

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

msgCls :  String (optional)

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

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

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

Example:

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

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

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

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

Parameters

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

The item to which to add a listener/listeners.

ename :  Object/String

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

fn :  Function/String (optional)

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

scope :  Object (optional)

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

options :  Object (optional)

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

Returns

:Object

Only when the destroyable option is specified.

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

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

And when those listeners need to be removed:

Ext.destroy(this.btnListeners);

or

this.btnListeners.destroy();

move ( direction, distance )

Move the element relative to its current position.

Parameters

direction :  String

Possible values are:

  • "l" (or "left")
  • "r" (or "right")
  • "t" (or "top", or "up")
  • "b" (or "bottom", or "down")

distance :  Number

How far to move the element in pixels

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

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

Parameters

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

The item from which to remove a listener/listeners.

ename :  Object/String

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

fn :  Function (optional)

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

scope :  Object (optional)

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

nextNode ( [selector] ) : Ext.Component

Returns the next node in the Component tree in tree traversal order.

Note that this is not limited to siblings, and if invoked upon a node with no matching siblings, will walk the tree to attempt to find a match. Contrast with nextSibling.

Parameters

selector :  String (optional)

A Ext.ComponentQuery selector to filter the following nodes.

Returns

:Ext.Component

The next node (or the next node which matches the selector). Returns null if there is no matching node.

nextSibling ( [selector] ) : Ext.Component

Returns the next sibling of this Component.

Optionally selects the next sibling which matches the passed Ext.ComponentQuery selector.

May also be referred to as next()

Note that this is limited to siblings, and if no siblings of the item match, null is returned. Contrast with nextNode

Parameters

selector :  String (optional)

A Ext.ComponentQuery selector to filter the following items.

Returns

:Ext.Component

The next sibling (or the next sibling which matches the selector). Returns null if there is no matching sibling.

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

The on method is shorthand for addListener.

Appends an event handler to this object. For example:

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

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

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

One can also specify options for each event handler separately:

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

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

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

Parameters

eventName :  String/Object

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

fn :  Function/String (optional)

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

scope :  Object (optional)

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

options :  Object (optional)

An object containing handler configuration.

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

This object may contain any of the following properties:

scope :  Object

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

delay :  Number

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

single :  Boolean

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

buffer :  Number

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

onFrame :  Number

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

target :  Ext.util.Observable

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

element :  String

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

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

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

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

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

 panel.body.un(...)

delegate :  String (optional)

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

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

See the delegate example below.

capture :  Boolean (optional)

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

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

stopPropagation :  Boolean (optional)

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

preventDefault :  Boolean (optional)

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

stopEvent :  Boolean (optional)

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

args :  Array (optional)

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

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

destroyable :  Boolean (optional)

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

Defaults to:

false

priority :  Number (optional)

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

order :  String (optional)

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

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

Defaults to:

'current'

order :  String (optional)

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

Combining Options

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

A delayed, one-time listener.

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

Attaching multiple handlers in 1 call

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

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

Delegate

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

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

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

Defaults to: 'current'

Returns

:Object

Only when the destroyable option is specified.

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

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

And when those listeners need to be removed:

Ext.destroy(this.btnListeners);

or

this.btnListeners.destroy();

onAdded ( container, pos, instanced )
template tpl protected pro

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

Parameters

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.

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

Appends an after-event handler.

Same as addListener with order set to 'after'.

Parameters

eventName :  String/String[]/Object

The name of the event to listen for.

fn :  Function/String

The method the event invokes.

scope :  Object (optional)

The scope for fn.

options :  Object (optional)

An object containing handler configuration.

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

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

Same as addListener with order set to 'before'.

Parameters

eventName :  String/String[]/Object

The name of the event to listen for.

fn :  Function/String

The method the event invokes.

scope :  Object (optional)

The scope for fn.

options :  Object (optional)

An object containing handler configuration.

onBindStore ( store, initial )
protected pro

Template method, it is called when a new store is bound to the current instance.

Parameters

store :  Ext.data.AbstractStore

The store being bound

initial :  Boolean

True if this store is being bound as initialization of the instance.

onBlur

Intercept calls to onBlur to remove focusCls, because the base field classes assume this should be applied to inputEl

onBoxReady ( width, height )
template tpl protected pro

Invoked when this component has first achieved size. This occurs after the componentLayout has completed its initial run.

This method is not called on components that use cfg-liquidLayout, such as Ext.button.Button and Ext.form.field.Base.

Note: If the Component has a ViewController and the controller has a boxReady method it will be called passing the Component and its width and height.

 boxReady: function (view, width, height) {
     // ...
 }

Parameters

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.

onChange ( newVal, oldVal )
private pri

If grow=true, invoke the autoSize method when the field's value is changed.

Parameters

newVal :  Object

oldVal :  Object

onCollapse
private pri

Disables the key navs for the BoundList when it is collapsed.

onDestroy
template tpl protected pro

Allows addition of behavior to the destroy operation.

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

onDirtyChange ( isDirty )
private pri

Called when the field's dirty state changes. Adds/removes the dirtyCls on the main element.

Parameters

isDirty :  Boolean

onDisable
template tpl protected pro

Allows addition of behavior to the disable operation. After calling the superclass's onDisable, the Component will be disabled.

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

onEnable
template tpl protected pro

Allows addition of behavior to the enable operation. After calling the superclass's onEnable, the Component will be enabled.

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

onEsc ( e )
private pri

Parameters

e :  Object

onExpand
private pri

Enables the key navs for the BoundList when it is expanded.

onFieldMutation ( e )
private pri

Called when some event (See the checkChangeEvents property) mutates the input field. We react to changes.

Subclasses may provide an inplementation which may perform other tasks (eg ComboBox value matching) before calling the checkChange method.

Parameters

e :  Object

onFocus

Intercept calls to onFocus to add focusCls, because the base field classes assume this should be applied to inputEl

onFocusEnter ( e )
template tpl protected pro

Called when focus enters this Component's hierarchy

Parameters

e :  Object

event :  Ext.event.Event

The underlying DOM event.

target :  HTMLElement

The element gaining focus.

relatedTarget :  HTMLElement

The element losing focus.

toComponent :  Ext.Component

The Component gaining focus.

fromComponent :  Ext.Component

The Component losing focus.

backwards :  Boolean

true if the fromComponent is after the toComponent* in the DOM tree, indicating that the user usedSHIFT+TABto move focus. Note that settingtabIndexvalues to affect tabbing order can cause this to be incorrect. SettingtabIndex values is not advised.

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

onFocusLeave ( e )
template tpl protected pro

Called when focus exits from this Component's hierarchy

Parameters

e :  Ext.event.Event

event :  Ext.event.Event

The underlying DOM event.

target :  HTMLElement

The element gaining focus.

relatedTarget :  HTMLElement

The element losing focus.

toComponent :  Ext.Component

The Component gaining focus.

fromComponent :  Ext.Component

The Component losing focus.

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

onFocusTopmost
private pri

This method is called internally by Ext.ZIndexManager to signal that a focusable floating Component has become the topost focusable in its zIndex stack.

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

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.

Parameters

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

callback :  Function (optional)

Callback function to be called when finished

scope :  Object (optional)

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

onInheritedAdd ( instanced )
private pri

Called when this Inheritable is added to a parent

Parameters

instanced :  Boolean

onInheritedRemove ( destroying )
private pri

Called when this inheritable is removed from a parent

Parameters

destroying :  Boolean

true if this item will be destroyed by it's container

onItemListClick ( e )
protected pro

Delegation control for selecting and removing labeled items or triggering list collapse/expansion

Parameters

e :  Object

onKeyDown ( e )
protected pro

Handles keyDown processing of key-based selection of labeled items. Supported keyboard controls:

  • If pick list is expanded

    • CTRL-A will select all the items in the pick list
  • If the cursor is at the beginning of the input field and there are values present

    • CTRL-A will highlight all the currently selected values
    • BACKSPACE and DELETE will remove any currently highlighted selected values
    • RIGHT and LEFT will move the current highlight in the appropriate direction
    • SHIFT-RIGHT and SHIFT-LEFT will add to the current highlight in the appropriate direction

Parameters

e :  Object

onKeyUp ( e, t )
protected pro

Handles auto-selection and creation of labeled items based on this field's delimiter, as well as the keyUp processing of key-based selection of labeled items.

Parameters

e :  Object

t :  Object

onMouseDown ( e )
private pri

Mousedown brings to front, and programmatically grabs focus unless the mousedown was on a focusable element

Parameters

e :  Object

onPosition ( x, y )
template tpl protected pro

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.

Parameters

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.

onRemoved ( destroying )
template tpl protected pro

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

Parameters

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.

onRender ( parentNode, containerIdx )
template tpl protected pro

Template method called when this Component's DOM structure is created.

At this point, this Component's (and all descendants') DOM structure exists but it has not been layed out (positioned and sized).

Subclasses which override this to gain access to the structure at render time should call the parent class's method before attempting to access any child elements of the Component.

Parameters

parentNode :  Ext.dom.Element

The parent Element in which this Component's encapsulating element is contained.

containerIdx :  Number

The index within the parent Container's child collection of this Component.

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

onResize ( width, height, oldWidth, oldHeight )
template tpl protected pro

Called when the component is resized.

This method is not called on components that use cfg-liquidLayout, such as Ext.button.Button and Ext.form.field.Base.

Parameters

width :  Number

The new width that was set

height :  Number

The new height that was set

oldWidth :  Number

The previous width

oldHeight :  Number

The previous height

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

onScrollEnd ( x, y )
template tpl protected pro

Invoked when a scroll operation is completed via this component's scroller.

Parameters

x :  Number

The current x position

y :  Number

The current y position

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

onScrollMove ( x, y )
template tpl protected pro

Invoked when this component is scrolled via its scroller.

Parameters

x :  Number

The current x position

y :  Number

The current y position

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

onScrollStart ( x, y )
template tpl protected pro

Invoked when a scroll is initiated on this component via its scroller.

Parameters

x :  Number

The current x position

y :  Number

The current y position

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

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

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.

Parameters

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

callback :  Function (optional)

scope :  Object (optional)

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

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

Invoked after the #afterShow method is complete.

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

Parameters

callback :  Function (optional)

scope :  Object (optional)

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

onStateChange
private pri

This method is called when any of the stateEvents are fired.

onTriggerClick ( field, trigger, event )
protected pro

Handles the trigger click; by default toggles between expanding and collapsing the picker component.

Parameters

field :  Ext.form.field.Picker

This field instance.

trigger :  Ext.form.trigger.Trigger

This field's picker trigger.

event :  Ext.event.Event

The event that generated this call.

onTypeAhead
protected pro

Overridden to get and set the DOM value directly for type-ahead suggestion (bypassing get/setRawValue)

onUnbindStore ( store, initial )
protected pro

Template method, it is called when an existing store is unbound from the current instance.

Parameters

store :  Ext.data.AbstractStore

The store being unbound

initial :  Boolean

True if this store is being bound as initialization of the instance.

onZIndexChange ( [isTopMost] )
private pri

This method is called internally by Ext.ZIndexManager to signal that a floating Component has either been moved to the top of its zIndex stack, or pushed from the top of its zIndex stack.

If a Window is superceded by another Window, deactivating it hides its shadow.

This method also fires the activate or deactivate event depending on which action occurred.

Parameters

isTopMost :  Boolean (optional)

True to activate the Component, false to deactivate it.

Defaults to: false

owns ( element )
private pri

Returns true if the passed element is within the container tree of this component.

For example if a menu's submenu contains an Ext.form.field.Date, that top level menu owns the elements of the date picker. Using this method, you can tell if an event took place within a certain component tree.

Parameters

element :  Object

previousNode ( [selector] ) : Ext.Component

Returns the previous node in the Component tree in tree traversal order.

Note that this is not limited to siblings, and if invoked upon a node with no matching siblings, will walk the tree in reverse order to attempt to find a match. Contrast with previousSibling.

Parameters

selector :  String (optional)

A Ext.ComponentQuery selector to filter the preceding nodes.

Returns

:Ext.Component

The previous node (or the previous node which matches the selector). Returns null if there is no matching node.

previousSibling ( [selector] ) : Ext.Component

Returns the previous sibling of this Component.

Optionally selects the previous sibling which matches the passed Ext.ComponentQuery selector.

May also be referred to as prev()

Note that this is limited to siblings, and if no siblings of the item match, null is returned. Contrast with previousNode

Parameters

selector :  String (optional)

A Ext.ComponentQuery selector to filter the preceding items.

Returns

:Ext.Component

The previous sibling (or the previous sibling which matches the selector). Returns null if there is no matching sibling.

processRawValue ( value ) : String

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.

Parameters

value :  String

The unprocessed string value

Returns

:String

The processed string value

publishState ( [property], [value] )
protected pro

Publish this components state to the ViewModel. If no arguments are given (or if this is the first call), the entire state is published. This state is determined by the publishes property.

This method is called only by component authors.

Available since: 5.0.0

Parameters

property :  String (optional)

The name of the property to update.

value :  Object (optional)

The value of property. Only needed if property is given.

publishValue
private pri

Publish the value of this field.

rawToValue ( rawValue ) : Object

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.

Parameters

rawValue :  Object

Returns

:Object

The converted value.

registerFloatingItem ( cmp )

Called by Component#doAutoRender

Register a Container configured floating: true with this Component's Ext.ZIndexManager.

Components added in this way will not participate in any layout, but will be rendered upon first show in the way that Ext.window.Windows are.

Parameters

cmp :  Object

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

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

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

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

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

Parameters

origin :  Object

The Observable whose events this object is to relay.

events :  String[]/Object

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

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

prefix :  String (optional)

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

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

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

Returns

:Object

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

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

Can be undone by calling

Ext.destroy(this.storeRelayers);

or this.store.relayers.destroy();

removeAnchor Ext.util.Positionable
chainable ch

Remove any anchor to this element. See anchorTo.

Returns

:Ext.util.Positionable

this

removeByListItemNode ( itemEl )

Removal of labelled item by node reference

Parameters

itemEl :  Object

removeClass ( cls ) : Ext.Component
deprecated dep

Removes a CSS class from the top level element representing this component.

Available since: 2.3.0

Parameters

cls :  String/String[]

The CSS class name to remove.

Returns

:Ext.Component

Returns the Component to allow method chaining.

Deprecated since version 4.1
Use addCls instead.

removeCls ( cls ) : Ext.Component
chainable ch

Removes a CSS class from the top level element representing this component.

Parameters

cls :  String/String[]

The CSS class name to remove.

Returns

:Ext.Component

Returns the Component to allow method chaining.

removeClsWithUI ( classes, skip )

Removes a cls to the uiCls array, which will also call removeUIClsFromElement and removes it from all elements of this component.

Parameters

classes :  String/String[]

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

skip :  Boolean

True to remove the class

removeDelegatedListener ( eventName, fn, scope )
private pri

Removes delegated listeners for a given eventName, function, and scope. Users should not invoke this method directly. It is called automatically by the framework as part of removeListener processing.

Parameters

eventName :  Object

fn :  Object

scope :  Object

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

Removes an event handler.

Parameters

eventName :  String

The type of event the handler was associated with.

fn :  Function

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

scope :  Object (optional)

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

Convenience Syntax

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

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

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

Exception - DOM event handlers using the element config option

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

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

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

Returns

:

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

Removes listeners that were added by the mon method.

Parameters

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

The item from which to remove a listener/listeners.

ename :  Object/String

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

fn :  Function (optional)

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

scope :  Object (optional)

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

removeManagedListenerItem ( isClear, managedListener )
private pri

Remove a single managed listener item

Parameters

isClear :  Boolean

True if this is being called during a clear

managedListener :  Object

The managed listener item See removeManagedListener for other args

removeUIClsFromElement ( uiCls )
protected pro

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.

Parameters

uiCls :  String

The UI class to remove from the element.

removeUIFromElement
private pri

Method which removes a specified UI from the components element.

removeValue ( value )

Removes a value or values from the current value of the field

Parameters

value :  Mixed

The value or values to remove from the current value, see setValue

render ( [container], [position] )

Renders the Component into the passed HTML element.

If you are using a Ext.container.Container object to house this Component, then do not use the render method.

A Container's child Components are rendered by that Container's layout manager when the Container is first rendered.

When creating complex UIs, it is important to remember that sizing and positioning of child items is the responsibility of the Container's layout manager. If you expect child items to be sized in response to user interactions, you must configure the Container with a layout manager which creates and manages the type of layout you have in mind.

Omitting the Container's layout config means that a basic layout manager is used which does nothing but render child components sequentially into the Container. No sizing or positioning will be performed in this situation.

Parameters

container :  Ext.dom.Element/HTMLElement/String (optional)

The element this Component should be rendered into. If it is being created from existing markup, this should be omitted.

position :  String/Number (optional)

The element ID or DOM node index within the container before which this component will be inserted (defaults to appending to the end of the container)

renderActiveError

Intercept calls to renderActiveError to add invalidCls, because the base field classes assume this should be applied to inputEl

reset

Resets the current field value to the originally loaded value and clears any validation messages. See Ext.form.Basic.trackResetOnLoad

resetOriginalValue

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.

resolveListenerScope ( [defaultScope] ) : Ext.app.ViewController/Ext.container.Container
protected pro

Gets the Controller or Component that is used as the event root for this view.

Available since: 5.0.0

Parameters

defaultScope :  Object (optional)

The default scope to return if none is found.

Defaults to: this

Returns

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

The default listener scope.

resolveSatelliteListenerScope ( satellite, [defaultScope] ) : Object
protected pro

Returns the default listener scope for a "satellite" of this component. Used for resolving scope for observable objects that are not part of the normal Container/Component hierarchy (for example, plugins)

Available since: 5.1.1

Parameters

satellite :  Ext.mixin.Observable

defaultScope :  Object (optional)

Returns

:Object

The listener scope

resumeEvent ( eventName )

Resumes firing of the named event(s).

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

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

Parameters

eventName :  String...

Multiple event names to resume.

resumeEvents ( [discardQueue] )

Resumes firing events (see suspendEvents).

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

Parameters

discardQueue :  Boolean (optional)

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

reverseTranslateXY ( xy ) : Number[]
private pri

Converts local coordinates into page-level coordinates

Parameters

xy :  Number[]

The local x and y coordinates

Returns

:Number[]

The translated coordinates

revertFocus
private pri

Returns focus to the Component or element found in the cached focusEnterEvent.

savePropToState ( propName, state, [stateName] ) : Boolean

Conditionally saves a single property from this object to the given state object. The idea is to only save state which has changed from the initial state so that current software settings do not override future software settings. Only those values that are user-changed state should be saved.

Parameters

propName :  String

The name of the property to save.

state :  Object

The state object in to which to save the property.

stateName :  String (optional)

The name to use for the property in state.

Returns

:Boolean

True if the property was saved, false if not.

savePropsToState ( propNames, state ) : Object

Gathers additional named properties of the instance and adds their current values to the passed state object.

Parameters

propNames :  String/String[]

The name (or array of names) of the property to save.

state :  Object

The state object in to which to save the property values.

Returns

:Object

state

saveState

Saves the state of the object to the persistence store.

scrollBy ( deltaX, deltaY, animate )

Scrolls this Component by the passed delta values, optionally animating.

All of the following are equivalent:

 comp.scrollBy(10, 10, true);
 comp.scrollBy([10, 10], true);
 comp.scrollBy({ x: 10, y: 10 }, true);

Parameters

deltaX :  Number/Number[]/Object

Either the x delta, an Array specifying x and y deltas or an object with "x" and "y" properties.

deltaY :  Number/Boolean/Object

Either the y delta, or an animate flag or config object.

animate :  Boolean/Object

Animate flag/config object if the delta values were passed separately.

scrollTo ( x, y, [animate] )

Scrolls this component to the specified x and y coordinates. Only applicable for scrollable components.

Parameters

x :  Number

y :  Number

animate :  Boolean/Object (optional)

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

select ( r )

Selects an item by a Ext.data.Model, or by a key value.

Parameters

r :  Object

selectText ( [start], [end], [direction] ) : Ext.form.field.Text
chainable ch

Select the specified contents of the input field (all by default).

Parameters

start :  Number (optional)

Defaults to: 0

end :  Number (optional)

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

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

Defaults to: "f"

Returns

:Ext.form.field.Text

this

sequenceFx Object
chainable ch

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

Returns

:Object

this

setActiveErrors ( errors )

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.

Parameters

errors :  String[]

The error messages

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

Sets the element's box.

Parameters

box :  Object

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

Returns

:Ext.util.Positionable

this

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

Sets a single/multiple configuration options.

Parameters

name :  String/Object

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

value :  Object (optional)

The value to set for the name parameter.

Returns

:Ext.Base

this

setDocked ( dock ) : Ext.Component
deprecated dep

Sets the dock position of this component in its parent panel. Note that this only has effect if this item is part of the dockedItems collection of a parent that has a DockLayout (note that any Panel has a DockLayout by default)

Parameters

dock :  Object

The dock position.

Returns

:Ext.Component

this

Deprecated since version 5.0
Use setDock instead.

setError ( error )
private pri

Set the current error state

Parameters

error :  String

The error message to set

setFieldDefaults ( defaults )

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.

Parameters

defaults :  Object

The defaults to apply to the object.

setHiddenValue ( values )
private pri

Set the value of hiddenDataEl Dynamically adds and removes input[type=hidden] elements

Parameters

values :  Object

setLoading ( load ) : Ext.LoadMask

This method allows you to show or hide a LoadMask on top of this component.

The mask will be rendered into the element returned by getMaskTarget which for most Components is the Component's element. See getMaskTarget and maskElement.

Most Components will return null indicating that their LoadMask cannot reside inside their element, but must be rendered into the document body.

Ext.view.Table however will direct a LoadMask to be rendered into the owning Ext.panel.Table.

Parameters

load :  Boolean/Object/String

True to show the default LoadMask, a config object that will be passed to the LoadMask constructor, or a message String to show. False to hide the current LoadMask.

Returns

:Ext.LoadMask

The LoadMask instance that has just been shown.

setLocalX ( x ) : Ext.util.Positionable

Sets the local x coordinate of this element using CSS style. When used on an absolute positioned element this method is symmetrical with getLocalX, but may not be symmetrical when used on a relatively positioned element.

Parameters

x :  Number

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

Returns

:Ext.util.Positionable

this

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

Sets the local x and y coordinates of this element using CSS style. When used on an absolute positioned element this method is symmetrical with getLocalXY, but may not be symmetrical when used on a relatively positioned element.

Parameters

x :  Number/Array

The x coordinate or an array containing [x, y]. A value of null sets the left style to 'auto'

y :  Number (optional)

The y coordinate, required if x is not an array. A value of null sets the top style to 'auto'

Returns

:Ext.util.Positionable

this

setLocalY ( y ) : Ext.util.Positionable

Sets the local y coordinate of this element using CSS style. When used on an absolute positioned element this method is symmetrical with getLocalY, but may not be symmetrical when used on a relatively positioned element.

Parameters

y :  Number

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

Returns

:Ext.util.Positionable

this

setMasked ( isMasked ) :
chainable ch private pri

Set masked state for this Component.

Parameters

isMasked :  Boolean

True if masked, false otherwise.

Returns

:

setOverflowXY ( overflowX, overflowY ) : Ext.Component
chainable ch deprecated dep

Sets the overflow x/y on the content element of the component. The x/y overflow values can be any valid CSS overflow (e.g., 'auto' or 'scroll'). By default, the value is 'hidden'. Passing undefined will preserve the current value.

Parameters

overflowX :  String

The overflow-x value.

overflowY :  String

The overflow-y value.

Returns

:Ext.Component

this

Deprecated since version 5.0.0
Use setScrollable instead

setPagePosition ( x, [y], [animate] ) : Ext.Component
chainable ch

Sets the page XY position of the component. To set the left and top instead, use setPosition. This method fires the event-move event.

Parameters

x :  Number/Number[]

The new x position or an array of [x,y].

y :  Number (optional)

The new y position.

animate :  Boolean/Object (optional)

True to animate the Component into its new position. You may also pass an animation configuration.

Returns

:Ext.Component

this

setPosition ( x, [y], [animate] ) : Ext.Component
chainable ch

Sets the left and top of the component. To set the page XY position instead, use setPagePosition. This method fires the event-move event.

Parameters

x :  Number/Number[]/Object

The new left, an array of [x,y], or animation config object containing x and y properties.

y :  Number (optional)

The new top.

animate :  Boolean/Object (optional)

If true, the Component is animated into its new position. You may also pass an animation configuration.

Returns

:Ext.Component

this

setRawValue ( value ) : Object

Sets the field's raw value directly, bypassing value conversion, change detection, and validation. To set the value with these additional inspections see setValue.

Parameters

value :  Object

The value to set

Returns

:Object

value The field value that is set

setReadOnlyAttr ( readOnly )
private pri

Sets the readonly attribute of the input element

Parameters

readOnly :  Object

setScrollX ( x, [animate] )

Sets the "x" scroll position for this component. Only applicable for scrollable components

Parameters

x :  Number

animate :  Boolean/Object (optional)

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

setScrollY ( y, [animate] )

Sets the "y" scroll position for this component. Only applicable for scrollable components

Parameters

y :  Number

animate :  Boolean/Object (optional)

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

setVisible ( visible ) : Ext.Component
chainable ch

Convenience function to hide or show this component by Boolean.

Available since: 1.1.0

Parameters

visible :  Boolean

true to show, false to hide.

Returns

:Ext.Component

this

setX ( x ) : Ext.util.Positionable

Sets the X position of the DOM element based on page coordinates.

Parameters

x :  Number

The X position

Returns

:Ext.util.Positionable

this

setXY ( pos ) : Ext.util.Positionable

Sets the position of the DOM element in page coordinates.

Parameters

pos :  Number[]

Contains X & Y [x, y] values for new position (coordinates are page-based)

Returns

:Ext.util.Positionable

this

setY ( y ) : Ext.util.Positionable

Sets the Y position of the DOM element based on page coordinates.

Parameters

y :  Number

The Y position

Returns

:Ext.util.Positionable

this

setZIndex ( index )
private pri

z-index is managed by the zIndexManager and may be overwritten at any time. Returns the next z-index to be used.

If this is a Container, then it will have rebased any managed floating Components, and so the next available z-index will be approximately 10000 above that.

Parameters

index :  Object

setupFramingTpl ( frameTpl )
private pri

Inject a reference to the function which applies the render template into the framing template. The framing template wraps the content.

Parameters

frameTpl :  Object

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

Shows this Component, rendering it first if autoRender or cfg-floating are true.

After being shown, a cfg-floating Component (such as a Ext.window.Window), is activated it and brought to the front of its z-index stack.

Parameters

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

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

Defaults to: null

callback :  Function (optional)

A callback function to call after the Component is displayed. Only necessary if animation was specified.

scope :  Object (optional)

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

Returns

:Ext.Component

this

showAt ( x, [y], [animate] ) : Ext.Component

Displays component at specific xy position. A floating component (like a menu) is positioned relative to its ownerCt if any. Useful for popping up a context menu:

listeners: {
    itemcontextmenu: function(view, record, item, index, event, options) {
        Ext.create('Ext.menu.Menu', {
            width: 100,
            height: 100,
            margin: '0 0 10 0',
            items: [{
                text: 'regular item 1'
            },{
                text: 'regular item 2'
            },{
                text: 'regular item 3'
            }]
        }).showAt(event.getXY());
    }
}

Parameters

x :  Number/Number[]

The new x position or array of [x,y].

y :  Number (optional)

The new y position

animate :  Boolean/Object (optional)

True to animate the Component into its new position. You may also pass an animation configuration.

Returns

:Ext.Component

this

showBy ( component, [position], [offset] ) : Ext.Component
chainable ch

Shows this component by the specified Ext.Component or Ext.dom.Element. Used when this component is cfg-floating.

Parameters

component :  Ext.Component/Ext.dom.Element

The Ext.Component or Ext.dom.Element to show the component by.

position :  String (optional)

Alignment position as used by Ext.util.Positionable#getAlignToXY. Defaults to defaultAlign. See alignTo for possible values.

offset :  Number[] (optional)

Alignment offsets as used by Ext.util.Positionable#getAlignToXY. See alignTo for possible values.

Returns

:Ext.Component

this

statics Ext.Class
protected pro

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

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

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

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

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

        statics.totalCreated++;
    },

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

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

        return cloned;
    }
});


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

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

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

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

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

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

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

Returns

:Ext.Class

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

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

Parameters

suppressEvent :  Object

Returns

:Ext.dom.Element

The Element

stopFx Ext.dom.Element
deprecated dep

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

Returns

:Ext.dom.Element

The Element

Deprecated since version 4.0
Replaced by stopAnimation

suspendEvent ( eventName )

Suspends firing of the named event(s).

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

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

Parameters

eventName :  String...

Multiple event names to suspend.

suspendEvents ( queueSuspended )

Suspends the firing of all events. (see resumeEvents)

Parameters

queueSuspended :  Boolean

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

syncFx Object
chainable ch

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

Returns

:Object

this

syncHidden
private pri

synchronizes the hidden state of this component with the state of its hierarchy

toBack Ext.Component
chainable ch

Sends this Component to the back of (lower z-index than) any other visible windows

Returns

:Ext.Component

this

toFront ( [preventFocus] ) : Ext.Component
chainable ch

Brings this floating Component to the front of any other visible, floating Components managed by the same Ext.ZIndexManager

If this Component is modal, inserts the modal mask just below this Component in the z-index stack.

Parameters

preventFocus :  Boolean (optional)

Specify true to prevent the Component from being focused.

Defaults to: false

Returns

:Ext.Component

this

toggleCls ( className, [state] ) : Ext.Component
chainable ch

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

Parameters

className :  String

The CSS class to toggle.

state :  Boolean (optional)

If specified as true, causes the class to be added. If specified as false, causes the class to be removed.

Returns

:Ext.Component

Returns the Component to allow method chaining.

toggleInvalidCls ( hasError )
private pri

Parameters

hasError :  Object

toggleSelectionByListItemNode ( itemEl, keepExisting )

Toggle of labeled item selection by node reference

Parameters

itemEl :  Object

keepExisting :  Object

transformRawValue ( value ) : Object
protected pro

Transform the raw value before it is set

Parameters

value :  Object

The value

Returns

:Object

The value to set

translatePoints ( x, [y] ) : Object

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

Parameters

x :  Number/Array

The page x or an array containing [x, y]

y :  Number (optional)

The page y, required if x is not an array

Returns

:Object

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

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

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

Parameters

x :  Number/Array

The page x or an array containing [x, y]

y :  Number (optional)

The page y, required if x is not an array

Returns

:Object

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

trimLabelSeparator String

Returns the trimmed label by slicing off the label separator character. Can be overridden.

Returns

:String

The trimmed field label, or empty string if not defined

un ( eventName, fn, [scope] ) :

Shorthand for removeListener. Removes an event handler.

Parameters

eventName :  String

The type of event the handler was associated with.

fn :  Function

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

scope :  Object (optional)

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

Convenience Syntax

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

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

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

Exception - DOM event handlers using the element config option

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

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

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

Returns

:

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

Removes a before-event handler.

Same as removeListener with order set to 'after'.

Parameters

eventName :  String/String[]/Object

The name of the event the handler was associated with.

fn :  Function/String

The handler to remove.

scope :  Object (optional)

The scope originally specified for fn.

options :  Object (optional)

Extra options object.

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

Removes a before-event handler.

Same as removeListener with order set to 'before'.

Parameters

eventName :  String/String[]/Object

The name of the event the handler was associated with.

fn :  Function/String

The handler to remove.

scope :  Object (optional)

The scope originally specified for fn.

options :  Object (optional)

Extra options object.

unbindStoreListeners ( store )
protected pro

Unbinds listeners from this component to the store. By default it will remove anything bound by the bindStoreListeners method, however it can be overridden in a subclass to provide any more complicated handling.

Parameters

store :  Ext.data.AbstractStore

The store to unbind from

unmask

Removes the mask applied by mask

unsetActiveError

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.

up ( [selector], [limit] ) : Ext.container.Container

Navigates up the ownership hierarchy searching for an ancestor Container which matches any passed selector or component.

Important. There is not a universal upwards navigation pointer. There are several upwards relationships such as the Ext.button.Button which activates a menu, or the Ext.menu.Item which activated a submenu, or the Ext.grid.column.Column which activated the column menu.

These differences are abstracted away by this method.

Example:

var owningTabPanel = grid.up('tabpanel');

Parameters

selector :  String/Ext.Component (optional)

The selector component or actual component to test. If not passed the immediate owner/activator is returned.

limit :  String/Number/Ext.Component (optional)

This may be a selector upon which to stop the upward scan, or a limit of the number of steps, or Component reference to stop on.

Returns

:Ext.container.Container

The matching ancestor Container (or undefined if no match was found).

update ( htmlOrData, [loadScripts], [callback], [scriptScope] )

Update the content area of a component.

Available since: 3.4.0

Parameters

htmlOrData :  String/Object

If this component has been configured with a template via the tpl config then it will use this argument as data to populate the template. If this component was not configured with a template, the components content area will be updated via Ext.Element update.

loadScripts :  Boolean (optional)

Only legitimate when using the html configuration. Causes embedded script tags to be executed. Inline source will be executed with this Component as the scope (this reference).

Defaults to: false

callback :  Function (optional)

Only legitimate when using the html configuration. Callback to execute when scripts have finished loading.

scriptScope :  Object (optional)

The scope (this reference) in which to execute inline script elements content. Scripts with a src attribute cannot be executed with this scope.

Defaults to: `this`

updateBox ( box ) : Ext.Component
chainable ch

Sets the current box measurements of the component's underlying element.

Parameters

box :  Object

An object in the format {x, y, width, height}

Returns

:Ext.Component

this

updateFrame
private pri

Updates the frame elements to match new framing. The current frameBody is preserved by transplanting it into the new frame. All other frame childEls are destroyed and recreated if needed by the new frame. This method cannot transition from framed to non-framed or vise-versa or between table and div based framing.

updateLayout ( [options] )

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.

Parameters

options :  Object (optional)

An object with layout options.

defer :  Boolean

true if this layout should be deferred.

isRoot :  Boolean

true if this layout should be the root of the layout.

updateSession ( session )
private pri

Updates the session config.

Parameters

session :  Ext.data.Session

updateValue
private pri

Internal setting of value when records are added to the valueCollection setValue itself adds to the valueCollection.

updateViewModel ( viewModel, oldViewModel )
private pri

Updates the viewModel config.

Parameters

viewModel :  Ext.app.ViewModel

oldViewModel :  Ext.app.ViewModel

validate Boolean

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.

Returns

:Boolean

True if the value is valid, else false

validateValue ( value ) : Boolean

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.

Parameters

value :  Object

The value to validate

Returns

:Boolean

True if all validations passed, false if one or more failed

valueToRaw ( value ) : Object

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.

Parameters

value :  Object

The mixed-type value to convert to the raw representation.

Returns

:Object

The converted raw value.

Static Methods

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

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

Parameters

config :  Object

mixinClass :  Ext.Class (optional)

The mixin class if the configs are from a mixin.

addInheritableStatics ( members ) :
chainable ch static sta private pri

Parameters

members :  Object

Returns

:

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

Parameters

name :  Object

member :  Object

Returns

:

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

Add methods / properties to the prototype of this class.

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

 My.awesome.Cat.addMembers({
     meow: function() {
        alert('Meowww...');
     }
 });

 var kitty = new My.awesome.Cat();
 kitty.meow();

Parameters

members :  Object

The members to add to this class.

isStatic :  Boolean (optional)

Pass true if the members are static.

Defaults to: false

privacy :  Boolean (optional)

Pass true if the members are private. This only has meaning in debug mode and only for methods.

Defaults to: false

Returns

:

addStatics ( members ) : Ext.Base
chainable ch static sta

Add / override static properties of this class.

Ext.define('My.cool.Class', {
    ...
});

My.cool.Class.addStatics({
    someProperty: 'someValue',      // My.cool.Class.someProperty = 'someValue'
    method1: function() { ... },    // My.cool.Class.method1 = function() { ... };
    method2: function() { ... }     // My.cool.Class.method2 = function() { ... };
});

Parameters

members :  Object

Returns

:Ext.Base

this

borrow ( fromClass, members ) : Ext.Base
static sta private pri

Borrow another class' members to the prototype of this class.

Ext.define('Bank', {
    money: '$$$',
    printMoney: function() {
        alert('$$$$$$$');
    }
});

Ext.define('Thief', {
    ...
});

Thief.borrow(Bank, ['money', 'printMoney']);

var steve = new Thief();

alert(steve.money); // alerts '$$$'
steve.printMoney(); // alerts '$$$$$$$'

Parameters

fromClass :  Ext.Base

The class to borrow members from

members :  Array/String

The names of the members to borrow

Returns

:Ext.Base

this

callParent ( args )
static sta protected pro

Parameters

args :  Object

callSuper ( args )
static sta protected pro

Parameters

args :  Object

create Object
static sta

Create a new instance of this Class.

Ext.define('My.cool.Class', {
    ...
});

My.cool.Class.create({
    someConfig: true
});

All parameters are passed to the constructor of the class.

Returns

:Object

the created instance.

createAlias ( alias, origin )
static sta

Create aliases for existing prototype methods. Example:

Ext.define('My.cool.Class', {
    method1: function() { ... },
    method2: function() { ... }
});

var test = new My.cool.Class();

My.cool.Class.createAlias({
    method3: 'method1',
    method4: 'method2'
});

test.method3(); // test.method1()

My.cool.Class.createAlias('method5', 'method3');

test.method5(); // test.method3() -> test.method1()

Parameters

alias :  String/Object

The new method name, or an object to set multiple aliases. See flexSetter

origin :  String/Object

The original method name

extend ( parentClass )
static sta private pri

Parameters

parentClass :  Object

getConfigurator Ext.Configurator
static sta private pri

Returns the Ext.Configurator for this class.

Returns

:Ext.Configurator

getName String
static sta

Get the current class' name in string format.

Ext.define('My.cool.Class', {
    constructor: function() {
        alert(this.self.getName()); // alerts 'My.cool.Class'
    }
});

My.cool.Class.getName(); // 'My.cool.Class'

Returns

:String

className

mixin ( name, mixinClass ) :
chainable ch static sta private pri

Used internally by the mixins pre-processor

Parameters

name :  Object

mixinClass :  Object

Returns

:

onExtended ( fn, scope ) :
chainable ch static sta private pri

Parameters

fn :  Object

scope :  Object

Returns

:

override ( members ) : Ext.Base
chainable ch static sta

Override members of this class. Overridden methods can be invoked via Ext.Base#callParent.

Ext.define('My.Cat', {
    constructor: function() {
        alert("I'm a cat!");
    }
});

My.Cat.override({
    constructor: function() {
        alert("I'm going to be a cat!");

        this.callParent(arguments);

        alert("Meeeeoooowwww");
    }
});

var kitty = new My.Cat(); // alerts "I'm going to be a cat!"
                          // alerts "I'm a cat!"
                          // alerts "Meeeeoooowwww"

Direct use of this method should be rare. Use Ext.define instead:

Ext.define('My.CatOverride', {
    override: 'My.Cat',
    constructor: function() {
        alert("I'm going to be a cat!");

        this.callParent(arguments);

        alert("Meeeeoooowwww");
    }
});

The above accomplishes the same result but can be managed by the Ext.Loader which can properly order the override and its target class and the build process can determine whether the override is needed based on the required state of the target class (My.Cat).

Parameters

members :  Object

The properties to add to this class. This should be specified as an object literal containing one or more properties.

Returns

:Ext.Base

this class

triggerExtended
static sta private pri

events

activate ( this, eOpts )

Fires after a Component has been visually activated.

Note This event is only fired if this Component is a child of a Ext.container.Container that uses Ext.layout.container.Card as it's layout or this Component is a floating Component.

Parameters

this :  Ext.Component

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

added ( this, container, pos, eOpts )

Fires after a Component had been added to a Container.

Available since: 3.4.0

Parameters

this :  Ext.Component

container :  Ext.container.Container

Parent Container

pos :  Number

position of Component

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

afterlayoutanimation ( this, eOpts )

This event first after a component's layout has been updated by a layout that included animation (e.g., a Ext.panel.Panel in an Ext.layout.container.Accordion layout).

Available since: 6.0.0

Parameters

this :  Ext.Component

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

afterrender ( this, eOpts )

Fires after the component rendering is finished.

The afterrender event is fired after this Component has been rendered, been post-processed by any afterRender method defined for the Component.

Available since: 3.4.0

Parameters

this :  Ext.Component

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

autosize ( this, height, eOpts )

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.

Parameters

this :  Ext.form.field.Tag

This field

height :  Number

The new field height

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

beforeactivate ( this, eOpts )

Fires before a Component has been visually activated. Returning false from an event listener can prevent the activate from occurring.

Note This event is only fired if this Component is a child of a Ext.container.Container that uses Ext.layout.container.Card as it's layout.

Parameters

this :  Ext.Component

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

beforedeactivate ( this, eOpts )

Fires before a Component has been visually deactivated. Returning false from an event listener can prevent the deactivate from occurring.

Note This event is only fired if this Component is a child of a Ext.container.Container that uses Ext.layout.container.Card as it's layout.

Parameters

this :  Ext.Component

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

beforedeselect ( combo, record, index, eOpts )

Fires before the deselected item is removed from the collection

Parameters

combo :  Ext.form.field.ComboBox

This combo box

record :  Ext.data.Model

The deselected record

index :  Number

The index of the deselected record

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

beforedestroy ( this, eOpts )

Fires before the component is destroyed.

Note: This event should not be used to try to veto the destruction sequence by returning false, even though this is often permitted in other "before" events. Doing so will have unpredictable side-effects and can result in partially destroyed objects. Instead look to other events like beforeclose that occur prior to the call to the destroy method.

Available since: 1.1.0

Parameters

this :  Ext.Component

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

beforehide ( this, eOpts )

Fires before the component is hidden when calling the hide method. Return false from an event handler to stop the hide.

Available since: 1.1.0

Parameters

this :  Ext.Component

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

beforequery ( queryPlan, eOpts )

Fires before all queries are processed. Return false to cancel the query or set the queryPlan's cancel property to true.

Parameters

queryPlan :  Object

An object containing details about the query to be executed.

combo :  Ext.form.field.ComboBox

A reference to this ComboBox.

query :  String

The query value to be used to match against the ComboBox's valueField.

forceAll :  Boolean

If true, causes the query to be executed even if the minChars threshold is not met.

cancel :  Boolean

A boolean value which, if set to true upon return, causes the query not to be executed.

rawQuery :  Boolean

If true indicates that the raw input field value is being used, and upon store load,

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

beforerender ( this, eOpts )

Fires before the component is rendered. Return false from an event handler to stop the method-render.

Available since: 1.1.0

Parameters

this :  Ext.Component

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

beforeselect ( combo, record, index, eOpts )

Fires before the selected item is added to the collection

Parameters

combo :  Ext.form.field.ComboBox

This combo box

record :  Ext.data.Model

The selected record

index :  Number

The index of the selected record

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

beforeshow ( this, eOpts )

Fires before the component is shown when calling the show method. Return false from an event handler to stop the show.

Available since: 1.1.0

Parameters

this :  Ext.Component

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

beforestaterestore ( this, state, eOpts )

Fires before the state of the object is restored. Return false from an event handler to stop the restore.

Parameters

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.

beforestatesave ( this, state, eOpts )

Fires before the state of the object is saved to the configured state provider. Return false to stop the save.

Parameters

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.

blur ( this, event, eOpts )

Fires when this Component's focusEl loses focus.

Parameters

this :  Ext.Component

event :  Ext.event.Event

The blur event.

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

boxready ( this, width, height, eOpts )

Fires one time - after the component has been laid out for the first time at its initial size.

This event does not fire on components that use cfg-liquidLayout, such as Ext.button.Button and Ext.form.field.Base.

Parameters

this :  Ext.Component

width :  Number

The initial width.

height :  Number

The initial height.

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

change ( this, newValue, oldValue, eOpts )

Fires when the value of a field is changed. The value of a field is checked for changes when the field's setValue method is called and when any of the events listed in checkChangeEvents are fired.

Parameters

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.

collapse ( field, eOpts )

Fires when the field's picker is collapsed.

Parameters

field :  Ext.form.field.Picker

This field instance

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

deactivate ( this, eOpts )

Fires after a Component has been visually deactivated.

Note This event is only fired if this Component is a child of a Ext.container.Container that uses Ext.layout.container.Card as it's layout or this Component is a floating Component.

Parameters

this :  Ext.Component

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

destroy ( this, eOpts )

Fires after the component is method-destroyed.

Available since: 1.1.0

Parameters

this :  Ext.Component

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

dirtychange ( this, isDirty, eOpts )

Fires when a change in the field's isDirty state is detected.

Parameters

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.

disable ( this, eOpts )

Fires after the component is disabled.

Available since: 1.1.0

Parameters

this :  Ext.Component

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

enable ( this, eOpts )

Fires after the component is enabled.

Available since: 1.1.0

Parameters

this :  Ext.Component

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

errorchange ( this, error, eOpts )

Fires when the active error message is changed via setActiveError.

Parameters

this :  Ext.form.Labelable

error :  String

The active error message

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

expand ( field, eOpts )

Fires when the field's picker is expanded.

Parameters

field :  Ext.form.field.Picker

This field instance

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

focus ( this, event, eOpts )

Fires when this Component's focusEl receives focus.

Parameters

this :  Ext.Component/Ext.Widget

event :  Ext.event.Event

The focus event.

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

focusenter ( this, event, eOpts )

Fires when focus enters this Component's hierarchy.

Parameters

this :  Ext.Component

event :  Ext.event.Event

The focusenter event.

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

focusleave ( this, event, eOpts )

Fires when focus leaves this Component's hierarchy.

Parameters

this :  Ext.Component

event :  Ext.event.Event

The focusleave event.

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

hide ( this, eOpts )

Fires after the component is hidden. Fires after the component is hidden when calling the hide method.

Available since: 1.1.0

Parameters

this :  Ext.Component

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

keydown ( this, e, eOpts )

Keydown input field event. This event only fires if enableKeyEvents is set to true.

Parameters

this :  Ext.form.field.Text

This text field

e :  Ext.event.Event

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

keypress ( this, e, eOpts )

Keypress input field event. This event only fires if enableKeyEvents is set to true.

Parameters

this :  Ext.form.field.Text

This text field

e :  Ext.event.Event

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

keyup ( this, e, eOpts )

Keyup input field event. This event only fires if enableKeyEvents is set to true.

Parameters

this :  Ext.form.field.Text

This text field

e :  Ext.event.Event

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

move ( this, x, y, eOpts )

Fires after the component is moved.

Parameters

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.

removed ( this, ownerCt, eOpts )

Fires when a component is removed from an Ext.container.Container

Available since: 3.4.0

Parameters

this :  Ext.Component

ownerCt :  Ext.container.Container

Container which holds the component

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

render ( this, eOpts )

Fires after the component markup is rendered.

Available since: 1.1.0

Parameters

this :  Ext.Component

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

resize ( this, width, height, oldWidth, oldHeight, eOpts )

Fires after the component is resized. Note that this does not fire when the component is first laid out at its initial size. To hook that point in the life cycle, use the boxready event.

This event does not fire on components that use cfg-liquidLayout, such as Ext.button.Button and Ext.form.field.Base.

Parameters

this :  Ext.Component

width :  Number

The new width that was set.

height :  Number

The new height that was set.

oldWidth :  Number

The previous width.

oldHeight :  Number

The previous height.

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

select ( combo, record, eOpts )

Fires when at least one list item is selected.

Parameters

combo :  Ext.form.field.ComboBox

This combo box

record :  Ext.data.Model/Ext.data.Model[]

With multiSelect false, the value will be a single record. With multiSelect true, the value will be an array of records.

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

show ( this, eOpts )

Fires after the component is shown when calling the show method.

Available since: 1.1.0

Parameters

this :  Ext.Component

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

specialkey ( this, e, eOpts )

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();
                    }
                }
            }
        }
    ],
    ...
});

Parameters

this :  Ext.form.field.Base

e :  Ext.event.Event

The event object

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

staterestore ( this, state, eOpts )

Fires after the state of the object is restored.

Parameters

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.

statesave ( this, state, eOpts )

Fires after the state of the object is saved to the configured state provider.

Parameters

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.

validitychange ( this, isValid, eOpts )

Fires when a change in the field's validity is detected.

Parameters

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.

writeablechange ( this, Read, eOpts )

Fires when this field changes its read-only status.

Parameters

this :  Ext.form.field.Base

Read :  Boolean

only flag

eOpts : Object

The options object passed to Ext.util.Observable.addListener.

theme variables

$form-clear-trigger-glyph : String / list

The default glyph for for the "clear" trigger when Global_CSS#$enable-font-icons is true.

Defaults to:

$fa-var-times 16px $font-icon-font-family

$form-clear-trigger-glyph-color : color

The color of the "clear" trigger when Global_CSS#$enable-font-icons is true.

Defaults to:

$form-trigger-glyph-color

$form-error-icon-background-image : String

The background image for error icons

Defaults to:

'form/exclamation'

$form-error-icon-height : Number

Height for form error icons.

Defaults to:

16px

$form-error-icon-side-margin : Number / list

Margin for error icons that are aligned to the side of the field

Defaults to:

0 1px

$form-error-icon-width : Number

Width for form error icons.

Defaults to:

16px

$form-error-msg-color : color

The text color of form error messages

Defaults to:

$form-field-invalid-border-color

$form-error-msg-font-family : String

The font-family of form error messages

Defaults to:

$font-family

$form-error-msg-font-size : Number

The font-size of form error messages

Defaults to:

$font-size

$form-error-msg-font-weight : String

The font-weight of form error messages

Defaults to:

$font-weight

$form-error-msg-line-height : Number

The line-height of form error messages

Defaults to:

$form-error-icon-height

$form-error-under-icon-spacing : Number

The space between the icon and the message for errors that display under the field

Defaults to:

4px

$form-error-under-padding : Number / list

The padding on errors that display under the form field

Defaults to:

2px 2px 2px 0

$form-field-background-color : color

Background color for form fields.

Defaults to:

#fff

$form-field-background-image : String

Background image for form fields.

Defaults to:

'form/text-bg'

$form-field-border-color : color

Border color for form fields.

Defaults to:

$neutral-color

$form-field-border-style : String

Border style for form fields.

Defaults to:

solid

$form-field-border-width : Number

Border width for form fields.

Defaults to:

1px

$form-field-color : color

Text color for form fields.

Defaults to:

$color

$form-field-disabled-opacity : Number

Opacity of disabled form fields

Defaults to:

.3

$form-field-empty-color : color

Text color for empty form fields.

Defaults to:

gray

$form-field-focus-border-color : color

Border color for focused form fields.

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:

$base-color

$form-field-focus-border-style : String

Border style for focused form fields.

Defaults to:

$form-field-border-style

$form-field-focus-border-width : Number

Border width for focused form fields.

Defaults to:

$form-field-border-width

$form-field-font-family : String

Font family for form fields.

Defaults to:

$font-family

$form-field-font-size : Number

Font size for form fields.

Defaults to:

$font-size

$form-field-font-weight : String

Font weight for form fields.

Defaults to:

$font-weight

$form-field-height : Number

Height for form fields.

Defaults to:

24px

$form-field-invalid-background-color : color

Background color for invalid form fields.

Defaults to:

#fff

$form-field-invalid-background-image : String

Background image for invalid form fields.

Defaults to:

'grid/invalid_line'

$form-field-invalid-background-position : String / list

Background position for invalid form fields.

Defaults to:

bottom

$form-field-invalid-background-repeat : String

Background repeat for invalid form fields.

Defaults to:

repeat-x

$form-field-invalid-border-color : color

Border color for invalid form fields.

Defaults to:

#c30

$form-field-padding : Number

Padding around form fields.

Defaults to:

1px 3px 2px

$form-file-field-color : color

Text color for file fields

Defaults to:

$form-field-empty-color

$form-item-margin-bottom : Number

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

$form-label-font-color : color

The text color of form field labels

Defaults to:

$color

$form-label-font-family : String

The font-family of form field labels

Defaults to:

$font-family

$form-label-font-size : Number

The font-size of form field labels

Defaults to:

$font-size

$form-label-font-weight : String

The font-weight of form field labels

Defaults to:

$font-weight

$form-label-horizontal-spacing : Number

Horizontal space between the label and the field body when the label is left-aligned.

Defaults to:

5px

$form-label-line-height : Number

The line-height of form field labels

Defaults to:

round($form-label-font-size * 1.15)

$form-label-vertical-spacing : Number

Vertical space between the label and the field body when the label is top-aligned.

Defaults to:

5px

$form-search-trigger-glyph : String / list

The default glyph for for the "search" trigger when Global_CSS#$enable-font-icons is true.

Defaults to:

$fa-var-search 16px $font-icon-font-family

$form-search-trigger-glyph-color : color

The color of the "search" trigger when Global_CSS#$enable-font-icons is true.

Defaults to:

$form-trigger-glyph-color

$form-text-field-background-color : color

The background color of the text field's input element

Defaults to:

$form-field-background-color

$form-text-field-background-image : String

The background image of the text field's input element

Defaults to:

$form-field-background-image

$form-text-field-body-width : Number

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

$form-text-field-border-color : color / list

The border color of text fields

Defaults to:

$form-field-border-color

$form-text-field-border-radius : Number / list

Border radius for text fields

Defaults to:

0

$form-text-field-border-style : String / list

The border style of text fields

Defaults to:

$form-field-border-style

$form-text-field-border-width : Number / list

The border width of text fields

Defaults to:

$form-field-border-width

$form-text-field-classic-border : Boolean

true to use classic-theme styled border for text fields.

Defaults to:

false

$form-text-field-color : color

The color of the text field's input element

Defaults to:

$form-field-color

$form-text-field-empty-color : color

Text color for empty text fields.

Defaults to:

$form-field-empty-color

$form-text-field-focus-border-color : color / list

The border color of the focused text field

Defaults to:

$form-field-focus-border-color

$form-text-field-font-family : String

Font family for text fields.

Defaults to:

$form-field-font-family

$form-text-field-font-size : Number

Font size for text fields.

Defaults to:

$form-field-font-size

$form-text-field-font-weight : String

Font weight for text fields.

Defaults to:

$form-field-font-weight

$form-text-field-height : Number

The height of text fields

Defaults to:

$form-field-height

$form-text-field-invalid-background-color : color

Background color of the text field's input element when the field value is invalid.

Defaults to:

$form-field-invalid-background-color

$form-text-field-invalid-background-image : String

Background image of the text field's input element when the field value is invalid.

Defaults to:

$form-field-invalid-background-image

$form-text-field-invalid-background-position : String / list

Background position of the text field's input element when the field value is invalid.

Defaults to:

$form-field-invalid-background-position

$form-text-field-invalid-background-repeat : String

Background repeat of the text field's input element when the field value is invalid.

Defaults to:

$form-field-invalid-background-repeat

$form-text-field-invalid-border-color : color

Border color for invalid text fields.

Defaults to:

$form-field-invalid-border-color

$form-text-field-padding : Number / list

The padding of the text field's input element

Defaults to:

$form-field-padding

$form-textarea-body-height : Number

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.

$form-textarea-line-height : Number

The line-height to use for the TextArea's text

$form-toolbar-error-icon-background-image : String

The background image for toolbar field error icons

Defaults to:

'form/exclamation'

$form-toolbar-error-icon-height : Number

Height for toolbar field error icons.

Defaults to:

16px

$form-toolbar-error-icon-side-margin : Number / list

Margin for toolbar field error icons that are aligned to the side of the field

Defaults to:

0 1px

$form-toolbar-error-icon-width : Number

Width for toolbar field error icons.

Defaults to:

16px

$form-toolbar-error-msg-color : color

The text color of toolbar form error messages

Defaults to:

$form-field-invalid-border-color

$form-toolbar-error-msg-font-family : String

The font-family of toolbar form field error messages

Defaults to:

$font-family

$form-toolbar-error-msg-font-size : Number

The font-size of toolbar form field error messages

Defaults to:

$font-size

$form-toolbar-error-msg-font-weight : String

The font-weight of toolbar form field error messages

Defaults to:

$font-weight

$form-toolbar-error-msg-line-height : Number

The line-height of toolbar form field error messages

Defaults to:

$form-toolbar-error-icon-height

$form-toolbar-error-under-icon-spacing : Number

The space between the icon and the message for errors that display under a toolbar field

Defaults to:

4px

$form-toolbar-error-under-padding : Number / list

The padding on errors that display under the toolbar form field

Defaults to:

2px 2px 2px 0

$form-toolbar-field-disabled-opacity : Number

Opacity of disabled toolbar form fields

Defaults to:

.3

$form-toolbar-field-font-family : String

Font family for toolbar form fields.

Defaults to:

$form-field-font-family

$form-toolbar-field-font-size : Number

Font size for toolbar form fields.

Defaults to:

$form-field-font-size

$form-toolbar-field-font-weight : String

Font weight for toolbar form fields.

Defaults to:

$form-field-font-weight

$form-toolbar-field-height : Number

Height for form fields in toolbar.

Defaults to:

$form-field-height

$form-toolbar-file-field-color : color

Text color for toolbar file fields

Defaults to:

$form-file-field-color

$form-toolbar-label-font-color : color

The text color of toolbar form field labels

Defaults to:

$color

$form-toolbar-label-font-family : String

The font-family of toolbar form field labels

Defaults to:

$font-family

$form-toolbar-label-font-size : Number

The font-size of toolbar form field labels

Defaults to:

$font-size

$form-toolbar-label-font-weight : String

The font-weight of toolbar form field labels

Defaults to:

$font-weight

$form-toolbar-label-horizontal-spacing : Number

Horizontal space between the toolbar field's label and the field body when the label is left-aligned.

Defaults to:

5px

$form-toolbar-label-line-height : Number

The line-height of toolbar form field labels

Defaults to:

round($form-toolbar-label-font-size * 1.15)

$form-toolbar-label-vertical-spacing : Number

Vertical space between the toolbar field's label and the field body when the label is top-aligned.

Defaults to:

5px

$form-toolbar-tag-field-item-margin : Number / list

The padding for toolbar tag fields

Defaults to:

$tag-field-item-margin

$form-toolbar-tag-field-padding : Number / list

The margin for toolbar tag field items

Defaults to:

$tag-field-padding

$form-toolbar-text-field-background-color : color

The background color of the toolbar text field's input element

Defaults to:

$form-text-field-background-color

$form-toolbar-text-field-background-image : String

The background image of the toolbar text field's input element

Defaults to:

$form-text-field-background-image

$form-toolbar-text-field-body-width : Number

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

$form-toolbar-text-field-border-color : color / list

The border color of toolbar text fields

Defaults to:

$form-text-field-border-color

$form-toolbar-text-field-border-radius : Number / list

Border radius for toolbar text fields

Defaults to:

$form-text-field-border-radius

$form-toolbar-text-field-border-style : String / list

The border style of toolbar text fields

Defaults to:

$form-text-field-border-style

$form-toolbar-text-field-border-width : Number / list

The border width of toolbar text fields

Defaults to:

$form-text-field-border-width

$form-toolbar-text-field-classic-border : Boolean

true to use classic-theme styled border for toolbar text fields.

Defaults to:

$form-text-field-classic-border

$form-toolbar-text-field-color : color

The color of the toolbar text field's input element

Defaults to:

$form-text-field-color

$form-toolbar-text-field-empty-color : color

Text color for empty toolbar text fields.

Defaults to:

$form-text-field-empty-color

$form-toolbar-text-field-focus-border-color : color / list

The border color of the focused toolbar text field

Defaults to:

$form-text-field-focus-border-color

$form-toolbar-text-field-font-family : String

Font family for toolbar text fields.

Defaults to:

$form-text-field-font-family

$form-toolbar-text-field-font-size : Number

Font size for toolbar text fields.

Defaults to:

$form-text-field-font-size

$form-toolbar-text-field-font-weight : String

Font weight for toolbar text fields.

Defaults to:

$form-text-field-font-weight

$form-toolbar-text-field-height : Number

The height of toolbar text fields

Defaults to:

$form-toolbar-field-height

$form-toolbar-text-field-invalid-background-color : color

Background color of the toolbar text field's input element when the field value is invalid.

Defaults to:

$form-text-field-invalid-background-color

$form-toolbar-text-field-invalid-background-image : String

Background image of the toolbar text field's input element when the field value is invalid.

Defaults to:

$form-text-field-invalid-background-image

$form-toolbar-text-field-invalid-background-position : String / list

Background position of the toolbar text field's input element when the field value is invalid.

Defaults to:

$form-text-field-invalid-background-position

$form-toolbar-text-field-invalid-background-repeat : String

Background repeat of the toolbar text field's input element when the field value is invalid.

Defaults to:

$form-text-field-invalid-background-repeat

$form-toolbar-text-field-invalid-border-color : color

Border color for invalid toolbar text fields.

Defaults to:

$form-text-field-invalid-border-color

$form-toolbar-text-field-padding : Number / list

The padding of the toolbar text field's input element

Defaults to:

$form-text-field-padding

$form-toolbar-textarea-body-height : Number

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

$form-toolbar-textarea-line-height : Number / String

The line-height to use for the toolbar TextArea's text

Defaults to:

$form-textarea-line-height

$form-toolbar-trigger-background-color : color

The background color of the toolbar text field's trigger element

Defaults to:

$form-text-field-background-color

$form-toolbar-trigger-background-image : String

The default background image for toolbar text field triggers

Defaults to:

$form-trigger-background-image

$form-toolbar-trigger-border-color : color / list

The color of the toolbar text field's trigger's border

Defaults to:

$form-trigger-border-color

$form-toolbar-trigger-border-color-focus : color

The color of the toolbar text field's trigger's border when the field is focused

Defaults to:

$form-trigger-border-color-focus

$form-toolbar-trigger-border-color-over : color

The color of the toolbar text field's trigger's border when hovered

Defaults to:

$form-trigger-border-color

$form-toolbar-trigger-border-color-pressed : 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

$form-toolbar-trigger-border-style : String / list

The style of the toolbar text field's trigger's border

Defaults to:

$form-trigger-border-style

$form-toolbar-trigger-border-width : Number / list

The width of the toolbar text field's trigger's border

Defaults to:

$form-trigger-border-width

$form-toolbar-trigger-glyph : String / list

The default glyph for for toolbar text field triggers when Global_CSS#$enable-font-icons is true.

Defaults to:

$form-trigger-glyph

$form-toolbar-trigger-glyph-color : color

The color of toolbar text field triggers when Global_CSS#$enable-font-icons is true.

Defaults to:

$form-trigger-glyph-color

$form-toolbar-trigger-width : Number

The width of the toolbar text field's trigger element

Defaults to:

$form-trigger-width

$form-trigger-background-color : color

The background color of the text field's trigger element

Defaults to:

$form-field-background-color

$form-trigger-background-image : String

The default background image for text field triggers

Defaults to:

'form/trigger'

$form-trigger-border-color : color / list

The color of the text field's trigger's border

Defaults to:

$form-field-border-color

$form-trigger-border-color-focus : color

The color of the text field's trigger's border when the field is focused

Defaults to:

$form-field-focus-border-color

$form-trigger-border-color-over : color

The color of the text field's trigger's border when hovered

Defaults to:

$form-field-border-color

$form-trigger-border-color-pressed : 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

$form-trigger-border-style : String / list

The style of the text field's trigger's border

Defaults to:

$form-field-border-style

$form-trigger-border-width : Number / list

The width of the text field's trigger's border

Defaults to:

0

$form-trigger-glyph : String / list

The default glyph for for text field triggers when Global_CSS#$enable-font-icons is true.

Defaults to:

$fa-var-caret-down 16px $font-icon-font-family

$form-trigger-glyph-color : color

The color of text field triggers when Global_CSS#$enable-font-icons is true.

Defaults to:

$form-text-field-color

$form-trigger-width : Number

The width of the text field's trigger element

Defaults to:

22px

$grid-cell-field-color : Number

The color of the grid field text

Defaults to:

$grid-row-cell-color

$grid-cell-field-font-family : String

The font-family of the grid field text

Defaults to:

$grid-row-cell-font-family

$grid-cell-field-font-size : Number

The font size of the grid field text

Defaults to:

$grid-row-cell-font-size

$grid-cell-field-font-weight : String

The font-weight of the grid field text

Defaults to:

$grid-row-cell-font-weight

$grid-cell-field-height : Number

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)

$grid-cell-field-padding : Number / list

The padding of grid fields.

$grid-cell-field-trigger-background-color : color

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

$grid-cell-field-trigger-background-image : String

The default background image for text field triggers when rendered in the context of a grid cell

Defaults to:

$form-trigger-background-image

$grid-cell-field-trigger-border-color : color / list

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

$grid-cell-field-trigger-border-color-focus : 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

$grid-cell-field-trigger-border-color-over : color

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

$grid-cell-field-trigger-border-color-pressed : 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

$grid-cell-field-trigger-border-style : String / list

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

$grid-cell-field-trigger-border-width : Number / list

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

$grid-cell-field-trigger-width : Number

The width of a text field's trigger element when rendered in the context of a grid cell

Defaults to:

$form-trigger-width

$grid-cell-file-field-color : color

Text color for file fields rendered in the context of a grid cell

Defaults to:

$form-file-field-color

$grid-cell-tag-field-item-margin : Number / list

The margin of a tag field's items when rendered in the context of a grid cell

Defaults to:

$tag-field-item-margin

$grid-cell-tag-field-padding : Number / list

The padding of a tag field's input element when rendered in the context of a grid cell

Defaults to:

$tag-field-padding

$grid-cell-text-field-background-color : color

The background color of a text field's input element when rendered in the context of a grid cell

Defaults to:

$form-text-field-background-color

$grid-cell-text-field-background-image : String

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

$grid-cell-text-field-body-width : Number
private pri

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

$grid-cell-text-field-border-color : color / list

The border color of text fields rendered in the context of a grid cell

Defaults to:

$form-text-field-border-color

$grid-cell-text-field-border-radius : Number / list

Border radius for text fields rendered in the context of a grid cell.

Defaults to:

$form-text-field-border-radius

$grid-cell-text-field-border-style : String / list

The border style of text fields rendered in the context of a grid cell

Defaults to:

$form-text-field-border-style

$grid-cell-text-field-border-width : Number / list

The border width of text fields rendered in the context of a grid cell

Defaults to:

$form-text-field-border-width

$grid-cell-text-field-classic-border : Boolean

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

$grid-cell-text-field-color : color

The color of a text field's input element when rendered in the context of a grid cell

Defaults to:

$grid-cell-field-color

$grid-cell-text-field-empty-color : color

Text color for empty text fields rendered in the context of a grid cell.

Defaults to:

$form-text-field-empty-color

$grid-cell-text-field-focus-border-color : color / list

The border color of the focused text fields rendered in the context of a grid cell

Defaults to:

$form-text-field-focus-border-color

$grid-cell-text-field-font-family : String

Font family for text fields rendered in the context of a grid cell.

Defaults to:

$grid-cell-field-font-family

$grid-cell-text-field-font-size : Number

Font size for text fields rendered in the context of a grid cell.

Defaults to:

$grid-cell-field-font-size

$grid-cell-text-field-font-weight : String

Font weight for text fields rendered in the context of a grid cell.

Defaults to:

$grid-cell-field-font-weight

$grid-cell-text-field-height : Number

The height of text fields rendered in the context of a grid cell

Defaults to:

$grid-cell-field-height

$grid-cell-text-field-invalid-background-color : color

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

$grid-cell-text-field-invalid-background-image : String

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

$grid-cell-text-field-invalid-background-position : String / list

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

$grid-cell-text-field-invalid-background-repeat : String

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

$grid-cell-text-field-invalid-border-color : color

Border color for invalid text fields rendered in the context of a grid cell.

Defaults to:

$form-text-field-invalid-border-color

$grid-cell-text-field-padding : Number / list

The padding of a text field's input element when rendered in the context of a grid cell

Defaults to:

$grid-cell-field-padding

$grid-cell-textarea-body-height : Number

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

$grid-cell-textarea-line-height : Number / String

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

$include-field-default-ui : Boolean

True to include the "default" field UI

Defaults to:

$include-default-uis

$include-field-toolbar-ui : Boolean

True to include the "toolbar" field UI

Defaults to:

false

$include-grid-cell-field-ui : Boolean

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 (Ext.grid.plugin.CellEditing or Ext.grid.plugin.RowEditing) are being used, or if a Ext.grid.column.Widget is being used to house an input field.

Defaults to:

false

$include-label-default-ui : Boolean

True to include the "default" label UI

Defaults to:

$include-field-default-ui

$include-label-toolbar-ui : Boolean

True to include the "default" label UI

Defaults to:

$include-field-toolbar-ui

$include-tag-field-default-ui : Boolean

True to include the "default" tag field UI

Defaults to:

$include-text-field-default-ui

$include-tag-field-grid-ui : Boolean

True to include the "grid-cell" tag field UI

Defaults to:

$include-grid-cell-field-ui

$include-tag-field-toolbar-ui : Boolean

True to include the "toolbar" tag field UI

Defaults to:

$include-field-toolbar-ui

$include-text-field-default-ui : Boolean

True to include the "default" text field UI

Defaults to:

$include-field-default-ui

$include-text-field-grid-ui : Boolean

True to include the "grid-cell" text field UI

Defaults to:

$include-grid-cell-field-ui

$include-text-field-toolbar-ui : Boolean

True to include the "toolbar" text field UI

Defaults to:

$include-field-toolbar-ui

$tag-field-item-background-color : color

The background-color of tag field items

Defaults to:

mix(#fff, $neutral-color, 15%)

$tag-field-item-border-color : color

The border-color of tag field items

Defaults to:

$tag-field-item-background-color

$tag-field-item-border-radius : Number / list

The border-radius of tag field items

Defaults to:

3px

$tag-field-item-border-style : color

The border-style of tag field items

Defaults to:

solid

$tag-field-item-border-width : color

The border-width of tag field items

Defaults to:

1px

$tag-field-item-close-icon-glyph : String / list

Glyph for the "close" icon when Global_CSS#$enable-font-icons is true.

Defaults to:

$fa-var-close 16px $font-icon-font-family

$tag-field-item-close-icon-glyph-color : color

The color to use for the "close" icon of items in a tag field when Global_CSS#$enable-font-icons is true.

Defaults to:

$tag-field-item-color

$tag-field-item-close-icon-opacity : color

Opacity of the "close" icon

Defaults to:

null

$tag-field-item-close-icon-opacity-over : color

Opacity of the "close" icon when hovered

Defaults to:

$tag-field-item-close-icon-opacity

$tag-field-item-close-icon-opacity-pressed : color

Opacity of the "close" icon when pressed

Defaults to:

$tag-field-item-close-icon-opacity-over

$tag-field-item-close-icon-right : Number

Number of pixels to offset the close icon from the right of the item

Defaults to:

1px

$tag-field-item-close-icon-size : Number

The size of the close icon

Defaults to:

12px

$tag-field-item-close-icon-spacing : Number

Number of pixels of space between the tag field item text and close icon

Defaults to:

6px

$tag-field-item-close-icon-top : Number

Number of pixels to offset the close icon from the top of the item

Defaults to:

1px

$tag-field-item-color : color

The text color of tag field items

Defaults to:

$color

$tag-field-item-height : Number

The height of tag field items

Defaults to:

18px

$tag-field-item-margin : Number / list

The margin of tag field items

Defaults to:

0 4px 2px 0

$tag-field-item-over-background-color : color

The background-color of tag field items when hovered

Defaults to:

mix(#000, $tag-field-item-background-color, 5%)

$tag-field-item-over-border-color : color

The border-color of tag field items when hovered

Defaults to:

$tag-field-item-over-background-color

$tag-field-item-over-close-icon-glyph-color : color

The color to use for the "close" icon of hovered items in a tag field when Global_CSS#$enable-font-icons is true.

Defaults to:

$tag-field-item-over-color

$tag-field-item-over-color : color

The text color of tag field items when hovered

Defaults to:

$tag-field-item-color

$tag-field-item-padding : Number / list

The padding of tag field items

Defaults to:

0 5px

$tag-field-item-selected-background-color : color

The background-color of tag field items when selected

Defaults to:

$base-highlight-color

$tag-field-item-selected-border-color : color

The border-color of tag field items when selected

Defaults to:

$base-color

$tag-field-item-selected-close-icon-glyph-color : color

The color to use for the "close" icon of selected items in a tag field when Global_CSS#$enable-font-icons is true.

Defaults to:

$tag-field-item-selected-color

$tag-field-item-selected-color : color

The text color of tag field items when selected

Defaults to:

#fff

$tag-field-item-selected-over-close-icon-glyph-color : color

The color to use for the "close" icon of selected and hovered items in a tag field when Global_CSS#$enable-font-icons is true.

Defaults to:

$tag-field-item-selected-close-icon-glyph-color

$tag-field-padding : Number / list

Tag field padding

Defaults to:

2px 0 0 4px

theme mixins

extjs-label-ui ( ...list... )

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.

Parameters

$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 :  Number (optional)

Horizontal space between the label and the field body when the label is left-aligned.

Defaults to: $form-label-horizontal-spacing

$ui-vertical-spacing :  Number (optional)

Vertical space between the label and the field body when the label is top-aligned.

Defaults to: $form-label-vertical-spacing

$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

extjs-tag-field-ui ( ...list... )

Creates a visual theme for tag fields. Note this mixin only provides styling for the tag field's items, The label and error are styled by extjs-label-ui, and the field body is styled by text-field-ui

Parameters

$ui :  String

The name of the UI being created. Can not included spaces or special punctuation (used in CSS class names).

$ui-padding :  Number/list (optional)

Tag field padding

Defaults to: $tag-field-padding

$ui-item-height :  Number (optional)

The height of tag field items

Defaults to: $tag-field-item-height

$ui-item-border-radius :  Number/list (optional)

The border-radius of tag field items

Defaults to: $tag-field-item-border-radius

$ui-item-color :  color (optional)

The text color of tag field items

Defaults to: $tag-field-item-color

$ui-item-over-color :  color (optional)

The text color of tag field items when hovered

Defaults to: $tag-field-item-over-color

$ui-item-selected-color :  color (optional)

The text color of tag field items when selected

Defaults to: $tag-field-item-selected-color

$ui-item-background-color :  color (optional)

The background-color of tag field items

Defaults to: $tag-field-item-background-color

$ui-item-over-background-color :  color (optional)

The background-color of tag field items when hovered

Defaults to: $tag-field-item-over-background-color

$ui-item-selected-background-color :  color (optional)

The background-color of tag field items when selected

Defaults to: $tag-field-item-selected-background-color

$ui-item-border-width :  color (optional)

The border-width of tag field items

Defaults to: $tag-field-item-border-width

$ui-item-border-style :  color (optional)

The border-style of tag field items

Defaults to: $tag-field-item-border-style

$ui-item-border-color :  color (optional)

The border-color of tag field items

Defaults to: $tag-field-item-border-color

$ui-item-over-border-color :  color (optional)

The border-color of tag field items when hovered

Defaults to: $tag-field-item-over-border-color

$ui-item-selected-border-color :  color (optional)

The border-color of tag field items when selected

Defaults to: $tag-field-item-selected-border-color

$ui-item-padding :  Number/list (optional)

The padding of tag field items

Defaults to: $tag-field-item-padding

$ui-item-margin :  Number/list (optional)

The margin of tag field items

Defaults to: $tag-field-item-margin

$ui-item-close-icon-size :  Number (optional)

The size of the close icon

Defaults to: $tag-field-item-close-icon-size

$ui-item-close-icon-top :  Number (optional)

Number of pixels to offset the close icon from the top of the item

Defaults to: $tag-field-item-close-icon-top

$ui-item-close-icon-right :  Number (optional)

Number of pixels to offset the close icon from the right of the item

Defaults to: $tag-field-item-close-icon-right

$ui-item-close-icon-spacing :  Number (optional)

Number of pixels of space between the tag field item text and close icon

Defaults to: $tag-field-item-close-icon-spacing

$ui-item-close-icon-glyph-color :  color (optional)

The color to use for the "close" icon of items in a tag field when Global_CSS#$enable-font-icons is true.

Defaults to: $tag-field-item-close-icon-glyph-color

$ui-item-selected-close-icon-glyph-color :  color (optional)

The color to use for the "close" icon of selected items in a tag field when Global_CSS#$enable-font-icons is true.

Defaults to: $tag-field-item-selected-close-icon-glyph-color

$ui-item-over-close-icon-glyph-color :  color (optional)

The color to use for the "close" icon of hovered items in a tag field when Global_CSS#$enable-font-icons is true.

Defaults to: $tag-field-item-over-close-icon-glyph-color

$ui-item-selected-over-close-icon-glyph-color :  color (optional)

The color to use for the "close" icon of selected and hovered items in a tag field when Global_CSS#$enable-font-icons is true.

Defaults to: $tag-field-item-selected-over-close-icon-glyph-color

$ui-item-close-icon-glyph :  String/list (optional)

Glyph for the "close" icon when Global_CSS#$enable-font-icons is true.

Defaults to: $tag-field-item-close-icon-glyph

$ui-item-close-icon-opacity :  color (optional)

Opacity of the "close" icon

Defaults to: $tag-field-item-close-icon-opacity

$ui-item-close-icon-opacity-over :  color (optional)

Opacity of the "close" icon when hovered

Defaults to: $tag-field-item-close-icon-opacity-over

$ui-item-close-icon-opacity-pressed :  color (optional)

Opacity of the "close" icon when pressed

Defaults to: $tag-field-item-close-icon-opacity-pressed

extjs-text-field-ui ( ...list... )

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.

Parameters

$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-trigger-glyph :  String/list (optional)

The default glyph for for text field triggers when Global_CSS#$enable-font-icons is true.

Defaults to: $form-trigger-glyph

$ui-trigger-glyph-color :  color (optional)

The color the trigger when Global_CSS#$enable-font-icons is true.

Defaults to: $form-trigger-glyph-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 6.5.0 - Classic Toolkit