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

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

allowDeselect : Boolean

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

Defaults to:

false

alwaysOnTop : Boolean / Number

bindable bind

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

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

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

Defaults to:

false

anchor : String

This is a layout that enables anchoring of contained elements relative to the container's dimensions. If the container is resized, all anchored items are automatically rerendered according to their anchor rules.

This class is intended to be extended or created via the layout: 'anchor' config, and should generally not need to be created directly via the new keyword.

AnchorLayout does not have any direct config options (other than inherited ones). By default, AnchorLayout will calculate anchor measurements based on the size of the container itself. However, the container using the AnchorLayout can supply an anchoring-specific config property of anchorSize.

If anchorSize is specifed, the layout will use it as a virtual container for the purposes of calculating anchor measurements based on it instead, allowing the container to be sized independently of the anchoring logic if necessary.

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

animCollapse : Boolean / Number

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

Defaults to:

Ext.enableFx

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

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

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

Available since: 2.3.0

autoLoad : Boolean

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

Defaults to:

false

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

This config is intended mainly for non-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:

'x-component'

bbar : Object / Object[]

Convenience config. Short for 'Bottom Bar'.

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

is equivalent to

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

Defaults to:

null

bind : Object

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.

Defaults to:

null

bodyBorder : Boolean

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

Available since: 2.3.0

bodyCls : String / String[]

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

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

bodyPadding : Number / String

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

Defaults to:

undefined

bodyStyle : String / Object / Function

bindable bind

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

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

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

Available since: 2.3.0

border : Boolean

bindable bind

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

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

Defaults to false when using or extending Neptune.

Note: is ignored when frame is set to true.

Defaults to:

true

bubbleEvents : String[]

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

Available since: 3.4.0

bufferedRenderer : Boolean

Buffered rendering is enabled by default.

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

Defaults to:

true

Available since: 5.0.0

buttonAlign : String

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

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

buttons : Object / Object[]

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

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

is equivalent to

dockedItems: [{
    xtype: 'toolbar',
    dock: 'bottom',
    ui: 'footer',
    defaults: {
        minWidth: 200
    },
    items: [
        { xtype: 'component', flex: 1 },
        { xtype: 'button', text: 'Button 1' }
    ]
}]

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

Defaults to:

null

childEls : Object / String[] / Object[]

bindable bind

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

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

closable : Boolean

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

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

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

Defaults to:

false

closeAction : String

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

• 'method-destroy' :

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

• 'method-hide' :

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

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

Defaults to:

'destroy'

closeToolText : String

Text to be announced by screen readers when the close Ext.panel.Tool is focused. Will also be set as the close tool's tooltip text.

Note: Applicable when the panel is closable: true

Defaults to:

'Close panel'

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

collapsed : Boolean

bindable bind

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

Defaults to:

false

collapsedCls : String

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

Defaults to:

'collapsed'

collapseDirection : String

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

Defaults to the cfg-headerPosition

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

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

collapseFirst : Boolean

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

Defaults to:

true

collapseMode : String

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

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

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

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

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

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

collapseToolText : String

Text to be announced by screen readers when collapse Ext.panel.Tool is focused. Will also be set as the collapse tool's tooltip text.

Note: Applicable when the panel is collapsible: true

Defaults to:

'Collapse panel'

collapsible : Boolean

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

Defaults to:

undefined

columnLines : Boolean

Adds column line styling

columns : Ext.grid.column.Column[] / Object

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

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

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

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

Defaults to:

false

constrainHeader : Boolean

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

Defaults to:

false

constraintInsets : Object / String

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

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

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

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

contentEl : String

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

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

Notes:

The specified HTML element is appended to the layout element of the component after any configured HTML has been inserted, and so the document will not contain this element at the time the 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 Ext.Component#cfg-tpl to update the content area of the Component.

Defaults to:

null

Available since: 3.4.0

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"

defaultButton : String

