actions : Object

bindable bind

An object containing properties which define named Ext.Action for this container and any descendant components.

An Action encapsulates a shareable, reusable set of properties which define a "clickable" UI component such as a Ext.button.Button or Ext.menu.Item, or panel header tool, or an Ext.grid.column.Action

An Action, or more conveniently, the name of an action prefixed with '@' may be used as a config object for creating child components which use a handler config property to reference a Controller method to invoke when the component is clicked.

The property name is the action name, which may then be used as a child item configuration in an items configuration in any descendant component such as a toolbar or a menu, or in a tools configuration of a Panel.

The property value is a configuration object for any clickable component.

See the Ext.Action class for an example of reusable Actions.

Defaults to:

null

Available since: 6.2.0

activeChildTabIndex : Number

DOM tabIndex attribute to set on the active Focusable child of this container when using the "Roaming tabindex" technique.

Defaults to:

0

activeItem : String / Number

bindable bind

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

Available since: 2.3.0

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

align : 'start' / 'center' / 'end'

bindable bind

Sets the alignment of the header and rendered columns. Possible values are: 'start', 'center', and 'end'.

Since 6.2.0, 'left' and 'right' will still work, but retain their meaning even when the application is in RTL mode.

'start' and 'end' always conform to the locale's text direction.

Defaults to:

'start'

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

allowFocusingDisabledChildren : Boolean

Set this to true to enable focusing disabled child items via keyboard.

Defaults to:

false

alwaysOnTop : Boolean / Number

bindable bind

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

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

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

Defaults to:

false

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

anchorSize : Number / Object

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

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

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

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.

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.

autoDestroy : Boolean

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

Defaults to:

true

Available since: 2.3.0

autoEl : String / Object

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

You do not normally need to specify this. For the base classes Ext.Component and Ext.container.Container, this defaults to 'div'. The more complex Sencha classes use a more complex DOM structure specified by their own 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

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

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

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:

Ext.baseCSSPrefix + 'container'

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

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.

bubbleEvents : String[]

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

Available since: 3.4.0

cellFocusable : Boolean

Configure as false to remove all cells in this column from navigation.

This is currently used by the PivotGrid package to create columns which have no semantic role, but are purely for visual indentation purposes.

Defaults to:

true

Available since: 6.2.0.

cellWrap : Boolean

True to allow whitespace in this column's cells to wrap, and cause taller column height where necessary.

This implicitly sets the variableRowHeight config to true

Defaults to:

false

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:

Ext.create('Ext.Component', {
    renderTo: Ext.getBody(),
    renderTpl: [
        '<h1 id="{id}-title" data-ref="title">{title}</h1>',
        '<p>{msg}</p>',
    ],
    renderData: {
        title: "Error",
        msg: "Something went wrong"
    },
    childEls: ["title"],
    listeners: {
        afterrender: function(cmp){
            // After rendering the component will have a title property
            cmp.title.setStyle({color: "red"});
        }
    }
});

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:

{}

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

columns : Object[]

An optional array of sub-column definitions. This column becomes a group, and houses the columns defined in the columns config.

Group columns may not be sortable. But they may be hideable and moveable. And you may move headers into and out of a group. Note that if all sub columns are dragged out of a group, the group is destroyed.

columnsText : String

The text for the columns submenu item.

Defaults to:

'Columns'

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'

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

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

dataIndex : String

The name of the field in the grid's Ext.data.Stores Ext.data.Model definition from which to draw the column's value. Required.

Defaults to:

null

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'

defaultFocus : String

Specifies a child Component to receive focus when this Container's method-focus method is called. Should be a valid Ext.ComponentQuery selector.

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

defaults : Object / Function

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

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

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

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

Usage:

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

Available since: 2.3.0

defaultType : String

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

Defaults to:

'panel'

Available since: 2.3.0

defaultWidth : Number

Width of the header if no width or flex is specified.

Defaults to:

100

detachOnRemove : Boolean

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

Defaults to:

true

dirtyText : String

This text will be announced by Assistive Technologies such as screen readers when a cell with changed ("dirty") value is focused.

Defaults to:

"Cell value has been edited"

disabled : Boolean

bindable bind

true to disable the component.

Defaults to:

false

Available since: 2.3.0

disabledCls : String

CSS class to add when the Component is disabled.

Defaults to:

Ext.baseCSSPrefix + 'item-disabled'

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

draggable : Boolean

False to disable drag-drop reordering of this column.

Defaults to:

true

editor : Object / String

bindable bind

An optional xtype or config object for a Ext.form.field.Field to use for editing. Only applicable if the grid is using an Ext.grid.plugin.Editing plugin.

