<ext-numbercolumn/> Ext.grid.column.Number

dataIndex : String

required req

<ext-numbercolumn dataIndex="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.dataIndex = 'value';
let dataIndex = element.dataIndex;

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

Defaults to:

null

activeChildTabIndex : Number

immutable imm

<ext-numbercolumn activeChildTabIndex="10" />

let element = document.body.querySelector('ext-numbercolumn');
element.activeChildTabIndex = 10;
let activeChildTabIndex = element.activeChildTabIndex;

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

Defaults to:

0

activeItem : <ext-component/> / Object / String / Number

<ext-numbercolumn activeItem="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.activeItem = 'value';
let activeItem = element.activeItem;

The item from the cfg-items collection that will be active first. This is usually only meaningful in a Ext.layout.Card, where only one item can be active at a time. If passed a string, it will be assumed to be a Ext.ComponentQuery selector. A number will reference an index or a <ext-component/> instance may be passed as well. An object config will be created as a new component.

Defaults to:

0

align : String

<ext-numbercolumn align="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.align = 'value';
let align = element.align;

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

Defaults to:

'left'

alignSelf : String

<ext-numbercolumn alignSelf="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.alignSelf = 'value';
let alignSelf = element.alignSelf;

Specifies the self alignment of this widget in a box layout

Defaults to:

null

allowFocusingDisabledChildren : Boolean

immutable imm

<ext-numbercolumn allowFocusingDisabledChildren="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.allowFocusingDisabledChildren = true;
let allowFocusingDisabledChildren = element.allowFocusingDisabledChildren;

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

Defaults to:

false

alwaysOnTop : Boolean / Number

<ext-numbercolumn alwaysOnTop="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.alwaysOnTop = true;
let alwaysOnTop = element.alwaysOnTop;

A flag indicating that this component should be above its floated siblings.

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

Available since: 6.2.0

ariaAttributes : Object

<ext-numbercolumn ariaAttributes="{ }" />

let element = document.body.querySelector('ext-numbercolumn');
element.ariaAttributes = { };
let ariaAttributes = element.ariaAttributes;

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

immutable imm

<ext-numbercolumn ariaDescribedBy="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.ariaDescribedBy = 'value';
let ariaDescribedBy = element.ariaDescribedBy;

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

immutable imm

<ext-numbercolumn ariaLabel="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.ariaLabel = 'value';
let ariaLabel = element.ariaLabel;

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

immutable imm

<ext-numbercolumn ariaLabelledBy="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.ariaLabelledBy = 'value';
let ariaLabelledBy = element.ariaLabelledBy;

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.

ariaRole : String

readonly ro

<ext-numbercolumn ariaRole="value" />

let element = document.body.querySelector('ext-numbercolumn');
let ariaRole = element.ariaRole;

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

autoDestroy : Boolean

<ext-numbercolumn autoDestroy="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.autoDestroy = true;
let autoDestroy = element.autoDestroy;

If true, child items will be destroyed as soon as they are removed from this container.

Defaults to:

true

autoSize : Boolean

<ext-numbercolumn autoSize="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.autoSize = true;
let autoSize = element.autoSize;

May be set to false for improved layout performance if auto-sizing is not required.

Some versions of Safari, both desktop and mobile, have very slow performance if the application has deeply nested containers due to the following WebKit bug: https://bugs.webkit.org/show_bug.cgi?id=150445

Applications that experience performance issues in the affected versions of Safari may need to turn off autoSizing globally for all <ext-container/> instances by placing the following override in the application's "overrides" directory:

Ext.define('MyApp.overrides.Container', {
    override: 'Ext.Container',
    config: {
        autoSize: false
    }
});

Once auto-sizing support has turned off by default, it can be selectively turned back on only on those container instances that explicitly need auto-sizing behavior by setting autoSize to true.

This option can also be used to allow items to be sized in percentage units as a workaround for the following browser bug: https://bugs.webkit.org/show_bug.cgi?id=137730

To illustrate, the following example should render a 200px by 200px green box (the container) with a yellow box inside of it (the child item). The child item's height and width are both set to '50%' so the child should render exactly 100px by 100px in size.

Ext.create({
    xtype: 'container',
    renderTo: Ext.getBody(),
    height: 200,
    width: 200,
    style: 'background: green',
    items: [{
        xtype: 'component',
        style: 'background: yellow',
        height: '50%',
        width: '50%'
    }]
});

All browsers except for Safari render the previous example correctly, but Safari does not assign a height to the component. To make percentage-sized items work in Safari, simply set autoSize to false on the container.

Since the underlying implementation works by absolutely positioning the container's body element, this option can only be used when the container is not "shrink wrapping" the content in either direction. When autoSize is set to false, shrink wrapped dimension(s) will collapse to 0.

Defaults to:

true

axisLock : Boolean

<ext-numbercolumn axisLock="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.axisLock = true;
let axisLock = element.axisLock;

If true, then, when showBy or alignTo fallback on constraint violation only takes place along the major align axis.

That is, if alignment "l-r" is being used, and axisLock: true is used, then if constraints fail, only fallback to "r-l" is considered.

Defaults to:

null

bind : Object / String

<ext-numbercolumn bind="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.bind = 'value';
let bind = element.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

bodyCls : String / String[]

<ext-numbercolumn bodyCls="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.bodyCls = 'value';
let bodyCls = element.bodyCls;

The CSS class to add to this container's body element.

Defaults to:

null

Available since: 7.0

border : Boolean

<ext-numbercolumn border="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.border = true;
let border = element.border;

Enables or disables bordering on this component. The following values are accepted:

• null or `true (default): Do nothing and allow the border to be specified by the theme.
• false: suppress the default border provided by the theme.

Please note that enabling bordering via this config will not add a border-color or border-style CSS property to the component; you provide the border-color and border-style via CSS rule or style configuration (if not already provide by the theme).

Using style:

Ext.Viewport.add({
    centered: true,
    width: 100,
    height: 100,

    style: 'border: 1px solid blue;'
    // ...
});

Using CSS:

Ext.Viewport.add({
    centered: true,
    width: 100,
    height: 100,

    cls: 'my-component'
    // ...
});

And your CSS file:

.my-component {
    border: 1px solid red;
}

Defaults to:

null

bottom : Number / String

<ext-numbercolumn bottom="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.bottom = 'value';
let bottom = element.bottom;

The absolute bottom position of this Component; must be a valid CSS length value, e.g: 300, 100px, 30%, etc. Explicitly setting this value will make this Component become 'positioned', which means it will no longer participate in the layout of the Container that it resides in.

Defaults to:

null

cell : Object

<ext-numbercolumn cell="{ }" />

let element = document.body.querySelector('ext-numbercolumn');
element.cell = { };
let cell = element.cell;

The config object used to create <ext-gridcellbase/> for this column. By default, cells use the <ext-gridcell/> xtype. To create a different type of cell, simply provide this config and the desired xtype.

Defaults to:

{
    xtype: 'gridcell'
}

centered : Boolean

<ext-numbercolumn centered="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.centered = true;
let centered = element.centered;

Configure this as true to have this Component centered within its Container. Setting this value to true will make this Component become 'positioned', which means it will no longer participate in the layout of the Container that it resides in.

Defaults to:

false

classCls

readonly ro

<ext-numbercolumn classCls="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.classCls = 'value';
let classCls = element.classCls;

A CSS class to apply to the main element that will be inherited down the class hierarchy. Subclasses may override this property on their prototype to add their own CSS class in addition to the CSS classes inherited from ancestor classes via the prototype chain. For example

Ext.define('Foo', {
    extend: 'Ext.Widget',
    classCls: 'foo'
});

Ext.define('Bar', {
    extend: 'Foo',
    classCls: 'bar'
});

var bar = new Bar();

console.log(bar.element.className); // outputs 'foo bar'

Defaults to:

Ext.baseCSSPrefix + 'component'

cls : String / String[]

<ext-numbercolumn cls="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.cls = 'value';
let cls = element.cls;

The CSS class to add to this widget's element, in addition to the baseCls. In many cases, this property will be specified by the derived widget class. See userCls for adding additional CSS classes to widget instances (such as items in a <ext-container/>).

Defaults to:

null

columns : Ext.grid.column.Column[]

<ext-numbercolumn columns="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.columns = 'value';
let columns = element.columns;

The sub columns within this column/header container.

Defaults to:

null

computedWidth : Number

readonly ro

<ext-numbercolumn computedWidth="10" />

let element = document.body.querySelector('ext-numbercolumn');
let computedWidth = element.computedWidth;

The computed width for this column, may come from either width or flex.

Defaults to:

null

constrainAlign : String / Ext.util.Region / Ext.dom.Element

<ext-numbercolumn constrainAlign="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.constrainAlign = 'value';
let constrainAlign = element.constrainAlign;

A specification of the constraint to apply when showBy or alignTo is called to align a floated or positioned component.

Defaults to the parent container for positioned components (components which have their top, right, bottom or left set to move them out of their container's layout flow).

Defaults to the viewport for floated components.

May be a Ext.ComponentQuery selector to find an ancestor component to constrain within.

May be false to specify that constraining is not applied.

You may also specify an element, or a Ext.util.Region

Defaults to:

null

containsFocus : Boolean

readonly ro

<ext-numbercolumn containsFocus="true" />

let element = document.body.querySelector('ext-numbercolumn');
let containsFocus = element.containsFocus;

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

contentEl : Ext.dom.Element / HTMLElement / String

<ext-numbercolumn contentEl="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.contentEl = 'value';
let contentEl = element.contentEl;

The configured element will automatically be added as the content of this component. When you pass a string, we expect it to be an element id. If the content element is hidden, we will automatically show it.

Defaults to:

null

controller : String / Object / Ext.app.ViewController

<ext-numbercolumn controller="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.controller = 'value';
let controller = element.controller;

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

<ext-numbercolumn data="{ }" />

let element = document.body.querySelector('ext-numbercolumn');
element.data = { };
let data = element.data;

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

Note: Data will be appended to any existing data.

Defaults to:

null

defaultBindProperty : String

readonly ro

<ext-numbercolumn defaultBindProperty="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.defaultBindProperty = 'value';
let defaultBindProperty = element.defaultBindProperty;

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'

defaultColumnUI

<ext-numbercolumn defaultColumnUI="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.defaultColumnUI = 'value';
let defaultColumnUI = element.defaultColumnUI;

A default ui to use for <ext-gridcolumn/> <ext-column/> <ext-templatecolumn/> in this header.

Defaults to:

null

defaultEditor : Object / <ext-field/>

<ext-numbercolumn defaultEditor="{ }" />

let element = document.body.querySelector('ext-numbercolumn');
element.defaultEditor = { };
let defaultEditor = element.defaultEditor;

An optional config object used to create a default editor for values in this column when no editor is specified. This config is typically defined by derived column classes such as <ext-datecolumn/> to tune the default editor.

This value is augmented by the editorDefaults config.

Defaults to:

{}

defaultFilterType : String

readonly ro

<ext-numbercolumn defaultFilterType="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.defaultFilterType = 'value';
let defaultFilterType = element.defaultFilterType;

This property can be set on column classes to determine the default type alias for filters.

Defaults to:

null

defaultFocus : String

<ext-numbercolumn defaultFocus="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.defaultFocus = 'value';
let defaultFocus = element.defaultFocus;

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

Defaults to:

null

defaultListenerScope : Boolean

<ext-numbercolumn defaultListenerScope="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.defaultListenerScope = true;
let defaultListenerScope = element.defaultListenerScope;

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

defaultToolWeights : Object

<ext-numbercolumn defaultToolWeights="{ }" />

let element = document.body.querySelector('ext-numbercolumn');
element.defaultToolWeights = { };
let defaultToolWeights = element.defaultToolWeights;

The default weight for tools in the header.

Defaults to:

{
    toggle: 10,
    gear: 20,
    prev: 30,
    next: 40,
    left: 50,
    right: 60,
    down: 70,
    up: 80,
    refresh: 90,
    disclosure: 100,
    // was originally defined in ListItem
    plus: 100,
    minus: 110,
    search: 120,
    edit: 125,
    save: 130,
    print: 140,
    expand: 150,
    collapse: 160,
    help: 170,
    pin: 180,
    unpin: 190,
    minimize: 200,
    maximize: 210,
    restore: 220,
    close: 230,
    trash: 240
}

Available since: 6.5.0

defaultWidth : Number

<ext-numbercolumn defaultWidth="10" />

let element = document.body.querySelector('ext-numbercolumn');
element.defaultWidth = 10;
let defaultWidth = element.defaultWidth;

A width to apply if the flex or width configurations have not been specified.

Defaults to:

100

Available since: 6.2.0

defaults : Object

<ext-numbercolumn defaults="{ }" />

let element = document.body.querySelector('ext-numbercolumn');
element.defaults = { };
let defaults = element.defaults;

A set of default configurations to apply to all child Components in this Container. It's often useful to specify defaults when creating more than one items with similar configurations. For example here we can specify that each child is a panel and avoid repeating the xtype declaration for each one:

Ext.create({
    xtype: 'container',
    defaults: {
        xtype: 'panel'
    },
    items: [
        {
            html: 'Panel 1'
        },
        {
            html: 'Panel 2'
        }
    ]
});

Defaults to:

null

depends : String[]

<ext-numbercolumn depends="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.depends = 'value';
let depends = element.depends;

Set this config to the field names that effect this column's rendering. This is important for best performance when using a renderer, a summaryRenderer or a tpl to render the cell's content. This is because such mechanisms can use any field and as such must be refreshed on any field change. When this config is provided, only changes to these fields (or the dataIndex) will cause a refresh.

When not using these mechanisms, only changes to the dataIndex will cause the cell content to be refreshed.

Defaults to:

null

Available since: 6.5.1

destroyed : Boolean

readonly ro

<ext-numbercolumn destroyed="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.destroyed = true;
let destroyed = element.destroyed;

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

Defaults to:

false

disabled : Boolean

<ext-numbercolumn disabled="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.disabled = true;
let disabled = element.disabled;

Whether or not this component is disabled

Defaults to:

null

displayed : Boolean

<ext-numbercolumn displayed="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.displayed = true;
let displayed = element.displayed;

Set to true to call show and false to call hide. Unlike the hidden config, changing this config will potentially involve animations to show or hide the component.

Defaults to:

null

Available since: 6.5.0

docked : String

<ext-numbercolumn docked="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.docked = 'value';
let docked = element.docked;

The dock position of this component in its container. Can be left, top, right or bottom.

Notes

You must use a HTML5 doctype for docked bottom to work. To do this, simply add the following code to the HTML file:

<!doctype html>

So your index.html file should look a little like this:

<!doctype html>
<html>
    <head>
        <title>MY application title</title>
        ...

Defaults to:

null

draggable : Boolean / Object / Ext.drag.Source

<ext-numbercolumn draggable="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.draggable = true;
let draggable = element.draggable;

Set to true to allow this component to be dragged. This can also be the config object for the Ext.drag.Source that will manage the drag.

Defaults to:

null

editable : Boolean

<ext-numbercolumn editable="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.editable = true;
let editable = element.editable;

Set this to true to make this column editable. Only applicable if the grid is using an grideditable plugin.

Defaults to:

null

editor : Object / String

<ext-numbercolumn editor="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.editor = 'value';
let editor = element.editor;

The xtype or config object for a <ext-field/> to use for editing. This config is used by the grideditable plugin.

If this config is not set, and editable is set to true, the defaultEditor is used.

Defaults to:

null

editorDefaults : Object

<ext-numbercolumn editorDefaults="{ }" />

let element = document.body.querySelector('ext-numbercolumn');
element.editorDefaults = { };
let editorDefaults = element.editorDefaults;

This object holds default config objects for creating the column's editor. The keys of this object are field type values (such as 'date' or 'int'). These keys can also be a comma-separated list of such type names.

These defaults are applied when producing an editor based on the field of store's model identified by the dataIndex.

See ensureEditor.

Defaults to:

{
    "default": {
        xtype: 'textfield',
        autoComplete: false,
        textAlign: undefined
    },
    'bool,boolean': {
        xtype: 'checkboxfield',
        bodyAign: undefined
    },
    date: {
        xtype: 'datefield',
        textAlign: undefined
    },
    'float,number': {
        xtype: 'numberfield',
        textAlign: undefined
    },
    'int,integer': {
        xtype: 'numberfield',
        decimals: 0,
        textAlign: undefined
    }
}

Available since: 7.0

exportRenderer : Boolean / Function / String

<ext-numbercolumn exportRenderer="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.exportRenderer = true;
let exportRenderer = element.exportRenderer;

During data export via the gridexporter 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, record, dataIndex, cell, column) {
         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, record, dataIndex, cell, column) {
         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[]

<ext-numbercolumn exportStyle="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.exportStyle = 'value';
let exportStyle = element.exportStyle;

A style definition that is used during data export via the gridexporter. 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',
     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',
     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',
     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

<ext-numbercolumn exportSummaryRenderer="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.exportSummaryRenderer = true;
let exportSummaryRenderer = element.exportSummaryRenderer;

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

Defaults to:

false

factoryConfig : Object

readonly ro

<ext-numbercolumn factoryConfig="{ }" />

let element = document.body.querySelector('ext-numbercolumn');
element.factoryConfig = { };
let factoryConfig = element.factoryConfig;

If this property is specified by the target class of this mixin its properties are used to configure the created Ext.Factory.

filter : Object / Boolean

<ext-numbercolumn filter="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.filter = true;
let filter = element.filter;

Defaults to:

null

flex : Number / String / Object

<ext-numbercolumn flex="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.flex = 'value';
let flex = element.flex;

The flex of this item if this item item is inside a Ext.layout.HBox or Ext.layout.VBox layout.

You can also update the flex of a component dynamically using the Ext.layout.FlexBox#setItemFlex method.

When supplied as a string or number this option supports the same syntax as CSS flex. For example:

flex: '1 2 auto'

sets flex-grow property to 0, flex-shrink to 2 and flex-basis to 'auto'.

The default flex-shrink value for box layout items is set to 0 in the stylesheet, which is different from the browser's default flex-shrink value of 1. This accommodates the majority use case for applications since where non-flexed components are typically not expected to shrink smaller than their default size.

For convenience when only a single number is supplied it is used as the value for both flex-grow and flex-shrink, for example flex: 3 is the same as flex: '3 3'

An object form is also accepted:

flex: {
    grow: 1,
    shrink: 2,
    basis: 'auto'
}

When the object form is supplied shrink always defaults to 0 regardless of the value of grow.

Although 'auto' is the default value for flex-basis, flex-basis defaults to 0% when flex is supplied as a single numeric or string value (e.g. flex: 1). If this behavior is not desired either explicitly set flex-basis to 'auto' or use the object form to set only grow and/or shrink:

flex: {
    grow: 2
}

Defaults to:

null

floated : Boolean

<ext-numbercolumn floated="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.floated = true;
let floated = element.floated;

A Component may be floated above all other components in the application. This means that the component is absolutely positioned, and will move to the front and occlude other sibling floated component if clicked.

A Floated component may have floated descendants. It will bring these decendants to the front with it when brought to the front of its sibling floated components.

By default, descendant floated components are all positioned using the viewport coordinate system. To make a floating component a positioning parent for descendants, and have the ancestors positioned relatively, configure the parent floated component with cfg-relative: true.

Defaults to:

false

Available since: 6.2.0

floatingCls : String

readonly ro

<ext-numbercolumn floatingCls="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.floatingCls = 'value';
let floatingCls = element.floatingCls;

The CSS class to add to this component when it is floated at the viewport level.

Defaults to:

Ext.baseCSSPrefix + 'floating'

focusCls : String

immutable imm

<ext-numbercolumn focusCls="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.focusCls = 'value';
let focusCls = element.focusCls;

CSS class that will be added to focused component's focusClsEl, and removed when component blurs.

Defaults to:

'x-focused'

focusClsEl : Ext.dom.Element

readonly ro

<ext-numbercolumn focusClsEl="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.focusClsEl = 'value';
let focusClsEl = element.focusClsEl;

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

focusEl : Ext.dom.Element

readonly ro

<ext-numbercolumn focusEl="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.focusEl = 'value';
let focusEl = element.focusEl;

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'

focusable : Boolean

readonly ro

<ext-numbercolumn focusable="true" />

let element = document.body.querySelector('ext-numbercolumn');
let focusable = element.focusable;

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

focusableContainer : Boolean

immutable imm

<ext-numbercolumn focusableContainer="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.focusableContainer = true;
let focusableContainer = element.focusableContainer;

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

focusableContainerEl : String / Ext.dom.Element

readonly ro

<ext-numbercolumn focusableContainerEl="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.focusableContainerEl = 'value';
let focusableContainerEl = element.focusableContainerEl;

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"

formatter : String

<ext-numbercolumn formatter="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.formatter = 'value';
let formatter = element.formatter;

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 getController or the closest ancestor component configured as defaultListenerScope is assumed to be the object with the method.

Defaults to:

null

Available since: 6.2.0

fullscreen : Boolean

immutable imm

<ext-numbercolumn fullscreen="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.fullscreen = true;
let fullscreen = element.fullscreen;

Force the component to take up 100% width and height available, by adding it to Ext.Viewport.

groupHeaderTpl : String / String[] / Ext.XTemplate

<ext-numbercolumn groupHeaderTpl="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.groupHeaderTpl = 'value';
let groupHeaderTpl = element.groupHeaderTpl;

This config allows a column to replace the default template supplied by the grid's groupHeader.tpl.

Defaults to:

null

Available since: 6.5.0

groupable : Boolean

<ext-numbercolumn groupable="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.groupable = true;
let groupable = element.groupable;

If the grid is grouped, the menu for this column will offer to "Group by this column" if this is set to true.

If using the gridviewoptions plugin, this option may be used to disable the option to group by this column.

Defaults to:

true

grouper : Function / String / Object / Ext.util.Grouper

<ext-numbercolumn grouper="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.grouper = 'value';
let grouper = element.grouper;

A grouper config object to apply when the standard grouping user interface is is invoked. This option is, for example, available in the column's header menu.

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

A Ext.app.ViewController method can be used like so:

 grouper: 'groupMethodName'

This is different then a sorter in that the grouper method is used to set the groupFn. This string returned by this method is used to determine group membership. To specify both the grpoupFn and the sorterFn:

 grouper: {
     groupFn: 'groupMethodName'
     sorterFn: 'sorterMethodName
 }

Defaults to:

null

Available since: 6.5.0

hasFocus : Boolean

readonly ro

<ext-numbercolumn hasFocus="true" />

let element = document.body.querySelector('ext-numbercolumn');
let hasFocus = element.hasFocus;

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

Defaults to:

false

hasListeners : Object

readonly ro

<ext-numbercolumn hasListeners="{ }" />

let element = document.body.querySelector('ext-numbercolumn');
let hasListeners = element.hasListeners;

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

height : Number / String

<ext-numbercolumn height="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.height = 'value';
let height = element.height;

The height of this Component; must be a valid CSS length value, e.g: 300, 100px, 30%, etc. By default, if this is not explicitly set, this Component's element will simply have its own natural size. If set to auto, it will set the width to null meaning it will have its own natural size.

Defaults to:

null

hidden : Boolean

<ext-numbercolumn hidden="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.hidden = true;
let hidden = element.hidden;

Whether or not this Component is hidden (its CSS display property is set to none).

Defaults to true for floated Components.

Defaults to:

null

hideAnimation : String / Mixed

<ext-numbercolumn hideAnimation="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.hideAnimation = 'value';
let hideAnimation = element.hideAnimation;

Animation effect to apply when the Component is being hidden. Typically you want to use an outbound animation type such as 'fadeOut' or 'slideOut'. For more animations, check the Ext.fx.Animation#type config.

Defaults to:

null

hideMode : 'clip' / 'display' / 'offsets' / 'opacity' / 'visibility'

<ext-numbercolumn hideMode="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.hideMode = 'value';
let hideMode = element.hideMode;

A String which specifies how this component's DOM element will be hidden. The accepted values are any of these:

• 'clip' : Hide using clip.
• 'display' : Hide using display.
• 'offsets' : Hide using positioning offsets.
• 'opacity' : Hide using opacity.
• 'visibility' : Hide using visibility.

Hiding using display results in having no dimensions as well as resetting scroll positions to 0.

The other modes overcome this but may have different trade-offs in certain circumstances.

Defaults to:

'display'

Available since: 6.5.0

hideOnMaskTap : Boolean

<ext-numbercolumn hideOnMaskTap="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.hideOnMaskTap = true;
let hideOnMaskTap = element.hideOnMaskTap;

When using a modal Component, setting this to true will hide the modal mask and the Container when the mask is tapped on.

Defaults to:

null

hideable : Boolean

<ext-numbercolumn hideable="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.hideable = true;
let hideable = element.hideable;

False to prevent the user from hiding this column.

Defaults to:

true

Available since: 6.5.0

html : String / Ext.dom.Element / HTMLElement

<ext-numbercolumn html="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.html = 'value';
let html = element.html;

Optional HTML content to render inside this Component, or a reference to an existing element on the page.

Defaults to:

null

id : String

immutable imm

<ext-numbercolumn id="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.id = 'value';
let id = element.id;

The unique id of this component instance.

It should not be necessary to use this configuration except for singleton objects in your application. Components created with an id may be accessed globally using Ext.getCmp.

Instead of using assigned ids, use the itemId config, and Ext.ComponentQuery which provides selector-based searching for Sencha Components analogous to DOM querying. The <ext-container/> class contains 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.

Note: to avoid complications imposed by a unique id also see itemId.

Defaults to an auto-assigned id.

ignore : Boolean

<ext-numbercolumn ignore="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.ignore = true;
let ignore = element.ignore;

Setting to true prevents this column from being used by plugins such as gridviewoptions or Ext.grid.plugin.Summary. It is intended for special columns such as the row number or checkbox selection.

Defaults to:

false

ignoreExport : Boolean

<ext-numbercolumn ignoreExport="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.ignoreExport = true;
let ignoreExport = element.ignoreExport;

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. You can set this flag on any column that you want to be ignored during export.

This is used by gridexporter.

Defaults to:

false

inactiveChildTabIndex : Number

immutable imm

<ext-numbercolumn inactiveChildTabIndex="10" />

let element = document.body.querySelector('ext-numbercolumn');
element.inactiveChildTabIndex = 10;
let inactiveChildTabIndex = element.inactiveChildTabIndex;

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

inheritUi : Boolean / String

readonly ro

<ext-numbercolumn inheritUi="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.inheritUi = true;
let inheritUi = element.inheritUi;

Set to true on widgets that should inherit ui from their parent container. This property is typically set on the class body, but can be set on an instance as long as it is set prior to the instance being added to its container. This property is inspected at the moment a widget is added to a container, and any UIs on the container are added to the widget at that time. Inherited UIs are in addition to the widget's own ui, and are updated when the container's UI changes.

Defaults to:

false

innerCls : String

<ext-numbercolumn innerCls="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.innerCls = 'value';
let innerCls = element.innerCls;

A string to add to the immediate parent element of the inner items of this container. That is, items that are not docked, positioned or floated. In some containers, positioned items may be in this same element.

Defaults to:

null

Available since: 6.5.0

isContainer : Boolean

readonly ro

<ext-numbercolumn isContainer="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.isContainer = true;
let isContainer = element.isContainer;

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

Defaults to:

true

isGridColumn : Boolean

readonly ro

<ext-numbercolumn isGridColumn="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.isGridColumn = true;
let isGridColumn = element.isGridColumn;

Set in this class to identify, at runtime, instances which are not instances of the HeaderContainer base class, but are in fact, the subclass: Ext.grid.Column.

Defaults to:

true

isHeaderContainer : Boolean

readonly ro

<ext-numbercolumn isHeaderContainer="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.isHeaderContainer = true;
let isHeaderContainer = element.isHeaderContainer;

true in this class to identify an object this type, or subclass thereof.

Defaults to:

true

isHeaderGroup : Boolean

readonly ro

<ext-numbercolumn isHeaderGroup="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.isHeaderGroup = true;
let isHeaderGroup = element.isHeaderGroup;

This will be set to true if the column has child columns.

isLeafHeader : Boolean

readonly ro

<ext-numbercolumn isLeafHeader="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.isLeafHeader = true;
let isLeafHeader = element.isLeafHeader;

This will be set to true if the column has no child columns.

isObservable : Boolean

readonly ro

<ext-numbercolumn isObservable="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.isObservable = true;
let isObservable = element.isObservable;

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

Defaults to:

true

itemId : String

<ext-numbercolumn itemId="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.itemId = 'value';
let itemId = element.itemId;

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 Ext#getCmp, use itemId with Ext.Container#getComponent which will retrieve itemId's or id's. Since itemId's are an index to the container's internal MixedCollection, the itemId is scoped locally to the container - avoiding potential conflicts with Ext.ComponentManager which requires a unique id.

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

Defaults to:

undefined

keyMap : Object

<ext-numbercolumn keyMap="{ }" />

let element = document.body.querySelector('ext-numbercolumn');
element.keyMap = { };
let keyMap = element.keyMap;

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

<ext-numbercolumn keyMapEnabled="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.keyMapEnabled = true;
let keyMapEnabled = element.keyMapEnabled;

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

lastKeyMapEvent : Ext.event.Event

readonly ro

<ext-numbercolumn lastKeyMapEvent="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.lastKeyMapEvent = 'value';
let lastKeyMapEvent = element.lastKeyMapEvent;

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

Available since: 6.6.0

layout : Object / String

<ext-numbercolumn layout="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.layout = 'value';
let layout = element.layout;

Configuration for this Container's layout. Example:

Ext.create({
    xtype: 'container',
    layout: {
        type: 'hbox',
        align: 'middle'
    },
    items: [{
        xtype: 'panel',
        flex: 1,
        bodyStyle: {
            background: "#000",
            color:"#fff"
        }
    }, {
       xtype: 'panel',
       flex: 2,
       bodyStyle: {
           background: "#f00",
           color:"#fff"
       }
    }]
});

Defaults to:

'auto'

left : Number / String

<ext-numbercolumn left="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.left = 'value';
let left = element.left;

The absolute left position of this Component; must be a valid CSS length value, e.g: 300, 100px, 30%, etc. Explicitly setting this value will make this Component become 'positioned', which means it will no longer participate in the layout of the Container that it resides in.

Defaults to:

null

listeners : Object

<ext-numbercolumn listeners="{ }" />

let element = document.body.querySelector('ext-numbercolumn');
element.listeners = { };
let listeners = element.listeners;

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

locked : Boolean / String

<ext-numbercolumn locked="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.locked = true;
let locked = element.locked;

This config can be used with Locking Grid Determines whether the column is locked or not. Configure as true to lock the column to default locked region <ext-lockedgrid/> String values contains one of the defined locking regions - "left", "right" or "center"

Defaults to:

null

margin : Number / String

<ext-numbercolumn margin="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.margin = 'value';
let margin = element.margin;

The margin to use on this Component. Can be specified as a number (in which case all edges get the same margin) or a CSS string like '5 10 10 10'

Defaults to:

null

masked : Boolean / String / Object / <ext-mask/> / <ext-loadmask/>

<ext-numbercolumn masked="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.masked = true;
let masked = element.masked;

A configuration to allow you to mask this container.

If the value is a string, it will be used as the message config for an <ext-loadmask/>.

For more precise control over the mask, you can optionally pass an object block with and xtype of loadmask, and an optional message value to display a loading mask. Please refer to the <ext-loadmask/> component to see other configurations.

Ext.create({
    xtype: 'container',
    fullscreen: true,
    html: 'Hello World',
    masked: {
        xtype: 'loadmask',
        message: 'My Message'
    }
});

Alternatively, you can just call the setter at any time with true/false to show/hide the mask:

setMasked(true); //show the mask
setMasked(false); //hides the mask

There are also two convenient methods, method-mask and unmask, to allow you to mask and unmask this container at any time.

Remember, the Ext.Viewport is always a container, so if you want to mask your whole application at anytime, can call:

Ext.Viewport.setMasked({
    xtype: 'loadmask',
    message: 'Hello'
});

Defaults to:

null

maxHeight : Number / String

<ext-numbercolumn maxHeight="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.maxHeight = 'value';
let maxHeight = element.maxHeight;

The maximum height of this Component; must be a valid CSS length value, e.g: 300, 100px, 30%, etc. If set to auto, it will set the width to null meaning it will have its own natural size. Note that this config will not apply if the Component is 'positioned' (absolutely positioned or centered)

Defaults to:

null

maxWidth : Number / String

<ext-numbercolumn maxWidth="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.maxWidth = 'value';
let maxWidth = element.maxWidth;

The maximum width of this Component; must be a valid CSS length value, e.g: 300, 100px, 30%, etc. If set to auto, it will set the width to null meaning it will have its own natural size. Note that this config will not apply if the Component is 'positioned' (absolutely positioned or centered)

Defaults to:

null

menu : <ext-menu/> / Object

<ext-numbercolumn menu="{ }" />

let element = document.body.querySelector('ext-numbercolumn');
element.menu = { };
let menu = element.menu;

An optional menu configuration object which is merged with the grid's columnMenu to create this column's header menu. This can be set to null to remove the menu from this column. To dynamically change whether the menu should be enabled or not use the menuDisabled config.

The grid's columnMenu provides the sort items, this config can be used to add column-specific menu items or override aspects of the common items.

Defaults to:

{}

Available since: 6.5.0

menuDisabled : Boolean

<ext-numbercolumn menuDisabled="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.menuDisabled = true;
let menuDisabled = element.menuDisabled;

Set to true to disable this column's menu containing sort/hide options. This can be useful if the menu will be dynamically available since setting menu to null will eliminate the menu making dynamic changes to its availability more expensive.

Defaults to:

false

Available since: 6.5.0

minHeight : Number / String

<ext-numbercolumn minHeight="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.minHeight = 'value';
let minHeight = element.minHeight;

The minimum height of this Component; must be a valid CSS length value, e.g: 300, 100px, 30%, etc. If set to auto, it will set the width to null meaning it will have its own natural size.

Defaults to:

null

minWidth : Number / String

<ext-numbercolumn minWidth="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.minWidth = 'value';
let minWidth = element.minWidth;

The minimum width of this Component; must be a valid CSS length value, e.g: 300, 100px, 30%, etc. If set to auto, it will set the width to null meaning it will have its own natural size.

Defaults to:

null

modal : Boolean

<ext-numbercolumn modal="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.modal = true;
let modal = element.modal;

true to make this Component modal. This will create a mask underneath the Component that covers its parent and does not allow the user to interact with any other Components until this Component is dismissed.

Defaults to:

null

modelValidation : Boolean

immutable imm

<ext-numbercolumn modelValidation="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.modelValidation = true;
let modelValidation = element.modelValidation;

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

When set to true by a component (or by an ancestor container), the validators of for any {@Ext.data.Model record} fields will be used wherever the value is bound to such data fields.

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

Defaults to:

null

Available since: 6.5.0

name : String

immutable imm

<ext-numbercolumn name="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.name = 'value';
let name = element.name;

Name for the widget to be used with Ext.Container#lookupName et al.

Defaults to:

null

nameHolder : Boolean

immutable imm

<ext-numbercolumn nameHolder="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.nameHolder = true;
let nameHolder = element.nameHolder;

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

Defaults to:

false

nameable : Boolean

immutable imm

<ext-numbercolumn nameable="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.nameable = true;
let nameable = element.nameable;

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

Defaults to:

false

padding : Number / String

<ext-numbercolumn padding="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.padding = 'value';
let padding = element.padding;

The padding to use on this Component. Can be specified as a number (in which case all edges get the same padding) or a CSS string like '5 10 10 10'

Defaults to:

null

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

<ext-numbercolumn plugins="{ }" />

let element = document.body.querySelector('ext-numbercolumn');
element.plugins = { };
let plugins = element.plugins;

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:

 var list = Ext.create({
     xtype: 'list',
     itemTpl: '<div class="item">{title}</div>',
     store: 'Items',

     plugins: 'listpaging'
 });

In the above examples, the string "listpaging" is the type alias for listpaging. The full alias includes the "plugin." prefix (i.e., 'plugin.listpaging').

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

 var list = Ext.create({
     xtype: 'list',
     itemTpl: '<div class="item">{title}</div>',
     store: 'Items',

     plugins: {
         pullrefresh: true,
         listpaging: {
             autoPaging: true,
             weight: 10
         }
     }
 });

The object keys are the id's as well as the default type alias. This form allows the value of the plugins to be merged from base class to derived class and finally with the instance configuration. This allows classes to define a set of plugins that derived classes or instantiators can further configure or disable. This merge behavior is a feature of the config.

The plugins config can also be an array of plugin aliases (arrays are not merged so this form does not respect plugins defined by the class author):

 var list = Ext.create({
     xtype: 'list',
     itemTpl: '<div class="item">{title}</div>',
     store: 'Items',

     plugins: ['listpaging', 'pullrefresh']
 });

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

 var list = Ext.create({
     xtype: 'list',
     itemTpl: '<div class="item">{title}</div>',
     store: 'Items',

     plugins: ['pullrefresh', {
         type: 'listpaging',
         autoPaging: true
     }]
 });

Defaults to:

null

publishes : String / String[] / Object

<ext-numbercolumn publishes="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.publishes = 'value';
let publishes = element.publishes;

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

record : Ext.data.Model

<ext-numbercolumn record="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.record = 'value';
let record = element.record;

A model instance which updates the Component's html based on it's tpl. Similar to the data configuration, but tied to to a record to make allow dynamic updates. This must be a model instance and not a configuration of one.

Defaults to:

null

reference : String

immutable imm

<ext-numbercolumn reference="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.reference = 'value';
let reference = element.reference;

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

immutable imm

<ext-numbercolumn referenceHolder="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.referenceHolder = true;
let referenceHolder = element.referenceHolder;

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

relative : Boolean

<ext-numbercolumn relative="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.relative = true;
let relative = element.relative;

Only valid when a component is cfg-floated

Configure this as true if you require descendant floated components to be positioned relative to this component's coordinate space, not the viewport's coordinate space.

Note: The coordinate space is this Component's encapsulating element's area. Not that of the inner element in which static child items are rendered by the layout.

Defaults to:

false

Available since: 6.2.0

rendered : Boolean

readonly ro

<ext-numbercolumn rendered="true" />

let element = document.body.querySelector('ext-numbercolumn');
let rendered = element.rendered;

The rendered flag is set when a widget is inserted into the document for the first time.

Note that this is a one-way operation. The first time a widget is inserted into the document, this flag is set, and it is never unset.

renderer : Function / String

<ext-numbercolumn renderer="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.renderer = 'value';
let renderer = element.renderer;

A renderer is a method which can be used to transform data (value, appearance, etc.) before it is rendered.

For example:

 {
     text: 'Some column',
     dataIndex: 'fieldName',

     renderer: function(value, record) {
         if (value === 1) {
             return '1 person';
         }
         return value + ' people';
     }
 }

If a string is supplied, it should be the name of a renderer method from the appropriate Ext.app.ViewController.

This config is only processed if the cell type is the default of <ext-gridcell/>.

Note See <ext-grid/> documentation for other, better alternatives to rendering cell content.

Defaults to:

null

Properties

value : Object

The data value for the current cell.

record : Ext.data.Model

The record for the current row.

dataIndex : Number

The dataIndex of the current column.

cell : Ext.grid.cell.Base

The current cell.

column : Ext.grid.column.Column

The current column.

return : String

The HTML string to be rendered. Note: to render HTML into the cell, you will have to configure the column's cell with encodeHtml: false

resetFocusPosition : Boolean

immutable imm

<ext-numbercolumn resetFocusPosition="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.resetFocusPosition = true;
let resetFocusPosition = element.resetFocusPosition;

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

<ext-numbercolumn resizable="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.resizable = true;
let resizable = element.resizable;

False to prevent the column from being resizable. Note that this configuration only works when the columnresizing plugin is enabled on the <ext-grid/>.

Defaults to:

true

right : Number / String

<ext-numbercolumn right="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.right = 'value';
let right = element.right;

The absolute right position of this Component; must be a valid CSS length value, e.g: 300, 100px, 30%, etc. Explicitly setting this value will make this Component become 'positioned', which means it will no longer participate in the layout of the Container that it resides in.

Defaults to:

null

ripple : Boolean / Object / String

<ext-numbercolumn ripple="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.ripple = true;
let ripple = element.ripple;

Set to truthy, Color or Object value for the ripple.

Defaults to:

null

Available since: 6.5.0

Properties

color : String

The background color of the ripple.

position : Array

Position for the ripple to start at [x,y]. Determines if a Ripple effect should happen whenever this element is pressed.

For example: { ripple: true }

Or:

 {
     ripple: {
         color: 'red'
     }
 }

For complex components, individual elements can suppress ripples by adding the x-no-ripple class to disable rippling for a tree of elements.

scope : Object

<ext-numbercolumn scope="{ }" />

let element = document.body.querySelector('ext-numbercolumn');
element.scope = { };
let scope = element.scope;

The scope to use when calling the renderer or formatter function.

Defaults to:

null

scrollable : Boolean / String / Object

<ext-numbercolumn scrollable="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.scrollable = true;
let scrollable = element.scrollable;

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

session : Boolean / Object / Ext.data.Session

<ext-numbercolumn session="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.session = true;
let session = element.session;

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

<ext-numbercolumn shadow="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.shadow = true;
let shadow = element.shadow;

Configure as true for the component to have a drop shadow. 'false' will suppress any default shadow. By default the theme will determine the presence of a shadow.

Defaults to:

null

Available since: 6.2.0

shareableName : Boolean

immutable imm

<ext-numbercolumn shareableName="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.shareableName = true;
let shareableName = element.shareableName;

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

<ext-numbercolumn shim="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.shim = true;
let shim = element.shim;

Only valid when a component is cfg-floated

Configure as true for the component to use an <iframe> as an underlay to ensure certain non-standard browser plugins are occluded by this component.

Defaults to:

false

Available since: 6.2.0

showAnimation : String / Mixed

<ext-numbercolumn showAnimation="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.showAnimation = 'value';
let showAnimation = element.showAnimation;

Animation effect to apply when the Component is being shown. Typically you want to use an inbound animation type such as 'fadeIn' or 'slideIn'. For more animations, check the Ext.fx.Animation#type config.

Defaults to:

null

sortable : Boolean

<ext-numbercolumn sortable="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.sortable = true;
let sortable = element.sortable;

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

Defaults to:

true

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

<ext-numbercolumn sorter="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.sorter = 'value';
let sorter = element.sorter;

A sorter config object to apply when the standard sort user interface is 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.

A Ext.app.ViewController method can be used like so:

 sorter: 'sorterMethodName'

Or more explicitly:

 sorter: {
     sorterFn: 'sorterMethodName'
 }

By default sorting is based on the dataIndex but this can be adjusted like so:

 sorter: {
     property: 'otherProperty'
 }

Defaults to:

true

Available since: 6.5.0

stateId : String

<ext-numbercolumn stateId="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.stateId = 'value';
let stateId = element.stateId;

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

Defaults to:

null

stateful : Boolean / Object / String[]

<ext-numbercolumn stateful="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.stateful = true;
let stateful = element.stateful;

This config specifies the config properties that will be persisted using the Ext.state.Provider. If this config is set to true, the configs specified by statefulDefaults will be assumed.

 stateful: true

Otherwise, this config can be an array of strings of the properties to save:

 stateful: [
     'width',
     'height',
     'collapsed'
 ]

The above is equivalent to:

 stateful: {
     width: true,
     height: true,
     collapsed: true
 }

Note: To be truly stateful, an id or stateId must also be assigned.

A stateful object will save its state when any of these config properties change value.

Defaults to:

false

style : String / Object

<ext-numbercolumn style="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.style = 'value';
let style = element.style;

Additional CSS styles that will be rendered into an inline style attribute when the widget is rendered.

You can pass either a string syntax:

style: 'background:red'

Or by using an object:

style: {
    background: 'red'
}

When using the object syntax, you can define CSS Properties by using a string:

style: {
    'border-left': '1px solid red'
}

Although the object syntax is much easier to read, we suggest you to use the string syntax for better performance.

Defaults to:

null

summary : String

<ext-numbercolumn summary="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.summary = 'value';
let summary = element.summary;

This config replaces the default mechanism of acquiring a summary result from the summary record. When specified, this string is the name of a summary type:

• Ext.data.summary.Average
• Ext.data.summary.Count
• Ext.data.summary.Max
• Ext.data.summary.Min
• Ext.data.summary.Sum

The summary is based on either the summaryDataIndex or the dataIndex if there is no summaryDataIndex.

This config is only valid when all data is available client-side to calculate summaries.

It is generally best to allow the summary Ext.data.Model to computer summary values (and not use this config). In some cases, however, this config can be useful to isolate summary calculations to only certain grids.

To implement a custom summary for a column, use summaryRenderer.

Defaults to:

null

Available since: 6.5.0

summaryCell : Object

<ext-numbercolumn summaryCell="{ }" />

let element = document.body.querySelector('ext-numbercolumn');
element.summaryCell = { };
let summaryCell = element.summaryCell;

The config object used to create <ext-gridcellbase/> in <ext-gridsummaryrow/> for this column.

Defaults to:

null

summaryDataIndex : String

<ext-numbercolumn summaryDataIndex="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.summaryDataIndex = 'value';
let summaryDataIndex = element.summaryDataIndex;

For <ext-gridsummaryrow/> this config overrides the normal dataIndex to use from the summary record.

Defaults to:

null

Available since: 6.5.0

summaryFormatter : String

<ext-numbercolumn summaryFormatter="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.summaryFormatter = 'value';
let summaryFormatter = element.summaryFormatter;

This summaryFormatter is similar to formatter but is called before displaying a value in the SummaryRow. The config is optional, if not specified the default calculated value is shown. The summaryFormatter is called with:

• value: The calculated value.

Note that this configuration only works when the grid has the Ext.grid.plugin.Summary plugin enabled.

Defaults to:

null

summaryRenderer : Function / String

<ext-numbercolumn summaryRenderer="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.summaryRenderer = 'value';
let summaryRenderer = element.summaryRenderer;

This summaryRenderer is called to render the value to display in a cell of a summary row. If the value of this config is a String, it is the name of the renderer method on the associated controller.

Defaults to:

null

Properties

value : Mixed

The summary value to render. This value is retrieved from the summary record based on the summaryDataIndex or dataIndex, or by applying the summary algorithm to the appropriate records. While this value can be useful, it can also be ignored and the renderer method can use the context information to determine the value to render entirely on its own.

context : Object

The summary context object.

tabIndex : Number

<ext-numbercolumn tabIndex="10" />

let element = document.body.querySelector('ext-numbercolumn');
element.tabIndex = 10;
let tabIndex = element.tabIndex;

DOM tabIndex attribute for this component's focusEl.

Defaults to:

null

text : String

<ext-numbercolumn text="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.text = 'value';
let text = element.text;

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

Note: to have a clickable header with no text displayed you can use the default non-breaking space ( ).

Defaults to:

'\xa0'

toFrontOnShow : Boolean

<ext-numbercolumn toFrontOnShow="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.toFrontOnShow = true;
let toFrontOnShow = element.toFrontOnShow;

True to automatically call toFront when a cfg-floated Component is shown.

Defaults to:

true

toolDefaults : Object

<ext-numbercolumn toolDefaults="{ }" />

let element = document.body.querySelector('ext-numbercolumn');
element.toolDefaults = { };
let toolDefaults = element.toolDefaults;

The properties of this object are shallow copied (via applyIf() as opposed to Ext.merge() to each tool declared in the tools config.

Defaults to:

{
    xtype: 'tool',
    zone: 'end'
}

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

<ext-numbercolumn tools="{ }" />

let element = document.body.querySelector('ext-numbercolumn');
element.tools = { };
let tools = element.tools;

An array of <ext-tool/> <ext-paneltool/> configs or an object keyed by itemId.

Defaults to:

null

tooltip : String / Object

<ext-numbercolumn tooltip="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.tooltip = 'value';
let tooltip = element.tooltip;

The tooltip for this component - can be a string to be used as innerHTML (html tags are accepted) or <ext-tooltip/> config object.

The default behavior is to use a shared tip instance. The tooltip configuration is registered with the Ext.tip.Manager. To enable this, your application can set the Ext.app.Application#quickTips config, or an instance of the Ext.tip.Manager may be created manually.

To force a unique tooltip instance to be created, specify autoCreate: true on this configuration.

Configuring this with autoHide: false implies autoCreate: true so that the desired persistent behavior can be obtained with other targets still showing the singleton instance.

Defaults to:

null

top : Number / String

<ext-numbercolumn top="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.top = 'value';
let top = element.top;

The absolute top position of this Component; must be a valid CSS length value, e.g: 300, 100px, 30%, etc. Explicitly setting this value will make this Component become 'positioned', which means it will no longer participate in the layout of the Container that it resides in.

Defaults to:

null

touchAction : Object

<ext-numbercolumn touchAction="{ }" />

let element = document.body.querySelector('ext-numbercolumn');
element.touchAction = { };
let touchAction = element.touchAction;

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 reference elements using the reference 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.Widget', {
    touchAction: {
        panX: false
    },
    listeners: {
        drag: function(e) {
            // implement drag logic
        }
    }
});

Defaults to:

null

tpl : String / String[] / Ext.XTemplate

<ext-numbercolumn tpl="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.tpl = 'value';
let tpl = element.tpl;

An Ext.XTemplate, or an XTemplate definition string to use to process a Ext.data.Model data to produce a cell's rendered value.

Ext.create('Ext.data.Store', {
    storeId:'employeeStore',
    fields:['firstname', 'lastname', 'seniority', 'department'],
    groupField: 'department',
    data:[
        { firstname: "Michael", lastname: "Scott",   seniority: 7, department: "Management" },
        { firstname: "Dwight",  lastname: "Schrute", seniority: 2, department: "Sales" },
        { firstname: "Jim",     lastname: "Halpert", seniority: 3, department: "Sales" },
        { firstname: "Kevin",   lastname: "Malone",  seniority: 4, department: "Accounting" },
        { firstname: "Angela",  lastname: "Martin",  seniority: 5, department: "Accounting" }
    ]
});

Ext.create('Ext.grid.Panel', {
    title: 'Column Template Demo',
    store: Ext.data.StoreManager.lookup('employeeStore'),
    columns: [{
        text: 'Full Name',
        tpl: '{firstname} {lastname}'
    }, {
        text: 'Department (Yrs)',
        tpl: '{department} ({seniority})'
    }],
    height: 200,
    width: 300,
    renderTo: Ext.getBody()
});

This config is only processed if the cell type is the default of <ext-gridcell/>.

Note See <ext-grid/> documentation for other, better alternatives to rendering cell content.

Defaults to:

null

tplWriteMode : String

<ext-numbercolumn tplWriteMode="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.tplWriteMode = 'value';
let tplWriteMode = element.tplWriteMode;

The Ext.(X)Template method to use when updating the content area of the Component.

Valid modes are:

• append
• insertAfter
• insertBefore
• insertFirst
• overwrite

Defaults to:

'overwrite'

twoWayBindable : String / String[] / Object

<ext-numbercolumn twoWayBindable="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.twoWayBindable = 'value';
let twoWayBindable = element.twoWayBindable;

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 / String[]

<ext-numbercolumn ui="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.ui = 'value';
let ui = element.ui;

The ui or uis to be used on this Component

When a ui is configured, CSS class names are added to the element, created by appending the ui name(s) to each classCls and/or baseCls.

Defaults to:

null

userCls : String / String[]

<ext-numbercolumn userCls="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.userCls = 'value';
let userCls = element.userCls;

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

userSelectable : Boolean / String / Object

<ext-numbercolumn userSelectable="true" />

let element = document.body.querySelector('ext-numbercolumn');
element.userSelectable = true;
let userSelectable = element.userSelectable;

Set to true to allow users to select text within this component.

Can also be any valid value for the CSS3 user-select property.

A value of true implies auto, while false implies none.

May also be an object keyed by child element name.

By default, the user cannot click+drag+select text/elements of the UI. Applications may want to enable user selection for specific DOM elements, such as the bodyElement of a component used as a tab panel. The tab and tab text would not be user selectable in this example, but the content area when the tab is selected would.

 userSelectable: {
     element: true,       // allow the element to be user selectable
     bodyElement: true    // allow the component's body element to be user selectable
 }

Defaults to:

false

Available since: 6.5.1

viewModel : String / Object / Ext.app.ViewModel

<ext-numbercolumn viewModel="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.viewModel = 'value';
let viewModel = element.viewModel;

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

<ext-numbercolumn weight="10" />

let element = document.body.querySelector('ext-numbercolumn');
element.weight = 10;
let weight = element.weight;

This value controls this item's order in a weighted <ext-container/> (see parent).

Lower values gravitate towards the start of the container - the top in vertical layouts, the locale start side in horizontal layouts.

Defaults to:

0

width : Number / String

<ext-numbercolumn width="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.width = 'value';
let width = element.width;

The width of this Component; must be a valid CSS length value, e.g: 300, 100px, 30%, etc. By default, if this is not explicitly set, this Component's element will simply have its own natural size. If set to auto, it will set the width to null meaning it will have its own natural size.

Defaults to:

null

x : Number

<ext-numbercolumn x="10" />

let element = document.body.querySelector('ext-numbercolumn');
element.x = 10;
let x = element.x;

Only valid when a component is cfg-floated

The x position at which to position this component. This is usually viewport-relative. But if there is a relative: true ancestor, it will be relative to that.

Defaults to:

0

xtype : String

immutable imm

<ext-numbercolumn xtype="value" />

let element = document.body.querySelector('ext-numbercolumn');
element.xtype = 'value';
let xtype = element.xtype;

The xtype configuration option can be used to optimize Component creation and rendering. It serves as a shortcut to the full component name. For example, the component Ext.button.Button has an xtype of button.

You can define your own xtype on a custom <ext-component/> like so:

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

Any Component can be created implicitly as an object config with an xtype specified, allowing it to be declared and passed into the rendering pipeline without actually being instantiated as an object. Not only is rendering deferred, but the actual creation of the object itself is also deferred, saving memory and resources until they are actually needed. In complex, nested layouts containing many Components, this can make a noticeable improvement in performance.

// Explicit creation of contained Components:
var panel = new Ext.Panel({
   // ...
   items: [
      Ext.create('Ext.button.Button', {
         text: 'OK'
      })
   ]
});

// Implicit creation using xtype:
var panel = new Ext.Panel({
   // ...
   items: [{
      xtype: 'button',
      text: 'OK'
   }]
});

In the first example, the button will always be created immediately during the panel's initialization. With many added Components, this approach could potentially slow the rendering of the page. In the second example, the button will not be created or rendered until the panel is actually displayed in the browser. If the panel is never displayed (for example, if it is a tab that remains hidden) then the button will never be created and will never consume any resources whatsoever.

y : Number

<ext-numbercolumn y="10" />

let element = document.body.querySelector('ext-numbercolumn');
element.y = 10;
let y = element.y;

Only valid when a component is cfg-floated

The x position at which to position this component. This is usually viewport-relative. But if there is a relative: true ancestor, it will be relative to that.

Defaults to:

0

zIndex : Number

<ext-numbercolumn zIndex="10" />

let element = document.body.querySelector('ext-numbercolumn');
element.zIndex = 10;
let zIndex = element.zIndex;

The z-index to give this Component when it is rendered.

Not valid for cfg-floated Components. The Z ordering of cfg-floated Components is managed by ordering of the DOM elements.

Defaults to:

null

add ( newItems ) : Ext.Component/Ext.Component[]

let element = document.body.querySelector('ext-numbercolumn');
let add = element.add(newItems);

Adds one or more Components to this Container. Example:

var myPanel = Ext.create({
    xtype: 'panel',
    html : 'This will be added to a Container'
});

var items = myContainer.add([myPanel]); // Array returned
var item  = myContainer.add(myPanel);   // One item is returned

Parameters

Returns

addAfterListener

let element = document.body.querySelector('ext-numbercolumn');
element.addAfterListener();

Alias for onAfter.

addBeforeListener

let element = document.body.querySelector('ext-numbercolumn');
element.addBeforeListener();

Alias for onBefore.

addCls ( cls, [prefix], [suffix] )

let element = document.body.querySelector('ext-numbercolumn');
element.addCls(cls, prefix, suffix);

Adds a CSS class (or classes) to this Component's rendered element.

Parameters

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

chainable ch

let element = document.body.querySelector('ext-numbercolumn');
let addListener = element.addListener(eventName, fn, scope, options, order);

The on method is shorthand for addListener.

Appends an event handler to this object. For example:

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

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

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

One can also specify options for each event handler separately:

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

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

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

Parameters

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

 panel.body.un(...)

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

false

'current'

Returns

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

Ext.destroy(this.btnListeners);

this.btnListeners.destroy();

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

let element = document.body.querySelector('ext-numbercolumn');
let addManagedListener = element.addManagedListener(item, ename, fn, scope, options);

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

Example:

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

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

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

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

Parameters

Returns

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

Ext.destroy(this.btnListeners);

this.btnListeners.destroy();

addPlugin ( plugin )

let element = document.body.querySelector('ext-numbercolumn');
element.addPlugin(plugin);

Adds a plugin. For example:

 list.addPlugin('pullrefresh');

Or:

 list.addPlugin({
     type: 'pullrefresh',
     pullRefreshText: 'Pull to refresh...'
 });

Available since: 6.2.0

Parameters

afterRender

template tpl

let element = document.body.querySelector('ext-numbercolumn');
element.afterRender();

This method is called after the component is initially added to the DOM. If this component <ext-container/> other components, the afterRender method for child components is called before the parent's afterRender.

Implementations of this method should avoid reading from the DOM but are free to write to the DOM as needed. To read the DOM, consider implementing onRender instead.

This method is not generally needed because components always have their own DOM element and these are maintained by config property updaters prior to insertion in the DOM. In general, it is always best to manipulate the component's elements outside the DOM where there is no associated reflow or layout cost. This method is useful for situations where the component's elements must be in the DOM in order to be manipulated correctly.

Available since: 6.5.0

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

animateActiveItem ( activeItem, animation )

let element = document.body.querySelector('ext-numbercolumn');
element.animateActiveItem(activeItem, animation);

Animates to the supplied activeItem with a specified animation. Currently this only works with a Card layout. This passed animation will override any default animations on the container, for a single card switch. The animation will be destroyed when complete.

Parameters

applyMasked ( masked ) : Object

let element = document.body.querySelector('ext-numbercolumn');
let applyMasked = element.applyMasked(masked);

Changes the masked configuration when its setter is called, which will convert the value into a proper object/instance of <ext-mask/>/<ext-loadmask/>. If a mask already exists, it will use that instead.

Parameters

Returns