Reference name of the component to act as the default button for this Panel. Default button is activated by pressing Enter key while focus is contained within the Panel's defaultButtonTarget.

The most obvious use for defaultButton is submitting a form:

 var loginWindow = new Ext.window.Window({
     autoShow: true,
     width: 300,
     layout: 'form',
     title: 'Enter login information',
     referenceHolder: true,
     defaultFocus: 'textfield',
     defaultButton: 'okButton',

     items: [{
         xtype: 'textfield',
         fieldLabel: 'User name'
     }, {
         xtype: 'textfield',
         fieldLabel: 'Password'
     }],

     buttons: [{
         reference: 'okButton',
         text: 'Login',
         handler: function() {
             Ext.Msg.alert('Submit', 'Your login is being processed');
         }
     }]
 });

defaultButtonTarget : String

Name of the element that will be the target of defaultButton keydown listener. The default element is Panel body, which means that pressing Enter key while focus is on docked items will not fire defaultButton action.

If you want defaultButton action to fire in docked items, set this config to "el".

defaultDockWeights : Object

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

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

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

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

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

     this.callParent();
 }

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

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

     this.callParent();
 }

Defaults to:

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

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

deferRowRender : Boolean

Configure as true to enable deferred row rendering.

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

Defaults to:

false

detachOnRemove : Boolean

True to move any component to the detachedBody when the component is removed from this container. This option is only applicable when the component is not destroyed while being removed, see autoDestroy and 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

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:

'x-item-disabled'

disableSelection : Boolean

True to disable selection model.

Defaults to:

false

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

dockedItems : Object / Object[]

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

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

Defaults to:

null

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

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

NOTE: The private Ext.panel.DD class is used instead of ComponentDragger when simpleDrag is false (default). In this case you may pass a config for Ext.dd.DragSource.

See also dd.

Defaults to:

false

emptyText : String

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

enableColumnHide : Boolean

False to disable column hiding within this grid.

Defaults to:

true

enableColumnMove : Boolean

False to disable column dragging within this grid.

Defaults to:

true

enableColumnResize : Boolean

False to disable column resizing within this grid.

Defaults to:

true

enableLocking : Boolean

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

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

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

Plugins may also be targeted at the containing locking Panel.

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

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

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

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

Defaults to:

false

expandToolText : String

Text to be announced by screen readers when expand Ext.panel.Tool is focused. Will also be set as the expand tool's tooltip text.

Note: Applicable when the panel is collapsible: true

Defaults to:

'Expand panel'

fbar : Object / Object[]

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

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

is equivalent to

dockedItems: [{
    xtype: 'toolbar',
    dock: 'bottom',
    ui: 'footer',
    defaults: {
        minWidth: 200
    },
    items: [
        { xtype: 'component', flex: 1 },
        { xtype: 'button', text: 'Button 1' }
    ]
}]

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

Defaults to:

null

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

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

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

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

By using config object with ftype:

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

Or with just a ftype:

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

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

fixed : Boolean

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

Defaults to:

false

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

floatable : Boolean

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

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

Defaults to:

true

floating : Boolean

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

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

Floating Components that are 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

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

Defaults to:

'x-focus'

focusOnToFront : Boolean

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

Defaults to:

true

forceFit : Boolean

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

formBind : Boolean

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

Defaults to:

false

frame : Boolean

True to apply a frame to the panel.

Note: frame: true overrides border:false

Defaults to:

false

frameHeader : Boolean

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

Defaults to:

true

glyph : Number / String

bindable bind

A numeric unicode character code to use as the icon. The default font-family for glyphs can be set globally using glyphFontFamily application config or the Ext.setGlyphFontFamily() method.

The following shows how to set the glyph using the font icons provided in the SDK (assuming the font-family has been configured globally):

// assumes the glyphFontFamily is "FontAwesome"
glyph: 'xf005'     // the "home" icon