Note: The Ext.form.field.HtmlEditor field is not a supported editor field type.

editRenderer : Function / String

A renderer to be used in conjunction with Ext.grid.plugin.RowEditing. This renderer is used to display a custom value for non-editable fields.

Note: The editRenderer is called when the roweditor is initially shown. Changes to the record during editing will not call editRenderer.

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

Ext.create('Ext.grid.Panel', {
    title: 'Land Of Ooo',
    store: store,
    columns: [{
        text: 'Name',
        dataIndex: 'name',
        editRenderer: function(value){
            return '<span style="color:gray;">' + value + '</span>';
          }
    }, {
        text: 'Email',
        dataIndex: 'email',
        flex: 1,
        editor: {
            xtype: 'textfield',
            allowBlank: false
        }
    }],
    plugins: {
        rowediting: {
            clicksToEdit: 1
        }
    },
    height: 200,
    width: 400,
    renderTo: document.body
});

Parameters

editRenderer: function(value){
    // evaluates `value` to append either `person' or `people`
    return Ext.util.Format.plural(value, 'person', 'people');
}

editRenderer: function (value, metaData, record) {
    // evaluate the record's `updated` field and if truthy return the value
    // from the `newVal` field, else return value
    var updated = record.get('updated');
    return updated ? record.get('newVal') : value;
}

editRenderer: function (value, metaData, record, rowIndex) {
    // style the value differently for even / odd values
    var odd = (rowIndex % 2 === 0),
        color = (odd ? 'gray' : 'red');
    return '<span style="color:' + color + ';">' + value + '</span>';
}

editRenderer: function (value, metaData, record, rowIndex, colIndex, store) {
    // style the cell differently depending on how the value relates to the
    // average of all values
    var average = store.average('grades'),
        status = (value < average) ? 'needsImprovement' : 'satisfactory';
    return '<span class="' + status + '">' + value + '</span>';
}

editRenderer: function (value, metaData, record, rowIndex, colIndex, store, view) {
    // style the value using the dataIndex of the column
    var headerCt = this.getHeaderContainer(),
        column = headerCt.getHeaderAtIndex(colIndex);

    return '<span class="app-' + column.dataIndex + '">' + value + '</span>';
}

Returns

emptyCellText : String

The text to display in empty cells (cells with a value of undefined, null, or '').

Defaults to   aka  .

Defaults to:

undefined

enableColumnHide : Boolean

False to disable column hiding within this grid.

Defaults to:

true

enableTextSelection : Boolean

True to enable text selection inside grid cells in this column.

Defaults to:

false

exportRenderer : Boolean / Function / String

During data export via the Ext.grid.plugin.Exporter plugin the data for this column could be formatted in multiple ways:

• using the exportStyle.format
• using the formatter if no exportStyle is defined
• using the exportRenderer

If you want to use the renderer defined on this column then set exportRenderer to true. Beware that this should only happen if the renderer deals only with data on the record or value and it does NOT style the cell or returns an html string.

 {
     xtype: 'numbercolumn',
     dataIndex: 'price',
     text: 'Price',
     renderer: function (value, metaData, record, rowIndex, colIndex, store, view) {
         return Ext.util.Format.currency(value);
     },
     exportRenderer: true
 }

If you don't want to use the renderer during export but you still want to format the value in a special way then you can provide a function to exportRenderer or a string (which is a function name on the ViewController). The provided function has the same signature as the renderer.

 {
     xtype: 'numbercolumn',
     dataIndex: 'price',
     text: 'Price',
     exportRenderer: function (value, metaData, record, rowIndex, colIndex, store, view){
         return Ext.util.Format.currency(value);
     }
 }


 {
     xtype: 'numbercolumn',
     dataIndex: 'price',
     text: 'Price',
     exportRenderer: 'exportAsCurrency' // this is a function on the ViewController
 }

If exportStyle.format, formatter and exportRenderer are all defined on the column then the exportStyle wins and will be used to format the data for this column.

Defaults to:

false

exportStyle : Ext.exporter.file.Style / Ext.exporter.file.Style[]

A style definition that is used during data export via the Ext.grid.plugin.Exporter. This style will be applied to the columns generated in the exported file.

You could define it as a single object that will be used by all exporters:

 {
     xtype: 'numbercolumn',
     dataIndex: 'price',
     text: 'Price',
     exportStyle: {
         format: 'Currency',
         alignment: {
             horizontal: 'Right'
         },
         font: {
             italic: true
         }
     }
 }

You could also define it as an array of objects, each object having a type that specifies by which exporter will be used:

 {
     xtype: 'numbercolumn',
     dataIndex: 'price',
     text: 'Price',
     exportStyle: [{
         type: 'html', // used by the html exporter
         format: 'Currency',
         alignment: {
             horizontal: 'Right'
         },
         font: {
             italic: true
         }
     },{
         type: 'csv', // used by the `csv` exporter
         format: 'General'
     }]
 }

Or you can define it as an array of objects that has:

• one object with no type key that is considered the style to use by all exporters
• objects with the type key defined that are exceptions of the above rule

 {
     xtype: 'numbercolumn',
     dataIndex: 'price',
     text: 'Price',
     exportStyle: [{
         // no type defined means this is the default
         format: 'Currency',
         alignment: {
             horizontal: 'Right'
         },
         font: {
             italic: true
         }
     },{
         type: 'csv', // only the CSV exporter has a special style
         format: 'General'
     }]
 }

Defaults to:

null

exportSummaryRenderer : Boolean / Function / String

This config is similar to exportRenderer but is applied to summary records.

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

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

focusableContainer : Boolean

Enable or disable navigation with arrow keys for this FocusableContainer. This option may be useful with nested FocusableContainers, when only the root container should handle keyboard events.

Defaults to:

false

focusCls : String

CSS class suffix that will be used to compose the CSS class name that will be added to Component's focusClsEl, and removed when Component blurs.

Note that this is not a full CSS class name; this suffix will be combined with component's UI class via addClsWithUI and removeClsWithUI methods.

Defaults to:

'focus'

focusOnToFront : Boolean

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

Defaults to:

true

formatter : String

This config accepts a format specification as would be used in a Ext.Template formatted token. For example 'round(2)' to round numbers to 2 decimal places or 'date("Y-m-d")' to format a Date.

In previous releases the renderer config had limited abilities to use one of the Ext.util.Format methods but formatter now replaces that usage and can also handle formatting parameters.

When the value begins with "this." (for example, "this.foo(2)"), the implied scope on which "foo" is found is the scope config for the column.

If the scope is not given, or implied using a prefix of "this", then either the ViewController or the closest ancestor component configured as defaultListenerScope is assumed to be the object with the method.

Available since: 5.0.0

formBind : Boolean

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

Defaults to:

false

frame : Boolean

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.

groupable : Boolean

If the grid uses a Ext.grid.feature.Grouping, this option may be used to disable the header menu item to group by the column selected. By default, the header menu group option is enabled. Set to false to disable (but still show) the group option in the header menu for the column.

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.

hidden : Boolean

bindable bind

true to hide the component.

Defaults to:

false

Available since: 2.3.0

hideable : Boolean

False to prevent the user from hiding this column.

Defaults to:

true

hideMode : String

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

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

Defaults to:

'display'

Available since: 1.1.0

html : String / Object

bindable bind

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

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

ignoreExport : Boolean

This flag indicates that this column will be ignored when grid data is exported.

When grid data is exported you may want to export only some columns that are important and not everything. Widget, check and action columns are not relevant when data is exported. You can set this flag on any column that you want to be ignored during export.

This is used by Ext.grid.plugin.Clipboard and Ext.grid.plugin.Exporter.

Defaults to:

false

inactiveChildTabIndex : Number

DOM tabIndex attribute to set on inactive Focusable children of this container when using the "Roaming tabindex" technique. This value rarely needs to be changed from its default.

Defaults to:

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

items : Object / Object[]

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

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

Example:

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

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

Each item may be:

• A Ext.Component
• A Component configuration object

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

Every Component class has its own xtype.

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

Notes:

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

Do not specify contentEl or html with items.

Defaults to:

undefined

Available since: 2.3.0

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.

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

layout : Ext.enums.Layout / Object

bindable bind

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

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

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

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

Specify as an Object

Example usage:

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

• type

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

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

• Layout specific configuration properties

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

Specify as a String

Example usage:

layout: 'vbox'

• layout

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

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

Configuring the default layout type

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

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

Defaults to:

'auto'

Available since: 2.3.0

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

• All Form Fields (subclasses of Ext.form.field.Base)
• Ext.button.Button

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

• event-resize
• event-boxready

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

• afterComponentLayout
• onBoxReady
• onResize

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:

var win = Ext.create({
        xtype: 'window',
        title: 'Resize This Window!',
        height: 100,
        width: 200,
        layout: 'anchor',
        items: [{
            xtype: 'textarea',
            anchor: '0 0',
            liquidLayout: false // allows the textarea to fire "resize"
        }]
    }),
    textfield = win.items.getAt(0);