// assumes the glyphFontFamily is "Pictos"
glyph: 'H'         // the "home" icon

Alternatively, this config option accepts a string with the charCode and font-family separated by the @ symbol.

// using Font Awesome
glyph: 'xf005@FontAwesome'     // the "home" icon

// using Pictos
glyph: 'H@Pictos'              // the "home" icon

Depending on the theme you're using, you may need include the font icon packages in your application in order to use the icons included in the SDK. For more information see:

• Font Awesome icons
• Pictos icons
• Theming Guide

Defaults to:

null

header : Boolean / Object

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

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

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

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

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

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

headerBorders : Boolean

bindable bind

To show no borders around grid headers, configure this as false.

Defaults to:

`true`

headerOverCls : String

Optional CSS class to apply to the header element on mouseover

headerPosition : 'top' / 'bottom' / 'left' / 'right'

bindable bind

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

Defaults to:

'top'

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

hideCollapseTool : Boolean

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

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

html : String / Object

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

icon : String

bindable bind

Path to an image to use as an icon.

For instructions on how you can use icon fonts including those distributed in the SDK see iconCls.

Defaults to:

null

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

bindable bind

The side of the title to render the icon.

Defaults to:

null

iconCls : String

bindable bind

One or more space separated CSS classes to be applied to the icon element. The CSS rule(s) applied should specify a background image to be used as the icon.

An example of specifying a custom icon class would be something like:

// specify the property in the config for the class:
iconCls: 'my-home-icon'

// css rule specifying the background image to be used as the icon image:
.my-home-icon {
    background-image: url(../images/my-home-icon.gif) !important;
}

In addition to specifying your own classes, you can use the font icons provided in the SDK using the following syntax:

// using Font Awesome
iconCls: 'x-fa fa-home'

// using Pictos
iconCls: 'pictos pictos-home'

Depending on the theme you're using, you may need include the font icon packages in your application in order to use the icons included in the SDK. For more information see:

• Font Awesome icons
• Pictos icons
• Theming Guide

Defaults to:

null

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

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

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 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 updateLayout call.

Do not specify contentEl or html with items.

Defaults to:

undefined

Available since: 2.3.0

layout : Ext.enums.Layout / Object

bindable bind

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

The sizing and positioning of child 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

lbar : Object / Object[]

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

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

is equivalent to

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

Defaults to:

null

leadingBufferZone : Number

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

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

Defaults to:

20

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:

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

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

lockedGridConfig : Object

Any special configuration options for the locked part of the grid

lockedViewConfig : Object

A view configuration to be applied to the locked side of the grid. Any conflicting configurations between lockedViewConfig and viewConfig will be overwritten by the lockedViewConfig.

manageHeight : Boolean

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

Defaults to:

true

margin : Number / String

bindable bind

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

maskElement : String

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

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

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

Defaults to:

"el"

maxHeight : Number

bindable bind

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

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

Defaults to:

null

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

minButtonWidth : Number

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

Defaults to:

75

minHeight : Number

bindable bind

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

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

Defaults to:

null

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

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

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

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

multiColumnSort : Boolean

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

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

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

Defaults to:

false

normalGridConfig : Object

Any special configuration options for the normal part of the grid

normalViewConfig : Object

A view configuration to be applied to the normal/unlocked side of the grid. Any conflicting configurations between normalViewConfig and viewConfig will be overwritten by the normalViewConfig.

numFromEdge : Number

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

Defaults to:

2

overCls : String

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

Defaults to:

''

Available since: 2.3.0

overlapHeader : Boolean

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

padding : Number / String

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

placeholder : Ext.Component / Object

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

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

placeholderCollapseHideMode : Number

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

Defaults to:

Ext.Element.VISIBILITY

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

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

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

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

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

By using config object with ptype:

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

Or with just a ptype:

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

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

Available since: 2.3.0

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

rbar : Object / Object[]

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

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

is equivalent to

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