win.show();

textfield.on('resize', function(textfield, width, height) {
    Ext.Msg.alert('Text Field Resized', 'width: ' + width + ', height: ' + height);
});

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

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.Views itemclick event passing the node clicked on. To access DOM events directly from a child element of a Component, we need to specify the element option to identify the Component property to add a DOM listener to:

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

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

lockable : Boolean

If the grid is configured with enableLocking, or has columns which are configured with a locked value, this option may be used to disable user-driven locking or unlocking of this column. This column will remain in the side into which its own locked configuration placed it.

locked : Boolean

True to lock this column in place. Implicitly enables locking on the grid. See also Ext.grid.Panel#enableLocking.

Defaults to:

false

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

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

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

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

menuDisabled : Boolean

True to disable the column header menu containing sort/hide options.

Defaults to:

false

menuText : String

The text to render in the column visibility selection menu for this column. If not specified, will default to the text value.

Defaults to:

null

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

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

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.

nameable : Boolean

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

Defaults to:

false

nameHolder : Boolean

When true child components are tracked by their name property and can be retrieved using the lookupName method.

Defaults to:

false

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

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

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

The preferred form for multiple plugins or to configure plugins is the keyed-object form (new in version 6.5):

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

The keys are id's as well as the default type alias.

The plugins config 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
 }],

Available since: 2.3.0

producesHTML : Boolean

This flag indicates that the renderer produces HTML.

If this column is going to be updated rapidly, and the Ext.grid.column.Column#renderer or cfg-updater only produces text, then to avoid the expense of HTML parsing and element production during the update, this property may be configured as false.

Defaults to:

true

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

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

referenceHolder : Boolean

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

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

Defaults to:

false

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

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.

renderTo : String / HTMLElement / Ext.dom.Element

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

Notes:

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

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

See also: method-render.

Available since: 2.3.0

renderTpl : Ext.XTemplate / String / String[]

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:

'<tpl if="hasTabGuard">{% this.renderTabGuard(out, values, \'before\'); %}</tpl>' + '{% this.renderContainer(out,values) %}' + '<tpl if="hasTabGuard">{% this.renderTabGuard(out, values, \'after\'); %}</tpl>'

resetFocusPosition : Boolean

When true, FocusableContainer will reset last focused position whenever focus leaves the container. Subsequent tabbing into the container will always focus the first eligible child item.

When false, subsequent tabbing into the container will focus the child item that was last focused before.

Defaults to:

false

resizable : Boolean

False to prevent the column from being resizable.

Defaults to:

true

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

sealed : Boolean

Specify as true to constrain column dragging so that a column cannot be dragged into or out of this column.

Note that this config is only valid for column headers which contain child column headers, eg: { sealed: true text: 'ExtJS', columns: [{ text: '3.0.4', dataIndex: 'ext304' }, { text: '4.1.0', dataIndex: 'ext410' } }

Defaults to:

false

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

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

sortable : Boolean

False to disable sorting of this column. Whether local/remote sorting is used is specified in Ext.data.Store#remoteSort.

Defaults to:

true

sortAscText : String

The text to display in the sort menu to sort items in ascending order.

Defaults to:

'Sort Ascending'

sortClearText : String

The text to display in the sort menu to clear the sort order.

Defaults to:

'Clear Sort'

sortDescText : String

The text to display in the sort menu to sort items in descending order.

Defaults to:

'Sort Descending'

sorter : Function / String / Object / Ext.util.Sorter

bindable bind

A Sorter, or sorter config object to apply when the standard user interface sort gesture is invoked. This is usually clicking this column header, but there are also menu options to sort ascending or descending.

Note that a sorter may also be specified as a function which accepts two records to compare.

In 6.2.0, a Ext.app.ViewController method can be used like so:

 sorter: {
     sorterFn: 'sorterMethodName'
 }

Defaults to:

null

Available since: 6.0.1

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:

• event-resize

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()+(1000*60*60*24*7)), // 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

stateId : String

An identifier which identifies this column uniquely within the owning grid's state.

This does not have to be globally unique. A column's state is not saved standalone. It is encapsulated within the owning grid's state.

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

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

summaryRenderer : Function / String

A renderer to be used in conjunction with the Ext.grid.feature.Summary or Ext.grid.feature.GroupingSummary features. This renderer is used to display a summary value for this column.

suspendLayout : Boolean

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

Defaults to:

false

tabIndex : Number

bindable bind

DOM tabIndex attribute for this component's focusEl.

tdCls : String

A CSS class names to apply to the table cells for this column.

Defaults to:

''

text : String

bindable bind

The header text to be used as innerHTML (html tags are accepted) to display in the Grid.

Defaults to:

'\xa0'

toFrontOnShow : Boolean

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

Defaults to:

true

tooltip : String

A tooltip to display for this column header

tooltipType : String

The type of tooltip to use. Either 'qtip' for QuickTips or 'title' for title attribute.

Defaults to:

"qtip"

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

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

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

ui : String

bindable bind

A UI style for a component.

Defaults to:

'default'

updater : Function / String

An updater is a method which is used when records are updated, and an existing grid row needs updating. The method is passed the cell element and may manipulate it in any way.

Note: The updater is required to insert the emptyCellText if there is no value in the cell.

Ext.create('Ext.grid.Panel', {
    title: 'Grades',
    store: {
        fields: ['originalScore', 'newScore'],
        data: [{
            originalScore: 70,
            newScore: 70
        }]
    },
    columns: [{
        text: 'Score',
        dataIndex: 'newScore',
        editor: 'numberfield',
        flex: 1,
        updater: function (cell, value, record, view) {
            var inner = Ext.get(cell).first(),
                originalScore = record.get('originalScore'),
                color = (value === originalScore)
                    ? 'black' : (value > originalScore) ? 'green' : 'red';

            // set the color based on the current value
            // relative to the originalScore value
            // * same   = black
            // * higher = green
            // * less   = red
            inner.applyStyles({
                color: color
            });
            // pass the value to the cell's inner el
            inner.setHtml(value);
        }
    }],
    height: 200,
    width: 400,
    renderTo: document.body,
    tbar: [{
        xtype: 'numberfield',
        fieldLabel: 'New Score',
        value: 70,
        listeners: {
            change: function (field, newValue) {
                this.up('grid').getStore().first().set('newScore', newValue);
            }
        }
    }]
});

If a string is passed it is assumed to be the name of a method defined by the ViewController or an ancestor component configured as defaultListenerScope.

Properties

cell : HTMLElement

The HTML cell element to update.

value : Object

The data value for the current cell

record : Ext.data.Model

The record for the current row

view : Ext.view.View

The current view

Note: The updater is required to insert the emptyCellText if there is no value in the cell.

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

variableRowHeight : Boolean

True to indicate that data in this column may take on an unpredictable height, possibly differing from row to row.

If this is set, then View refreshes, and removal and addition of new rows will result in an ExtJS layout of the grid in order to adjust for possible addition/removal of scrollbars in the case of data changing height.

This config also tells the View's buffered renderer that row heights are unpredictable, and must be remeasured as the view is refreshed.

Defaults to:

false

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

weight : Number

HeaderContainer overrides the default weight of 0 for all docked items to 100. This is so that it has more priority over things like toolbars.

Defaults to:

100

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.

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

ariaRole : String

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

Defaults to:

'presentation'

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

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:

'html'

destroyed : Boolean

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

Defaults to:

false

floatingItems : Ext.util.MixedCollection

The MixedCollection containing all the floating child items of this container. Will be undefined if there are no floating child items.

Available since: 4.1.0

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

focusableContainerEl : String / Ext.dom.Element

The name of the element that FocusableContainer should bind its keyboard handler to. Similar to ariaEl, this name is resolved to the Ext.dom.Element instance after rendering.

Defaults to:

"el"

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

readonly ro

true if this component's focusEl is focused. See also containsFocus.

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

initialConfig : Object

readonly ro

The config object passed to the constructor during Component creation.

Defaults to:

config

isColumn : Boolean

readonly ro

Set in this class to identify, at runtime, instances which are not instances of the HeaderContainer base class, but are in fact simple column headers.

Defaults to:

true

isComponent : Boolean

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

Defaults to:

true

isContainer : Boolean

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

Defaults to:

true

isGroupHeader : Boolean

True if this HeaderContainer is in fact a group header which contains sub headers.

isObservable : Boolean

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

Defaults to:

true

items : Ext.util.ItemCollection

The Collection containing all the child items of this container.

Defaults to:

new Ext.util.ItemCollection()

Available since: 2.3.0

lastKeyMapEvent : Ext.event.Event

The last key event processed is cached on the component for use in subsequent event handlers.

Available since: 6.6.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

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

rendered : Boolean

readonly ro

Indicates whether or not the component has been rendered.

Defaults to:

false

Available since: 1.1.0

textEl : Ext.dom.Element

Element that contains the text in column header.

triggerEl : Ext.dom.Element

Element that acts as button for column header dropdown menu.

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