Defaults to:

null

reference : String

bindable bind

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

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

Defaults to:

null

referenceHolder : Boolean

bindable bind

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

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

reserveScrollbar : Boolean

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

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

Defaults to:

false

resizable : Boolean / Object

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

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

resizeHandles : String

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

Defaults to:

'all'

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

scrollDelta : Number

Number of pixels to scroll when scrolling the locked section with mousewheel.

Defaults to:

40

sealedColumns : Boolean

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

Defaults to:

false

selection : Ext.data.Model

bindable bind

The selected model. Typically used with binding.

Defaults to:

null

selModel : Ext.selection.Model / Object / String

A Ext.selection.Model instance or config object, or the selection model class's alias string.

In latter case its type property determines to which type of selection model this config is applied.

Defaults to:

rowmodel

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.

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.

Panels (subclasses and instances)

By default, when a panel is configured to shrink wrap in a given dimension, only the panel's "content" (items and html content inside the panel body) contributes to its size, and the content of docked items is ignored. Optionally you can use the shrinkWrapDock config to allow docked items to contribute to the panel's size as well. For example, if shrinkWrap and shrinkWrapDock are both set to true, the width of the panel would be the width of the panel's content and the panel's header text.

Defaults to:

2

shrinkWrapDock : Boolean / Number

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

Defaults to:

false

simpleDrag : Boolean

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

Defaults to:

false

sortableColumns : Boolean

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

Defaults to:

true

split : Boolean

Configure as true to place a resizing Ext.resizer.Splitter between the locked and unlocked columns.

Defaults to:

false

stateEvents : String[]

An array of events that, when fired, should trigger this object to save its state. Defaults to none. stateEvents may be any type of event supported by this object, including browser or custom events (e.g., ['click', 'customerchange']).

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

• event-resize - (added by Ext.Component)
• event-collapse - (added by Ext.panel.Panel)
• event-expand - (added by Ext.panel.Panel)
• event-columnresize
• event-columnmove
• event-columnhide
• event-columnshow
• event-sortchange
• event-filterchange
• event-groupchange

stateful : Boolean

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

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

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

To set the state provider for the current page:

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

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

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

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

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

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

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

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

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

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

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

Defaults to:

false

stateId : String

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

See stateful for an explanation of saving and restoring 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'
});

subGridXType : String

The xtype of the subgrid to specify. If this is not specified lockable will determine the subgrid xtype to create by the following rule. Use the superclasses xtype if the superclass is NOT tablepanel, otherwise use the xtype itself.

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

syncRowHeight : Boolean

Synchronize rowHeight between the normal and locked grid view. This is turned on by default. If your grid is guaranteed to have rows of all the same height, you should set this to false to optimize performance.

Defaults to:

true

tabIndex : Number

bindable bind

DOM tabIndex attribute for this Focusable's focusEl.

tbar : Object / Object[]

Convenience config. Short for 'Top Bar'.

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

is equivalent to

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

Defaults to:

null

title : String / Object

bindable bind

The title text or config object for the Ext.panel.Title component. When a title is specified, the Ext.panel.Header will automatically be created and displayed unless header is set to false.

Defaults to:

null

titleAlign : 'left' / 'center' / 'right'

bindable bind

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

Defaults to:

null

titleCollapse : Boolean

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

Defaults to:

undefined

titleRotation : 'default' / 0 / 1 / 2

bindable bind

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

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

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

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

Defaults to:

null

toFrontOnShow : Boolean

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

Defaults to:

true

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

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

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

Example usage:

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

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

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

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

tplWriteMode : String

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

Defaults to:

'overwrite'

Available since: 3.4.0

trailingBufferZone : Number

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

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

Defaults to:

10

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'

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

view : Ext.view.Table

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

viewConfig : Object

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

viewModel : String / Object / Ext.app.ViewModel

bindable bind

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

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

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

Defaults to:

null

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.

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