The documentation for the ExtReact product diverges somewhat from the
documentation of other Sencha products. The sections below describe
documentation for all products except where indicated as unique to
ExtReact
.
Many classes have shortcut names used when creating (instantiating) a class with a
configuration object. The shortcut name is referred to as an alias
(or xtype
if the
class extends Ext.Component). The alias/xtype is listed next to the class name of
applicable classes for quick reference.
ExtReact component classes list the configurable name prominently at the top of the API class doc followed by the fully-qualified class name.
Framework classes or their members may be specified as private
or protected
. Else,
the class / member is public
. Public
, protected
, and private
are access
descriptors used to convey how and when the class or class member should be used.
Public classes and class members are available for use by any other class or application code and may be relied upon as a stable and persistent within major product versions. Public classes and members may safely be extended via a subclass.
Protected class members are stable public
members intended to be used by the
owning class or its subclasses. Protected members may safely be extended via a subclass.
Private classes and class members are used internally by the framework and are not intended to be used by application developers. Private classes and members may change or be omitted from the framework at any time without notice and should not be relied upon in application logic.
ExtReact component classes display
configuration options as props
ExtReact component classes do not list
properties as a dedicated member type, but rather as
read only
props
static
label next to the
method name. *See Static below.Below is an example class member that we can disect to show the syntax of a class member (the lookupComponent method as viewed from the Ext.button.Button class in this case).
Let's look at each part of the member row:
lookupComponent
in this example)( item )
in this example)Ext.Component
in this case). This may be omitted for methods that do not
return anything other than undefined
or may display as multiple possible values
separated by a forward slash /
signifying that what is returned may depend on the
results of the method call (i.e. a method may return a Component if a get method calls is
successful or false
if unsuccessful which would be displayed as
Ext.Component/Boolean
).PROTECTED
in
this example - see the Flags section below)Ext.container.Container
in this example). The source
class will be displayed as a blue link if the member originates from the current class
and gray if it is inherited from an ancestor or mixed-in class.view source
in the example)item : Object
in the example).undefined
a "Returns" section
will note the type of class or object returned and a description (Ext.Component
in the
example)Available since 3.4.0
- not pictured in
the example) just after the member descriptionDefaults to: false
)The API documentation uses a number of flags to further commnicate the class member's function and intent. The label may be represented by a text label, an abbreviation, or an icon.
All ExtReact props are bindable
unless decorated as immutable
Immutable ExtReact props may not be use as a configurable prop when instantiating a component
classInstance.method1().method2().etc();
false
is returned from
an event handler- Indicates a framework class
- A singleton framework class. *See the singleton flag for more information
- A component-type framework class (any class within the Ext JS framework that extends Ext.Component)
- Indicates that the class, member, or guide is new in the currently viewed version
- Indicates a class member of type config
Or in the case of an ExtReact component class this
indicates a member of type prop
- Indicates a class member of type property
- Indicates a class member of type
method
- Indicates a class member of type event
- Indicates a class member of type
theme variable
- Indicates a class member of type
theme mixin
- Indicates that the class, member, or guide is new in the currently viewed version
Just below the class name on an API doc page is a row of buttons corresponding to the types of members owned by the current class. Each button shows a count of members by type (this count is updated as filters are applied). Clicking the button will navigate you to that member section. Hovering over the member-type button will reveal a popup menu of all members of that type for quick navigation.
Getting and setter methods that correlate to a class config option will show up in the methods section as well as in the configs section of both the API doc and the member-type menus just beneath the config they work with. The getter and setter method documentation will be found in the config row for easy reference.
ExtReact component classes do not hoist the getter /
setter methods into the prop. All methods will be described in the
Methods
section
Your page history is kept in localstorage and displayed (using the available real estate) just below the top title bar. By default, the only search results shown are the pages matching the product / version you're currently viewing. You can expand what is displayed by clicking on the button on the right-hand side of the history bar and choosing the "All" radio option. This will show all recent pages in the history bar for all products / versions.
Within the history config menu you will also see a listing of your recent page visits. The results are filtered by the "Current Product / Version" and "All" radio options. Clicking on the button will clear the history bar as well as the history kept in local storage.
If "All" is selected in the history config menu the checkbox option for "Show product details in the history bar" will be enabled. When checked, the product/version for each historic page will show alongside the page name in the history bar. Hovering the cursor over the page names in the history bar will also show the product/version as a tooltip.
Both API docs and guides can be searched for using the search field at the top of the page.
On API doc pages there is also a filter input field that filters the member rows using the filter string. In addition to filtering by string you can filter the class members by access level, inheritance, and read only. This is done using the checkboxes at the top of the page.
The checkbox at the bottom of the API class navigation tree filters the class list to include or exclude private classes.
Clicking on an empty search field will show your last 10 searches for quick navigation.
Each API doc page (with the exception of Javascript primitives pages) has a menu view of metadata relating to that class. This metadata view will have one or more of the following:
Ext.button.Button
class has an alternate class name of Ext.Button
). Alternate class
names are commonly maintained for backward compatibility.Runnable examples (Fiddles) are expanded on a page by default. You can collapse and expand example code blocks individually using the arrow on the top-left of the code block. You can also toggle the collapse state of all examples using the toggle button on the top-right of the page. The toggle-all state will be remembered between page loads.
Class members are collapsed on a page by default. You can expand and collapse members using the arrow icon on the left of the member row or globally using the expand / collapse all toggle button top-right.
Viewing the docs on narrower screens or browsers will result in a view optimized for a smaller form factor. The primary differences between the desktop and "mobile" view are:
The class source can be viewed by clicking on the class name at the top of an API doc page. The source for class members can be viewed by clicking on the "view source" link on the right-hand side of the member row.
<ext-calendar_timefield alignSelf="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.alignSelf = 'value';
let alignSelf = element.alignSelf;
Specifies the self alignment of this widget in a box layout
Defaults to:
null
<ext-calendar_timefield alignTarget="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.alignTarget = 'value';
let alignTarget = element.alignTarget;
The element reference to which the picker aligns
and sizes to. By default, it sizes to the bodyElement
which encapsulates the
input field and triggers.
An alternate value which may be useful if using floated
pickers on phone platforms
could be el
, to align the picker to the field's encapsulating element.
Defaults to:
'bodyElement'
<ext-calendar_timefield alwaysOnTop="true" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield animateUnderline="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.animateUnderline = true;
let animateUnderline = element.animateUnderline;
'true' to animate the underline of a field when focused
Defaults to:
false
Sets the value of animateUnderline
animateUnderline : Boolean
<ext-calendar_timefield ariaAttributes="{ }" />
let element = document.body.querySelector('ext-calendar_timefield');
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
Sets the value of ariaAttributes
ariaAttributes : Object
<ext-calendar_timefield ariaDescribedBy="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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.
<ext-calendar_timefield ariaLabel="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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.
<ext-calendar_timefield ariaLabelledBy="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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.
<ext-calendar_timefield autoCapitalize="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.autoCapitalize = true;
let autoCapitalize = element.autoCapitalize;
True to set the field's DOM element auto-capitalize attribute to "on", false to set to "off".
Defaults to:
null
Sets the value of autoCapitalize
autoCapitalize : Boolean
<ext-calendar_timefield autoComplete="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.autoComplete = true;
let autoComplete = element.autoComplete;
Autocomplete is disabled on Picker fields by default.
Defaults to:
false
<ext-calendar_timefield autoCorrect="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.autoCorrect = true;
let autoCorrect = element.autoCorrect;
True to set the field DOM element autocorrect attribute to "on", false to set to "off".
Defaults to:
null
<ext-calendar_timefield autoFitErrors="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.autoFitErrors = true;
let autoFitErrors = element.autoFitErrors;
Whether to adjust the field's body width to make room for the error messages.
Defaults to:
true
<ext-calendar_timefield autoFocus="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.autoFocus = true;
let autoFocus = element.autoFocus;
true
to automatically focus the first result gathered by the data store in the
dropdown list when it is opened. A false value would cause nothing in the list
to be highlighted automatically, so the user would have to manually highlight an
item before pressing the enter or tab key to select it
(unless the value of (typeAhead) were true), or use the mouse to select
a value.
Defaults to:
true
<ext-calendar_timefield autoFocusLast="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.autoFocusLast = true;
let autoFocusLast = element.autoFocusLast;
When true
, the last selected record in the dropdown list will be re-selected
upon autoFocus. Set to false
to always select the first record in
the drop-down list. For accessible applications it is recommended to set this
option to false
.
Defaults to:
true
<ext-calendar_timefield autoHideInputMask="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.autoHideInputMask = true;
let autoHideInputMask = element.autoHideInputMask;
Specify as false
to always show the inputMask
.
Defaults to:
true
Available since: 6.5.0
Sets the value of autoHideInputMask
autoHideInputMask : Boolean
<ext-calendar_timefield autoLoadOnValue="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.autoLoadOnValue = true;
let autoLoadOnValue = element.autoLoadOnValue;
This option controls whether to initially load the store when a value is set so that the display value can be determined from the appropriate record.
The store will only be loaded in a limited set of circumstances:
Defaults to:
false
Sets the value of autoLoadOnValue
autoLoadOnValue : Boolean
<ext-calendar_timefield autoSelect="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.autoSelect = true;
let autoSelect = element.autoSelect;
true
to auto select the first value in the store or options
when they are changed. This settings attempts to avoid the value being
set to null
, unless clearable is also true
in which case
only other changes (such as store load) will trigger auto-selection.
If this value is 'initial'
then auto selection will only occur on the first
opportunity (such as initial store load). This config will then be set to
false
.
Defaults to:
false
<ext-calendar_timefield axisLock="true" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield badFormatMessage="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.badFormatMessage = 'value';
let badFormatMessage = element.badFormatMessage;
The error message that will be displayed if the value cannot be parsed (for some derived types) or if the value does not match a configured inputMask.
Defaults to:
'Value does not match the required format'
Available since: 6.5.0
<ext-calendar_timefield bind="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield border="true" />
let element = document.body.querySelector('ext-calendar_timefield');
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).
Ext.Viewport.add({
centered: true,
width: 100,
height: 100,
style: 'border: 1px solid blue;'
// ...
});
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
<ext-calendar_timefield bottom="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield bubbleDirty="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.bubbleDirty = true;
let bubbleDirty = element.bubbleDirty;
Set to false
to disable dirty states affecting ancestor containers such as
fieldpanel
or formpanel
. The dirty state of such containers is based on the
presence of dirty descendants. In some cases, however, it may be desired to
hide the dirty state of one of these containers from its ancestor containers.
Defaults to:
true
Available since: 7.0
<ext-calendar_timefield centered="true" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield chipView="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.chipView = 'value';
let chipView = element.chipView;
A configuration object which may be specified to configure the
<ext-chipview/> used to display "tags" representing selected items
when multiSelect is true
.
Defaults to:
{ xtype: 'chipview', tabIndex: null, focusable: false, itemsFocusable: false, focusedCls: '', navigationModel: 'fieldchipview', selectable: { mode: 'multi' }, closable: true, closeHandler: 'up.onChipCloseTap' }
Available since: 6.7.0
<ext-calendar_timefield clearable="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.clearable = true;
let clearable = element.clearable;
true
to show a clear trigger in this field when it has a non-empty value
Defaults to:
true
<ext-calendar_timefield cls="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield collapseOnSelect="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.collapseOnSelect = true;
let collapseOnSelect = element.collapseOnSelect;
Has no effect if multiSelect is false
Configure as true to automatically hide the picker after a selection is made.
Defaults to:
false
Sets the value of collapseOnSelect
collapseOnSelect : Boolean
<ext-calendar_timefield constrainAlign="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
Returns the value of constrainAlign
Sets the value of constrainAlign
constrainAlign : String / Ext.util.Region / Ext.dom.Element
<ext-calendar_timefield contentEl="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
Returns the value of contentEl
Ext.dom.Element / HTMLElement / String
Sets the value of contentEl
contentEl : Ext.dom.Element / HTMLElement / String
<ext-calendar_timefield controller="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
let element = document.body.querySelector('ext-calendar_timefield');
let getController = element.getController();
Returns the Ext.app.ViewController instance associated with this component via the controller config or setController method.
Returns this component's ViewController or null if one was not configured
Sets the value of controller
controller : String / Object / Ext.app.ViewController
<ext-calendar_timefield data="{ }" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield dataType="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.dataType = 'value';
let dataType = element.dataType;
A config for a Ext.data.field.Field or data field sub-class instance
used to serialize this field's value for form submission. This is used by the
serialize method unless modelValidation
is used, in which case, the
data field of the bound Ext.data.Model is used.
For example:
{
xtype: 'datefield',
dataType: {
// type: 'date' (datefield does this by default)
dateWriteFormat: 'Y-m-d'
}
}
If this config is a string, it is used to create a Ext.data.field.Field by that alias.
Defaults to:
null
Available since: 7.0
Sets the value of dataType
dataType : Ext.data.field.Field / Object / String
<ext-calendar_timefield defaultListenerScope="true" />
let element = document.body.querySelector('ext-calendar_timefield');
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
Sets the value of defaultListenerScope
defaultListenerScope : Boolean
<ext-calendar_timefield delimiter="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.delimiter = 'value';
let delimiter = element.delimiter;
The character(s) used to separate new values to be added when createNewOnEnter or createNewOnBlur are set.
Only meaningful when multiSelect is true
.
Defaults to:
','
<ext-calendar_timefield dirty="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.dirty = true;
let dirty = element.dirty;
This config property describes the modified state of this component. In most cases this config's value is maintained by the component and should be considered readonly. The class implementor should be the only one to call the setter.
For containers, this config will be updated on a short delay in some cases.
Defaults to:
false
Available since: 7.0
<ext-calendar_timefield disabled="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.disabled = true;
let disabled = element.disabled;
true
to disable the field.
Be aware that conformant with the HTML specification, disabled Fields will not be submitted.
Defaults to:
false
<ext-calendar_timefield displayed="true" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield displayField="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.displayField = 'value';
let displayField = element.displayField;
The underlying data value name to bind to this
Select control. If configured as null
, the valueField is used.
This resolved value is the visibly rendered value of the available selection options.
Defaults to:
'text'
<ext-calendar_timefield displayTpl="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.displayTpl = 'value';
let displayTpl = element.displayTpl;
The template to be used to display the selected record inside the text field.
If not specified, the displayField is shown in the text field.
Defaults to:
null
Sets the value of displayTpl
displayTpl : String / String[] / Ext.XTemplate
<ext-calendar_timefield docked="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield draggable="true" />
let element = document.body.querySelector('ext-calendar_timefield');
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
Sets the value of draggable
draggable : Boolean / Object / Ext.drag.Source
<ext-calendar_timefield edgePicker="{ }" />
let element = document.body.querySelector('ext-calendar_timefield');
element.edgePicker = { };
let edgePicker = element.edgePicker;
A configuration object, containing an cfg#xtype property which specifies
the widget to create if picker: 'edge'
(or if it's 'auto'
and the
app is on a phone).
Replaces defaultPhonePicker
Defaults to:
{ xtype: 'selectpicker', cover: true }
<ext-calendar_timefield editable="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.editable = true;
let editable = element.editable;
Configure as false
to prevent the user from typing text directly into the
field; the field can only have its value set programmatically or via an action
invoked by a trigger.
Contrast with readOnly which disables all mutation via the UI.
Defaults to:
false
<ext-calendar_timefield enterAnimation="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.enterAnimation = 'value';
let enterAnimation = element.enterAnimation;
Animation effect to apply when the Component is being shown. Typically you want to use an inbound animation type such as 'fadeIn' or 'slideIn'.
Defaults to:
null
Deprecated since version 2.0.0
Please use showAnimation instead.
Sets the value of enterAnimation
enterAnimation : String / Mixed
<ext-calendar_timefield error="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.error = 'value';
let error = element.error;
The error (or errors) to display for this field. This config is typically set by the field's validators but can be set directly if an error needs to be associated with a field manually.
Errors will be HTML encoded as necessary and errorTpl before becoming the current errorMessage.
Defaults to:
null
Available since: 6.5.0
<ext-calendar_timefield errorMessage="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.errorMessage = 'value';
let errorMessage = element.errorMessage;
The field's error message to display as errorTarget.
This message must already be properly formatted and encoded as appropriate
for the errorTarget
.
Defaults to:
null
Available since: 6.5.0
<ext-calendar_timefield errorTarget="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.errorTarget = 'value';
let errorTarget = element.errorTarget;
The location where the error message text should display.
The following are values that have predefined meaning:
qtip
Display a Ext.tip.Manager containing the message
when the user hovers (or taps) the field. For this option to work, quick tips
must be enabled by calling Ext.tip.Manager#init.side
Add an error icon to the right of the field, displaying the message
in a popup on hover or tap.title
Display the message in a default browser title
attribute.under
Add a div
beneath the field containing the error message.Defaults to:
'qtip'
Available since: 6.5.0
<ext-calendar_timefield errorTip="{ }" />
let element = document.body.querySelector('ext-calendar_timefield');
element.errorTip = { };
let errorTip = element.errorTip;
The default config that will be used to display errors in the tooltip.
Defaults to:
null
Available since: 6.5.0
<ext-calendar_timefield errorTpl="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.errorTpl = 'value';
let errorTpl = element.errorTpl;
The template used to format the error set for this field. By default, the errorTarget is used to determine whether the error(s) are formatted as an HTML list or as plain text.
Defaults to:
null
Available since: 6.5.0
Sets the value of errorTpl
errorTpl : String / String[] / Ext.XTemplate
<ext-calendar_timefield eventHandlers="{ }" />
let element = document.body.querySelector('ext-calendar_timefield');
element.eventHandlers = { };
let eventHandlers = element.eventHandlers;
A map of event type to the corresponding handler method name. This is used internally by native event handling mechanism.
Defaults to:
{ focus: 'handleFocusEvent', blur: 'handleBlurEvent' }
Deprecated since version 6.6.0
Inline event handlers are deprecated
<ext-calendar_timefield exitAnimation="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.exitAnimation = 'value';
let exitAnimation = element.exitAnimation;
Animation effect to apply when the Component is being hidden.
Defaults to:
null
Deprecated since version 2.0.0
Please use hideAnimation instead. Typically you want to use
an outbound animation type such as 'fadeOut' or 'slideOut'.
Sets the value of exitAnimation
exitAnimation : String / Mixed
<ext-calendar_timefield flex="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield floated="true" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield floatedPicker="{ }" />
let element = document.body.querySelector('ext-calendar_timefield');
element.floatedPicker = { };
let floatedPicker = element.floatedPicker;
A configuration object, containing an cfg#xtype property which specifies
the widget to create if picker: 'floated'
(or if it's 'auto'
and
the app is not on a phone).
Replaces defaultTabletPicker
Defaults to:
{ xtype: 'boundlist', infinite: false, // BoundListNavigationModel binds to input field // Must only be enabled when list is visible navigationModel: { disabled: true }, scrollToTopOnRefresh: false, loadingHeight: 70, maxHeight: 300, floated: true, axisLock: true, hideAnimation: null }
<ext-calendar_timefield floatedPickerAlign="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.floatedPickerAlign = 'value';
let floatedPickerAlign = element.floatedPickerAlign;
*Only valud when the floatedPicker is used. The showBy alignment string to use when showing the floated picker by the input field.
Defaults to:
tl-bl?
Sets the value of floatedPickerAlign
floatedPickerAlign : String
<ext-calendar_timefield focusCls="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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'
<ext-calendar_timefield focusTrap="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.focusTrap = 'value';
let focusTrap = element.focusTrap;
Defaults to:
{ tabIndex: -1, cls: 'x-hidden-clip' }
<ext-calendar_timefield forceSelection="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.forceSelection = true;
let forceSelection = element.forceSelection;
By default the value must always be the valueField of one of the
records in the store. Configure as false
to allow the value to be set to
arbitrary text, and have this component auto create an associated record with
the typed value as the valueField.
This config is only supported for use in <ext-combobox/> <ext-comboboxfield/> but is defined here (as private) because of its many entanglements with value processing.
Defaults to:
true
Available since: 6.5.0
Sets the value of forceSelection
forceSelection : Boolean
<ext-calendar_timefield height="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield hideAnimation="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
Sets the value of hideAnimation
hideAnimation : String / Mixed
<ext-calendar_timefield hideMode="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
Returns the value of hideMode
'clip' / 'display' / 'offsets' / 'opacity' / 'visibility'
Sets the value of hideMode
hideMode : 'clip' / 'display' / 'offsets' / 'opacity' / 'visibility'
<ext-calendar_timefield hideOnMaskTap="true" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield hideTrigger="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.hideTrigger = true;
let hideTrigger = element.hideTrigger;
true
to hide the expand trigger.
Defaults to:
false
<ext-calendar_timefield html="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
Returns the value of html
String / Ext.dom.Element / HTMLElement
<ext-calendar_timefield id="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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.
let element = document.body.querySelector('ext-calendar_timefield');
let getId = element.getId();
Retrieves the id
. This method Will auto-generate an id if one has not already
been configured.
id
<ext-calendar_timefield inline="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.inline = true;
let inline = element.inline;
true
to cause this field to layout with inline element behavior.
An inline field's width is determined by the total width of its label and body
elements instead of automatically expanding to fill the width of its container.
Defaults to:
false
<ext-calendar_timefield inputCls="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.inputCls = 'value';
let inputCls = element.inputCls;
Deprecated since version 6.5.0
There is no longer an input component to which to add a class.
<ext-calendar_timefield inputMask="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.inputMask = 'value';
let inputMask = element.inputMask;
Important: To use this config you must require Ext.field.InputMask
or
use a complete framework build. The logic to implement an inputMask
is not
automatically included in a build.
Defaults to:
null
Available since: 6.5.0
Sets the value of inputMask
inputMask : String / Ext.field.InputMask
<ext-calendar_timefield inputType="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.inputType = 'value';
let inputType = element.inputType;
The type attribute for input fields -- e.g. text, password, date, url, email, etc.
Defaults to:
'text'
<ext-calendar_timefield inputValue="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.inputValue = 'value';
let inputValue = element.inputValue;
Defaults to:
null
<ext-calendar_timefield instanceCls="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.instanceCls = 'value';
let instanceCls = element.instanceCls;
An extra CSS class or classes to augment the classCls on an individual instance
Defaults to:
null
Available since: 6.5.0
<ext-calendar_timefield itemCls="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.itemCls = 'value';
let itemCls = element.itemCls;
An additional CSS class to apply to items within the picker list.
Defaults to:
null
<ext-calendar_timefield itemId="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield itemTpl="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.itemTpl = 'value';
let itemTpl = element.itemTpl;
An XTemplate definition string (Or an Ext.XTemplate) which specifies how to display a list item from a record values object. This is automatically generated to display the displayField if not specified.
Defaults to:
false
<ext-calendar_timefield keyMap="{ }" />
let element = document.body.querySelector('ext-calendar_timefield');
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
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.
<ext-calendar_timefield keyMapEnabled="true" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield keyMapTarget="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.keyMapTarget = 'value';
let keyMapTarget = element.keyMapTarget;
The name of the member that should be used to listen for keydown/keypress events. This is intended to be controlled at the class level not per instance.
Defaults to:
'el'
<ext-calendar_timefield label="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.label = 'value';
let label = element.label;
The label of this field
Defaults to:
null
<ext-calendar_timefield labelAlign="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.labelAlign = 'value';
let labelAlign = element.labelAlign;
When value is 'placeholder'
, the label text will be rendered as placeholder
text inside the empty input and will animated to "top" alignment when the input
is focused or contains text.
The position to render the label relative to the field body.
Defaults to:
'left'
Returns the value of labelAlign
'top' / 'left' / 'bottom' / 'right'
Sets the value of labelAlign
labelAlign : 'top' / 'left' / 'bottom' / 'right'
<ext-calendar_timefield labelCls="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.labelCls = 'value';
let labelCls = element.labelCls;
Optional CSS class to add to the Label element.
Defaults to:
null
<ext-calendar_timefield labelInPlaceholder="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.labelInPlaceholder = 'value';
let labelInPlaceholder = element.labelInPlaceholder;
Defaults to:
true
Sets the value of labelInPlaceholder
labelInPlaceholder : Object
<ext-calendar_timefield labelMinWidth="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.labelMinWidth = 'value';
let labelMinWidth = element.labelMinWidth;
Min-width of this field's label.
Defaults to:
null
<ext-calendar_timefield labelTextAlign="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.labelTextAlign = 'value';
let labelTextAlign = element.labelTextAlign;
Text alignment of this field's label
Defaults to:
'left'
Returns the value of labelTextAlign
'top' / 'right' / 'bottom' / 'left'
Sets the value of labelTextAlign
labelTextAlign : 'top' / 'right' / 'bottom' / 'left'
<ext-calendar_timefield labelWidth="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.labelWidth = 'value';
let labelWidth = element.labelWidth;
Width of this field's label. Can be a number of pixels or any valid CSS value,
such as '30%'
. To size the label to its text, use labelWidth: 'auto'
Defaults to:
null
<ext-calendar_timefield labelWrap="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.labelWrap = true;
let labelWrap = element.labelWrap;
true
to allow the label to wrap. If set to false
, the label will be truncated
with an ellipsis.
Defaults to:
false
<ext-calendar_timefield left="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield listeners="{ }" />
let element = document.body.querySelector('ext-calendar_timefield');
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'); }
}
}
});
let element = document.body.querySelector('ext-calendar_timefield');
element.setListeners(listeners);
An alias for addListener. In versions prior to 5.1, listeners had a generated setter which could be called to add listeners. In 5.1 the listeners config is not processed using the config system and has no generated setter, so this method is provided for backward compatibility. The preferred way of adding listeners is to use the on method.
listeners : Object
The listeners
<ext-calendar_timefield margin="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield matchFieldWidth="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.matchFieldWidth = true;
let matchFieldWidth = element.matchFieldWidth;
*Only valid when the picker: 'floated'
is used.
Whether the floatedPicker's width should be explicitly set to match
the width of the input element.
Defaults to:
true
Sets the value of matchFieldWidth
matchFieldWidth : Boolean
<ext-calendar_timefield maxHeight="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield maxLength="10" />
let element = document.body.querySelector('ext-calendar_timefield');
element.maxLength = 10;
let maxLength = element.maxLength;
The maximum number of permitted input characters.
Defaults to:
null
<ext-calendar_timefield maxWidth="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield minHeight="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield minWidth="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield modal="true" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield modelValidation="true" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield multiSelect="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.multiSelect = true;
let multiSelect = element.multiSelect;
Configure as true
to allow selection of multiple items from the picker. This
results in each selected item being represented by a "chip" in the input area.
When true
, the field's value will be an array containing the
valueField values of all selected records or null
when there is
no selection.
Defaults to:
null
<ext-calendar_timefield name="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.name = 'value';
let name = element.name;
The field's name. Used by form panels to gather data to be submitted.
For <ext-inputfield/> this name is set as the name
attribute
of the inputElement
Defaults to:
null
<ext-calendar_timefield nameable="true" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield options="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.options = 'value';
let options = element.options;
An array of select options.
[
{text: 'First Option', value: 'first'},
{text: 'Second Option', value: 'second'},
{text: 'Third Option', value: 'third'}
]
Note: Option object member names should correspond with defined valueField and displayField values.
This config is mutually exclusive with the store config. Specifying them both is unssupported and will produce undefined behaviour.
Defaults to:
null
<ext-calendar_timefield padding="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield parseValidator="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.parseValidator = 'value';
let parseValidator = element.parseValidator;
Defaults to:
null
Available since: 6.5.1
Sets the value of parseValidator
parseValidator : Ext.data.validator.Validator
<ext-calendar_timefield pattern="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.pattern = 'value';
let pattern = element.pattern;
The value for the HTML5 pattern
attribute. You can use this to change which
keyboard layout will be used.
Ext.define('Ux.field.Pattern', {
extend : 'Ext.field.Text',
xtype : 'patternfield',
config : {
component : { pattern : '[0-9]*' } } });
Even though it extends <ext-textfield/>, it will display the number keyboard.
Defaults to:
null
<ext-calendar_timefield picker="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.picker = 'value';
let picker = element.picker;
A string representing the type of picker to use. Can be one of the following values.
'edge'
to use the edgePicker, generally used on small formfactor devices.'floated'
to use the floatedPicker, generally used on tablets or desktops.'auto'
to allow the framework to select the appropriate picker for the device.Can also be a config object for the picker.
Defaults to:
'auto'
<ext-calendar_timefield pickerSlotAlign="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.pickerSlotAlign = 'value';
let pickerSlotAlign = element.pickerSlotAlign;
The alignment of text in the picker created by this Select
Defaults to:
'center'
Sets the value of pickerSlotAlign
pickerSlotAlign : String
<ext-calendar_timefield placeholder="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.placeholder = 'value';
let placeholder = element.placeholder;
A string value displayed in the input when the control is empty.
Defaults to:
null
<ext-calendar_timefield placeHolder="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.placeHolder = 'value';
let placeHolder = element.placeHolder;
A string value displayed in the input when the control is empty.
Deprecated since version 6.5.0
Use the all lowercase placeholder config.
<ext-calendar_timefield plugins="{ }" />
let element = document.body.querySelector('ext-calendar_timefield');
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
Returns the value of plugins
Sets the value of plugins
plugins : Array / Ext.enums.Plugin / Object / Ext.plugin.Abstract
<ext-calendar_timefield publishes="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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:
{ selection: 1 }
<ext-calendar_timefield readOnly="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.readOnly = true;
let readOnly = element.readOnly;
true
to set the field DOM element readonly
attribute to "true"
.
Mutation of <ext-textfield/> through triggers is also disabled.
To simply prevent typing into the field while still allowing mutation through
triggers, set editable to false
.
Defaults to:
false
<ext-calendar_timefield record="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield recordCreator="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.recordCreator = 'value';
let recordCreator = element.recordCreator;
Defaults to:
null
Available since: 6.6.0
value : String
The typed value to be converted into a new record.
model : ObExt.data.Model
field : Ext.field.Select
This SelectField.
A function, or a method name in this class, or in a ViewController to be used to
create a record from a typed value when forceSelection is false
.
This gives app developers a chance to create a full featured record, or to veto the
record creation by returning null
.
<ext-calendar_timefield recordCreatorScope="{ }" />
let element = document.body.querySelector('ext-calendar_timefield');
element.recordCreatorScope = { };
let recordCreatorScope = element.recordCreatorScope;
The scope (this
reference) in which the configured recordCreator
will be executed, unless the recordCreator is a ViewController method name.
Defaults to:
null
Available since: 6.6.0
Sets the value of recordCreatorScope
recordCreatorScope : Object
<ext-calendar_timefield reference="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield relative="true" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield renderTo="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.renderTo = 'value';
let renderTo = element.renderTo;
Optional element to render this Component to. Not required if this component is an item of a Container of a Container.
Defaults to:
null
<ext-calendar_timefield required="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.required = true;
let required = element.required;
true
to make this field required.
Defaults to:
false
<ext-calendar_timefield requiredMessage="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.requiredMessage = 'value';
let requiredMessage = element.requiredMessage;
The error message to display when required is true
and the field's
value is "empty" (null
, undefined
, or empty string).
Defaults to:
'This field is required'
Sets the value of requiredMessage
requiredMessage : String
<ext-calendar_timefield right="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield ripple="true" />
let element = document.body.querySelector('ext-calendar_timefield');
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
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.
<ext-calendar_timefield scrollable="true" />
let element = document.body.querySelector('ext-calendar_timefield');
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 onlyy
or vertical
to enable vertical scrolling onlyAlso 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
<ext-calendar_timefield selection="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.selection = 'value';
let selection = element.selection;
The selected model. null
if no value exists.
Defaults to:
null
<ext-calendar_timefield selectOnTab="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.selectOnTab = true;
let selectOnTab = element.selectOnTab;
Whether the Tab key should select the currently highlighted item.
Defaults to:
true
<ext-calendar_timefield session="true" />
let element = document.body.querySelector('ext-calendar_timefield');
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
Sets the value of session
session : Boolean / Object / Ext.data.Session
<ext-calendar_timefield shadow="true" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield shim="true" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield showAnimation="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
Sets the value of showAnimation
showAnimation : String / Mixed
<ext-calendar_timefield sideError="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.sideError = 'value';
let sideError = element.sideError;
Defaults to:
null
<ext-calendar_timefield stateful="true" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield statefulDefaults="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.statefulDefaults = 'value';
let statefulDefaults = element.statefulDefaults;
The default set of stateful properties. The form of this config is the same as stateful except this config cannot be a Boolean.
This config is intended for classes to specify so that instances can simply
enable statefulness using stateful: true
.
Defaults to:
null
<ext-calendar_timefield stateId="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.stateId = 'value';
let stateId = element.stateId;
The unique id for this object to use for state management purposes.
Defaults to:
null
<ext-calendar_timefield store="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.store = 'value';
let store = element.store;
The store to provide selection options data. Either a Store instance, configuration object or store ID.
Defaults to:
null
<ext-calendar_timefield stripCharsRe="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.stripCharsRe = 'value';
let stripCharsRe = element.stripCharsRe;
A JavaScript RegExp object used to strip unwanted content from the value
during input. If stripCharsRe
is specified,
every character sequence matching stripCharsRe
will be removed.
<ext-calendar_timefield style="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield tabIndex="10" />
let element = document.body.querySelector('ext-calendar_timefield');
element.tabIndex = 10;
let tabIndex = element.tabIndex;
DOM tabIndex attribute for this component's focusEl.
Defaults to:
null
let element = document.body.querySelector('ext-calendar_timefield');
let getTabIndex = element.getTabIndex();
Return the actual tabIndex for this Focusable.
tabIndex attribute value
let element = document.body.querySelector('ext-calendar_timefield');
element.setTabIndex(newTabIndex);
Set the tabIndex property for this Focusable. If the focusEl is available, set tabIndex attribute on it, too.
newTabIndex : Number
new tabIndex to set
<ext-calendar_timefield textAlign="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.textAlign = 'value';
let textAlign = element.textAlign;
The text alignment of this field.
Defaults to:
'left'
Returns the value of textAlign
'left' / 'center' / 'right'
Sets the value of textAlign
textAlign : 'left' / 'center' / 'right'
<ext-calendar_timefield tipError="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.tipError = 'value';
let tipError = element.tipError;
Defaults to:
null
<ext-calendar_timefield titleError="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.titleError = 'value';
let titleError = element.titleError;
Defaults to:
null
<ext-calendar_timefield toFrontOnShow="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.toFrontOnShow = true;
let toFrontOnShow = element.toFrontOnShow;
True to automatically call toFront when a cfg-floated Component is shown.
Defaults to:
true
<ext-calendar_timefield tooltip="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield top="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield touchAction="{ }" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield tpl="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.tpl = 'value';
let tpl = element.tpl;
A String, Ext.Template, Ext.XTemplate or an Array of strings to form an Ext.XTemplate. Used in conjunction with the data and tplWriteMode configurations.
Note The data configuration must be set for any content to be shown in the component when using this configuration.
Defaults to:
null
Sets the value of tpl
tpl : String / String[] / Ext.Template / Ext.XTemplate[]
<ext-calendar_timefield tplWriteMode="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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:
Defaults to:
'overwrite'
<ext-calendar_timefield translatable="{ }" />
let element = document.body.querySelector('ext-calendar_timefield');
element.translatable = { };
let translatable = element.translatable;
Defaults to:
null
<ext-calendar_timefield triggers="{ }" />
let element = document.body.querySelector('ext-calendar_timefield');
element.triggers = { };
let triggers = element.triggers;
<ext-trigger/> <ext-trigger.trigger/> to use in this field. The keys in this object are unique identifiers for the triggers. The values in this object are <ext-trigger/> <ext-trigger.trigger/> configuration objects.
Ext.create('Ext.field.Text', {
label: 'My Custom Field',
triggers: {
foo: { cls: 'my-foo-trigger', handler: function() { console.log('foo trigger clicked'); } }, bar: { cls: 'my-bar-trigger', handler: function() { console.log('bar trigger clicked'); } } } });
The weight value may be a negative value in order to position custom triggers ahead of default triggers like that of a DatePicker field.
Ext.create('Ext.form.DatePicker', {
label: 'Pick a Date',
triggers: {
foo: { cls: 'my-foo-trigger', weight: -2, // negative to place before default triggers handler: function() { console.log('foo trigger clicked'); } }, bar: { cls: 'my-bar-trigger', weight: -1, handler: function() { console.log('bar trigger clicked'); } } } });
Defaults to:
{ clear: { type: 'clear' } }
<ext-calendar_timefield twoWayBindable="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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:
{ selection: 1 }
<ext-calendar_timefield ui="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield underError="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.underError = 'value';
let underError = element.underError;
Defaults to:
null
<ext-calendar_timefield userCls="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield userSelectable="true" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield validateDisabled="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.validateDisabled = true;
let validateDisabled = element.validateDisabled;
true
to validate the field, even if it is disabled.
Defaults to:
false
Sets the value of validateDisabled
validateDisabled : Boolean
<ext-calendar_timefield validationMessage="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.validationMessage = 'value';
let validationMessage = element.validationMessage;
For validation, regex, etc., this is the error message returned if field is invalid.
Defaults to:
'Is in the wrong format'
Sets the value of validationMessage
validationMessage : String
<ext-calendar_timefield validators="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.validators = 'value';
let validators = element.validators;
A validator or array of validators to be applied to the field.
When the field is validated, each validator is applied and if any one of them determines the field is invalid, the field will be marked as invalid. If you examine the field's validators, you will get an array of Ext.data.Validators.
Validation currently is synchronous. If you need to validate a field with interaction with a server, you would do this when the form is submitted.
A validator may be:
A function - the function will be called to validate the field; it should return false if invalid.
An object - an object with a member fn that is a function to be called to validate the field.
An instantiated Validator Ext.data.validator.Validator
Defaults to:
null
<ext-calendar_timefield value="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.value = 'value';
let value = element.value;
The field's value
Defaults to:
null
<ext-calendar_timefield valueCollection="{ }" />
let element = document.body.querySelector('ext-calendar_timefield');
let valueCollection = element.valueCollection;
A Ext.util.Collection instance, or configuration object used to create the collection of selected records.
This is used by the picker as the core of its selection handling, and also as the collection of selected values for this widget.
Defaults to:
{ rootProperty: 'data' }
Available since: 6.5.0
Sets the value of valueCollection
valueCollection : Object / Ext.util.Collection
<ext-calendar_timefield valueField="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.valueField = 'value';
let valueField = element.valueField;
The underlying data value name to bind to this
Select control. If configured as null
, the displayField is
used.
Defaults to:
'value'
<ext-calendar_timefield valueNotFoundText="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.valueNotFoundText = 'value';
let valueNotFoundText = element.valueNotFoundText;
The message to display if the value passed to setValue
is not found in the store.
Defaults to:
null
Sets the value of valueNotFoundText
valueNotFoundText : String
<ext-calendar_timefield viewModel="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
Sets the value of viewModel
viewModel : String / Object / Ext.app.ViewModel
<ext-calendar_timefield weight="10" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield width="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield x="10" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield xtype="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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.
<ext-calendar_timefield y="10" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield zIndex="10" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield $className="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.$className = 'value';
let $className = element.$className;
Defaults to:
'Ext.Base'
<ext-calendar_timefield $configPrefixed="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.$configPrefixed = true;
let $configPrefixed = element.$configPrefixed;
The value true
causes config
values to be stored on instances using a
property name prefixed with an underscore ("_") character. A value of false
stores config
values as properties using their exact name (no prefix).
Defaults to:
true
Available since: 5.0.0
<ext-calendar_timefield $configStrict="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.$configStrict = true;
let $configStrict = element.$configStrict;
The value true
instructs the initConfig
method to only honor values for
properties declared in the config
block of a class. When false
, properties
that are not declared in a config
block will be placed on the instance.
Defaults to:
true
Available since: 5.0.0
<ext-calendar_timefield $configTransforms="{ }" />
let element = document.body.querySelector('ext-calendar_timefield');
element.$configTransforms = { };
let $configTransforms = element.$configTransforms;
A prototype-chained object storing transform method names and priorities stored on the class prototype. On first instantiation, this object is converted into an array that is sorted by priority and stored on the constructor.
Defaults to:
{}
<ext-calendar_timefield $eventOptions="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.$eventOptions = 'value';
let $eventOptions = element.$eventOptions;
Matches options property names within a listeners specification object - property names which are never used as event names.
Defaults to:
{ scope: 1, delay: 1, buffer: 1, onFrame: 1, single: 1, args: 1, destroyable: 1, priority: 1, order: 1 }
<ext-calendar_timefield $vetoClearingPrototypeOnDestroy="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.$vetoClearingPrototypeOnDestroy = 'value';
let $vetoClearingPrototypeOnDestroy = element.$vetoClearingPrototypeOnDestroy;
We don't want the base destructor to clear the prototype because our destroyObservable handler must be called the very last. It will take care of the prototype after completing Observable destruction sequence.
Defaults to:
true
<ext-calendar_timefield activeAnimation="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.activeAnimation = 'value';
let activeAnimation = element.activeAnimation;
Defaults to:
null
<ext-calendar_timefield ariaEl="value" />
let element = document.body.querySelector('ext-calendar_timefield');
let ariaEl = element.ariaEl;
The name of the Component property that holds a reference to the Element that serves as that Component's ARIA element. This property will be replaced with the actual Element reference after rendering.
Most of the simple Components will have their main element as ariaEl.
Defaults to:
'el'
Available since: 6.0.0
<ext-calendar_timefield ariaRenderAttributes="{ }" />
let element = document.body.querySelector('ext-calendar_timefield');
element.ariaRenderAttributes = { };
let ariaRenderAttributes = element.ariaRenderAttributes;
Instance specific ARIA attributes to render into Component's ariaEl. This object is only used during rendering, and is discarded afterwards.
<ext-calendar_timefield ariaRole="value" />
let element = document.body.querySelector('ext-calendar_timefield');
let ariaRole = element.ariaRole;
ARIA role for this Component, defaults to no role. With no role, no other ARIA attributes are set.
<ext-calendar_timefield autoGenId="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.autoGenId = true;
let autoGenId = element.autoGenId;
true
indicates an id
was auto-generated rather than provided by configuration.
Defaults to:
false
Available since: 6.7.0
<ext-calendar_timefield baseCls="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.baseCls = 'value';
let baseCls = element.baseCls;
The base CSS class to apply to this widget's element.
Used as the prefix for ui-specific class names.
Defaults to the value of classCls or (x-
+ the xtype) of the widget
if classCls is null
Defaults to:
null
<ext-calendar_timefield classCls="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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 + 'selectfield'
<ext-calendar_timefield classClsRoot="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.classClsRoot = 'value';
let classClsRoot = element.classClsRoot;
When set to true
during widget class definition, that class will be the "root" for
classCls inheritance. Derived classes may set this to true
to avoid
inheriting a classCls from their superclass.
Defaults to:
true
<ext-calendar_timefield clearPropertiesOnDestroy="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.clearPropertiesOnDestroy = true;
let clearPropertiesOnDestroy = element.clearPropertiesOnDestroy;
Setting this property to false
will prevent nulling object references
on a Class instance after destruction. Setting this to "async"
will delay
the clearing for approx 50ms.
Defaults to:
true
Available since: 6.2.0
<ext-calendar_timefield clearPrototypeOnDestroy="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.clearPrototypeOnDestroy = true;
let clearPrototypeOnDestroy = element.clearPrototypeOnDestroy;
Setting this property to true
will result in setting the object's
prototype to null
after the destruction sequence is fully completed.
After that, most attempts at calling methods on the object instance
will result in "method not defined" exception. This can be very helpful
with tracking down otherwise hard to find bugs like runaway Ajax requests,
timed functions not cleared on destruction, etc.
Note that this option can only work in browsers that support Object.setPrototypeOf
method, and is only available in debugging mode.
Defaults to:
false
Available since: 6.2.0
<ext-calendar_timefield containsFocus="true" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield defaultBindProperty="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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:
'value'
<ext-calendar_timefield destroyed="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.destroyed = true;
let destroyed = element.destroyed;
This property is set to true
after the destroy
method is called.
Defaults to:
false
<ext-calendar_timefield dockPositions="value" />
let element = document.body.querySelector('ext-calendar_timefield');
let dockPositions = element.dockPositions;
Defaults to:
{ top: true, right: true, bottom: true, left: true }
<ext-calendar_timefield doKeyDown="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.doKeyDown = 'value';
let doKeyDown = element.doKeyDown;
Called when a key has been pressed in the <input>
Defaults to:
Ext.emptyFn
<ext-calendar_timefield element="{ }" />
let element = document.body.querySelector('ext-calendar_timefield');
element.element = { };
let element = element.element;
A configuration object for Ext.Element.create() that is used to create the Element template. Subclasses should avoid overriding this property and instead add elements using template.
Supports all the standard options of a Ext.Element.create() config and adds 3 additional options:
reference
- this option specifies a name for Element references. These
references names become properties of the Widget instance and refer to Ext.Element
instances that were created using the template:
element: {
reference: 'element',
children: [{
reference: 'innerElement'
}]
}
After construction of a widget the reference elements are accessible as follows:
var foo = new FooWidget(),
innerEl = foo.innerElement; // an Ext.Element that wraps the innerElement
The reference attribute is optional, but all Widgets must have a 'element'
reference on some element within the template (usually the outermost one).
listeners
- a standard listeners object as specified by Ext.mixin.Observable.
element: {
reference: 'element',
listeners: {
click: 'onClick'
},
children: [{
reference: 'innerElement',
listeners: {
click: 'onInnerClick'
}
}]
}
Since listeners cannot be attached without an Ext.Element reference the reference
property MUST be specified in order to use listeners
.
The Widget instance is used as the scope for all listeners specified in this way,
so it is invalid to use the scope
option in the listeners
config since it will
always be overwritten using this
.
uiCls
- a suffix to be appended to the ui-specific CSS class for each ui
for this widget. These ui classes are constructed by appending the ui
to each
classCls
or baseCls
for the widget. As such, uiCls
should
never be used on the main element
reference, as its uiCls
is computed automatically.For example, assume a widget is defined with a ui
of 'alt action'
and a
uiCls
of 'inner-el'
on its innerElement
reference element:
Ext.define('Doodad', {
extend: 'Ext.Widget',
xtype: 'doodad',
classCls: 'x-doodad',
ui: 'alt action',
element: {
reference: 'element',
children: [{
reference: 'innerElement',
cls: 'x-inner-el',
uiCls: 'inner-el'
}]
}
});
This would result in the following markup when rendered:
<div class="x-doodad x-doodad-alt x-doodad-action">
<div class="x-inner-el x-doodad-inner-el x-doodad-alt-inner-el x-doodad-action-inner-el"></div>
</div>
These additional classes can be used to style the reference element for a particular
ui; however, use of uiCls
is not typically necessary or recommended. Reference
elements should usually be styled using simple descendant selectors:
.x-doodad-alt .x-inner-el {
color: red;
}
When there is a possibility that widgets can be nested it is best to use direct child selectors to avoid the possibility of selecting all descendants instead of just the reference element for the intended widget:
.x-doodad-alt > .x-inner-el {
color: red;
}
Only use uiCls
when there is a possibility of nesting, AND there may be a variable
number of elements between the main element
and the reference element in question.
For example, Ext.Container with docked items has a different number of elements
in between its element
and its bodyElement
than a Container without docked items
because of the wrapping elements that are dynamically added to support docking.
To ensure it does not style all descendants it must use a uiCls
to style its
bodyElement
:
.x-container-alt-body-el {
background: #fff;
}
Note that when uiCls
is specified it also adds a class name that does not contain
the ui
using just the classCls
and/or baseCls
as the prefix. This class name
can be used for base-level styling that does not relate to any particular UI:
.x-container-body-el {
position: relative;
}
Defaults to:
{ reference: 'element' }
<ext-calendar_timefield eventsSuspended="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.eventsSuspended = 'value';
let eventsSuspended = element.eventsSuspended;
Initial suspended call count. Incremented when suspendEvents is called, decremented when resumeEvents is called.
Defaults to:
0
<ext-calendar_timefield factoryConfig="{ }" />
let element = document.body.querySelector('ext-calendar_timefield');
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
.
<ext-calendar_timefield floatedSelector="value" />
let element = document.body.querySelector('ext-calendar_timefield');
let floatedSelector = element.floatedSelector;
The CSS selector to match floated elements.
Defaults to:
".x-floated"
<ext-calendar_timefield floatingCls="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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'
<ext-calendar_timefield floatWrapCls="value" />
let element = document.body.querySelector('ext-calendar_timefield');
let floatWrapCls = element.floatWrapCls;
The CSS class to add to this component's floatWrap when it's created.
Defaults to:
"x-float-wrap"
<ext-calendar_timefield focusable="true" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield focusClsEl="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.focusClsEl = 'value';
let focusClsEl = element.focusClsEl;
The element that will have the focusCls applied when component's focusEl is focused.
<ext-calendar_timefield focusEl="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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'
<ext-calendar_timefield hasFocus="true" />
let element = document.body.querySelector('ext-calendar_timefield');
let hasFocus = element.hasFocus;
true
if this component's focusEl is focused.
See also containsFocus.
Defaults to:
false
<ext-calendar_timefield hasListeners="{ }" />
let element = document.body.querySelector('ext-calendar_timefield');
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);
}
<ext-calendar_timefield htmlErrorsTpl="value" />
let element = document.body.querySelector('ext-calendar_timefield');
let htmlErrorsTpl = element.htmlErrorsTpl;
The default template used to format errors in HTML. This property is promoted
to an Ext.XTemplate
instance on first use.
Defaults to:
[ '<tpl if="count == 1">', '<tpl for="errors">{.:htmlEncode}</tpl>', '<tpl elseif="count">', '<ul class="{listCls}">', '<tpl for="errors"><li>{.:htmlEncode}</li></tpl>', '</ul>', '</tpl>' ]
Available since: 6.5.0
<ext-calendar_timefield inheritUi="true" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield initFocusable="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.initFocusable = 'value';
let initFocusable = element.initFocusable;
Template method to do any Focusable related initialization that does not involve event listeners creation.
Defaults to:
Ext.emptyFn
<ext-calendar_timefield isComponent="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.isComponent = 'value';
let isComponent = element.isComponent;
Defaults to:
true
<ext-calendar_timefield isConfiguring="true" />
let element = document.body.querySelector('ext-calendar_timefield');
let isConfiguring = element.isConfiguring;
This property is set to true
during the call to initConfig
.
Defaults to:
false
Available since: 5.0.0
<ext-calendar_timefield isField="true" />
let element = document.body.querySelector('ext-calendar_timefield');
let isField = element.isField;
true
in this class to identify an object this type, or subclass thereof.
This is used by Ext.form.Panel#getValues to determine which components inside a form are fields.
Defaults to:
true
<ext-calendar_timefield isFirstInstance="true" />
let element = document.body.querySelector('ext-calendar_timefield');
let isFirstInstance = element.isFirstInstance;
This property is set to true
if this instance is the first of its class.
Defaults to:
false
Available since: 5.0.0
<ext-calendar_timefield isFormField="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.isFormField = 'value';
let isFormField = element.isFormField;
Defaults to:
true
<ext-calendar_timefield isInner="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.isInner = 'value';
let isInner = element.isInner;
Defaults to:
true
<ext-calendar_timefield isInstance="true" />
let element = document.body.querySelector('ext-calendar_timefield');
let isInstance = element.isInstance;
This value is true
and is used to identify plain objects from instances of
a defined class.
Defaults to:
true
<ext-calendar_timefield isObservable="true" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield isSelectField="true" />
let element = document.body.querySelector('ext-calendar_timefield');
element.isSelectField = true;
let isSelectField = element.isSelectField;
true
in this class to identify an object this type, or subclass thereof.
Defaults to:
true
<ext-calendar_timefield lastKeyMapEvent="value" />
let element = document.body.querySelector('ext-calendar_timefield');
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
<ext-calendar_timefield noBorderCls="value" />
let element = document.body.querySelector('ext-calendar_timefield');
let noBorderCls = element.noBorderCls;
The CSS class to add to this component should not have a border.
Defaults to:
Ext.baseCSSPrefix + 'noborder-trbl'
<ext-calendar_timefield originalValue="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.originalValue = 'value';
let originalValue = element.originalValue;
The original value when the field was instantiated.
Defaults to:
null
<ext-calendar_timefield plainErrorsTpl="value" />
let element = document.body.querySelector('ext-calendar_timefield');
let plainErrorsTpl = element.plainErrorsTpl;
The default template used to format errors as plain text. This property is promoted
to an Ext.XTemplate
instance on first use.
Defaults to:
[ '<tpl if="count">', '<tpl for="errors" between="\\n">{.}</tpl>', '</tpl>' ]
Available since: 6.5.0
<ext-calendar_timefield positioned="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.positioned = 'value';
let positioned = element.positioned;
Defaults to:
false
<ext-calendar_timefield rendered="true" />
let element = document.body.querySelector('ext-calendar_timefield');
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.
<ext-calendar_timefield self="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.self = 'value';
let self = element.self;
Get the reference to the current class from which this object was instantiated. Unlike
Ext.Base#statics, this.self
is scope-dependent and it's meant to be used
for dynamic inheritance. See Ext.Base#statics for a detailed comparison
Ext.define('My.Cat', {
statics: {
speciesName: 'Cat' // My.Cat.speciesName = 'Cat'
},
constructor: function() {
alert(this.self.speciesName); // dependent on 'this'
},
clone: function() {
return new this.self();
}
});
Ext.define('My.SnowLeopard', {
extend: 'My.Cat',
statics: {
speciesName: 'Snow Leopard' // My.SnowLeopard.speciesName = 'Snow Leopard'
}
});
var cat = new My.Cat(); // alerts 'Cat'
var snowLeopard = new My.SnowLeopard(); // alerts 'Snow Leopard'
var clone = snowLeopard.clone();
alert(Ext.getClassName(clone)); // alerts 'My.SnowLeopard'
Defaults to:
Base
<ext-calendar_timefield shadowCls="value" />
let element = document.body.querySelector('ext-calendar_timefield');
let shadowCls = element.shadowCls;
The CSS class to add to this component when it has a shadow.
Defaults to:
Ext.baseCSSPrefix + 'shadow'
<ext-calendar_timefield shimCls="value" />
let element = document.body.querySelector('ext-calendar_timefield');
let shimCls = element.shimCls;
The CSS class to add to this component's shim element if enabled.
Defaults to:
"x-shim"
<ext-calendar_timefield tag="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.tag = 'value';
let tag = element.tag;
The tag name to use for this field's input element. Subclasses should override this property on their class body. Not intended for instance-level use.
Defaults to:
'input'
<ext-calendar_timefield template="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.template = 'value';
let template = element.template;
An array of child elements to use as the children of the main element in the element template. Only used if "children" are not specified explicitly in the element template.
Defaults to:
[]
<ext-calendar_timefield uiReferences="{ }" />
let element = document.body.querySelector('ext-calendar_timefield');
element.uiReferences = { };
let uiReferences = element.uiReferences;
A map that tracks all reference elements configured with a uiCls
.
Contains the element
reference by default since the element
always gets
non-suffixed ui-specific CSS class names added to it (see syncUiCls)
<ext-calendar_timefield userSelectableClsMap="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.userSelectableClsMap = 'value';
let userSelectableClsMap = element.userSelectableClsMap;
Defaults to:
{ "true": Ext.baseCSSPrefix + 'user-selectable-auto', "false": Ext.baseCSSPrefix + 'user-selectable-none', all: Ext.baseCSSPrefix + 'user-selectable-all', auto: Ext.baseCSSPrefix + 'user-selectable-auto', text: Ext.baseCSSPrefix + 'user-selectable-text', none: Ext.baseCSSPrefix + 'user-selectable-none' }
<ext-calendar_timefield validateOnInit="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.validateOnInit = 'value';
let validateOnInit = element.validateOnInit;
Determines how initial values will handle validation
Defaults to:
'auto'
<ext-calendar_timefield validRefRe="value" />
let element = document.body.querySelector('ext-calendar_timefield');
element.validRefRe = 'value';
let validRefRe = element.validRefRe;
Regular expression used for validating reference
values.
Defaults to:
/^[a-z_][a-z0-9_]*$/i
let element = document.body.querySelector('ext-calendar_timefield');
let _addDeclaredListeners = element._addDeclaredListeners(listeners);
Adds declarative listeners as nested arrays of listener objects.
listeners : Array
true
if any listeners were added
let element = document.body.querySelector('ext-calendar_timefield');
element._fixReference();
Sets up a reference on our current reference holder.
let element = document.body.querySelector('ext-calendar_timefield');
element._flushStateful();
This method is called before destroy
to ensure that this instance's stateful
properties are saved to persistent storage. Since this object is about to be
destroyed, this cannot be delayed.
let element = document.body.querySelector('ext-calendar_timefield');
let _getStateId = element._getStateId();
Returns the state id for this object.
let element = document.body.querySelector('ext-calendar_timefield');
let activatePlugin = element.activatePlugin(type);
Creates a particular plugin type if defined in the plugins
configuration.
Available since: 6.2.0
type : String
The type
of the plugin.
The plugin that was created.
let element = document.body.querySelector('ext-calendar_timefield');
element.addAfterListener();
Alias for onAfter.
let element = document.body.querySelector('ext-calendar_timefield');
element.addBeforeListener();
Alias for onBefore.
let element = document.body.querySelector('ext-calendar_timefield');
element.addCls(cls, prefix, suffix);
Adds a CSS class (or classes) to this Component's rendered element.
cls : String/String[]
The CSS class(es) to add.
prefix : String (optional)
Optional prefix to add to each class.
Defaults to: ""
suffix : String (optional)
Optional suffix to add to each class.
Defaults to: ""
let element = document.body.querySelector('ext-calendar_timefield');
element.addDelegatedListener(eventName, fn, scope, options, order, caller, manager);
Adds a listeners with the "delegate" event option. Users should not invoke this method directly. Use the "delegate" event option of addListener instead.
eventName : Object
fn : Object
scope : Object
options : Object
order : Object
caller : Object
manager : Object
let element = document.body.querySelector('ext-calendar_timefield');
element.addDeprecations(deprecations);
This method applies a versioned, deprecation declaration to this class. This
is typically called by the deprecated
config.
deprecations : Object
let element = document.body.querySelector('ext-calendar_timefield');
let addElementReference = element.addElementReference(name, domNode);
Adds an element reference to this Widget instance.
name : String
The name of the reference
domNode : HTMLElement
let element = document.body.querySelector('ext-calendar_timefield');
element.addElementReferenceOnDemand(name, domNode);
Reduces instantiation time for a Widget by lazily instantiating Ext.Element references the first time they are used. This optimization only works for elements with no listeners specified.
name : String
The name of the reference
domNode : HTMLElement
let element = document.body.querySelector('ext-calendar_timefield');
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}
});
eventName : String/Object
The name of the event to listen for. May also be an object who's property names are event names.
fn : Function/String (optional)
The method the event invokes or the name of
the method within the specified scope
. Will be called with arguments
given to Ext.util.Observable#fireEvent plus the options
parameter described
below.
scope : Object (optional)
The scope (this
reference) in which the handler function is
executed. If omitted, defaults to the object which fired the event.
options : Object (optional)
An object containing handler configuration.
Note: The options object will also be passed as the last argument to every event handler.
This object may contain any of the following properties:
scope : Object
The scope (this
reference) in which the handler function is executed. If omitted,
defaults to the object which fired the event.
delay : Number
The number of milliseconds to delay the invocation of the handler after the event fires.
single : Boolean
True to add a handler to handle just the next firing of the event, and then remove itself.
buffer : Number
Causes the handler to be scheduled to run in an Ext.util.DelayedTask delayed by the specified number of milliseconds. If the event fires again within that time, the original handler is not invoked, but the new handler is scheduled in its place.
onFrame : Number
Causes the handler to be scheduled to run at the next animation frame event. If the event fires again before that time, the handler is not rescheduled - the handler will only be called once when the next animation frame is fired, with the last set of arguments passed.
target : Ext.util.Observable
Only call the handler if the event was fired on the target Observable, not if the event was bubbled up from a child Observable.
element : String
This option is only valid for listeners bound to <ext-component/>. The name of a Component property which references an Ext.dom.Element to add a listener to.
This option is useful during Component construction to add DOM event listeners to elements of <ext-component/> which will exist only after the Component is rendered.
For example, to add a click listener to a Panel's body:
var panel = new Ext.panel.Panel({
title: 'The title',
listeners: {
click: this.handlePanelClick,
element: 'body'
}
});
In order to remove listeners attached using the element, you'll need to reference the element itself as seen below.
panel.body.un(...)
delegate : String (optional)
A simple selector to filter the event target or look for a descendant of the target.
The "delegate" option is only available on Ext.dom.Element instances (or when attaching a listener to a Ext.dom.Element via a Component using the element option).
See the delegate example below.
capture : Boolean (optional)
When set to true
, the listener is fired in the capture phase of the event propagation
sequence, instead of the default bubble phase.
The capture
option is only available on Ext.dom.Element instances (or
when attaching a listener to a Ext.dom.Element via a Component using the
element option).
stopPropagation : Boolean (optional)
This option is only valid for listeners bound to Ext.dom.Element.
true
to call stopPropagation on the event
object before firing the handler.
preventDefault : Boolean (optional)
This option is only valid for listeners bound to Ext.dom.Element.
true
to call preventDefault on the event
object before firing the handler.
stopEvent : Boolean (optional)
This option is only valid for listeners bound to Ext.dom.Element.
true
to call stopEvent on the event object
before firing the handler.
args : Array (optional)
Optional set of arguments to pass to the handler function before the actual
fired event arguments. For example, if args
is set to ['foo', 42]
,
the event handler function will be called with an arguments list like this:
handler('foo', 42, <actual event arguments>...);
destroyable : Boolean (optional)
When specified as true
, the function returns a destroyable
object. An object
which implements the destroy
method which removes all listeners added in this call.
This syntax can be a helpful shortcut to using un; particularly when
removing multiple listeners. NOTE - not compatible when using the element
option. See un for the proper syntax for removing listeners added using the
element config.
Defaults to:
false
priority : Number (optional)
An optional numeric priority that determines the order in which event handlers are run. Event handlers with no priority will be run as if they had a priority of 0. Handlers with a higher priority will be prioritized to run sooner than those with a lower priority. Negative numbers can be used to set a priority lower than the default. Internally, the framework uses a range of 1000 or greater, and -1000 or lesser for handlers that are intended to run before or after all others, so it is recommended to stay within the range of -999 to 999 when setting the priority of event handlers in application-level code. A priority must be an integer to be valid. Fractional values are reserved for internal framework use.
order : String (optional)
A legacy option that is provided for backward compatibility.
It is recommended to use the priority
option instead. Available options are:
'before'
: equal to a priority of 100
'current'
: equal to a priority of 0
or default priority'after'
: equal to a priority of -100
Defaults to:
'current'
order : String (optional)
A shortcut for the order
event option. Provided for backward compatibility.
Please use the priority
event option instead.
Defaults to: 'current'
Only when the destroyable
option is specified.
A Destroyable
object. An object which implements the destroy
method which removes
all listeners added in this call. For example:
this.btnListeners = = myButton.on({
destroyable: true
mouseover: function() { console.log('mouseover'); },
mouseout: function() { console.log('mouseout'); },
click: function() { console.log('click'); }
});
And when those listeners need to be removed:
Ext.destroy(this.btnListeners);
or
this.btnListeners.destroy();
let element = document.body.querySelector('ext-calendar_timefield');
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.
item : Ext.util.Observable/Ext.dom.Element
The item to which to add a listener/listeners.
ename : Object/String
The event name, or an object containing event name properties.
fn : Function/String (optional)
If the ename
parameter was an event
name, this is the handler function or the name of a method on the specified
scope
.
scope : Object (optional)
If the ename
parameter was an event name, this is
the scope (this
reference) in which the handler function is executed.
options : Object (optional)
If the ename
parameter was an event name, this is
the addListener options.
Only when the destroyable
option is specified.
A Destroyable
object. An object which implements the destroy
method which removes
all listeners added in this call. For example:
this.btnListeners = myButton.mon({
destroyable: true
mouseover: function() { console.log('mouseover'); },
mouseout: function() { console.log('mouseout'); },
click: function() { console.log('click'); }
});
And when those listeners need to be removed:
Ext.destroy(this.btnListeners);
or
this.btnListeners.destroy();
let element = document.body.querySelector('ext-calendar_timefield');
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
plugin : Object/String/Ext.plugin.Abstract
The plugin or config object or alias to add.
let element = document.body.querySelector('ext-calendar_timefield');
let addTrigger = element.addTrigger(name, trigger);
Adds a trigger to this text field.
name : String
Unique name (within this field) for the trigger. Cannot be the same as the name of an existing trigger for this field.
trigger : Ext.field.trigger.Trigger/Object
The trigger instance or a config object for a trigger to add
The trigger that was added
let element = document.body.querySelector('ext-calendar_timefield');
element.adjustChildDirtyCount(dirty);
This method is called by descendants that use this mixin when their dirty
state
changes.
dirty : Boolean
The dirty state of the descendant component.
let element = document.body.querySelector('ext-calendar_timefield');
element.afterEdit();
Used to handle joining of a record to a tpl
let element = document.body.querySelector('ext-calendar_timefield');
element.afterErase();
Used to handle joining of a record to a tpl
let element = document.body.querySelector('ext-calendar_timefield');
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.
let element = document.body.querySelector('ext-calendar_timefield');
element.alignTo(component, alignment, options);
component : Object
alignment : Object
options : Object
let element = document.body.querySelector('ext-calendar_timefield');
let applyBind = element.applyBind(binds, currentBindings);
Available since: 5.0.0
binds : String/Object
currentBindings : Object
let element = document.body.querySelector('ext-calendar_timefield');
let applyCentered = element.applyCentered(centered);
centered : Boolean
let element = document.body.querySelector('ext-calendar_timefield');
element.applyPlugins(plugins, oldPlugins);
Applier for the plugins
config property.
plugins : String[]/Object[]/Ext.plugin.Abstract[]
The new plugins to use.
oldPlugins : Ext.plugin.Abstract[]
The existing plugins in use.
let element = document.body.querySelector('ext-calendar_timefield');
let applySession = element.applySession(session);
Transforms a Session config to a proper instance.
Available since: 5.0.0
session : Object
let element = document.body.querySelector('ext-calendar_timefield');
element.applyStyle(style, oldStyle);
style : Object
oldStyle : Object
let element = document.body.querySelector('ext-calendar_timefield');
element.applyTpl(tpl);
tpl : Object
let element = document.body.querySelector('ext-calendar_timefield');
element.applyValidators(validators);
validators : Object
let element = document.body.querySelector('ext-calendar_timefield');
let applyViewModel = element.applyViewModel(viewModel);
Transforms a ViewModel config to a proper instance.
Available since: 5.0.0
viewModel : String/Object/Ext.app.ViewModel
let element = document.body.querySelector('ext-calendar_timefield');
element.beforeInitialize();
let element = document.body.querySelector('ext-calendar_timefield');
element.beginSyncChildDirty();
This method is called when the component hierarchy has changed and the current set
of descendants will be reasserting their dirty
state. This method is only called
on nameHolder
containers.
let element = document.body.querySelector('ext-calendar_timefield');
element.bubble(fn, scope, args);
Bubbles up the getRefOwner hierarchy, calling the specified function
with each component. The scope (this
reference) of the function call will be the
scope provided or the current component. The arguments to the function will
be the args provided or the current component. If the function returns false at any
point, the bubble is stopped.
fn : Function
The function to call
scope : Object (optional)
The scope of the function. Defaults to current node.
args : Array (optional)
The args to call the function with. Defaults to passing the current component.
let element = document.body.querySelector('ext-calendar_timefield');
let callOverridden = element.callOverridden(args);
Call the original method that was previously overridden with Ext.Base#override
Ext.define('My.Cat', {
constructor: function() {
alert("I'm a cat!");
}
});
My.Cat.override({
constructor: function() {
alert("I'm going to be a cat!");
this.callOverridden();
alert("Meeeeoooowwww");
}
});
var kitty = new My.Cat(); // alerts "I'm going to be a cat!"
// alerts "I'm a cat!"
// alerts "Meeeeoooowwww"
args : Array/Arguments
The arguments, either an array or the arguments
object
from the current method, for example: this.callOverridden(arguments)
Returns the result of calling the overridden method
Deprecated since version 4.1.0
Use method-callParent instead.
let element = document.body.querySelector('ext-calendar_timefield');
let callParent = element.callParent(args);
Call the "parent" method of the current method. That is the method previously overridden by derivation or by an override (see Ext#define).
Ext.define('My.Base', {
constructor: function(x) {
this.x = x;
},
statics: {
method: function(x) {
return x;
}
}
});
Ext.define('My.Derived', {
extend: 'My.Base',
constructor: function() {
this.callParent([21]);
}
});
var obj = new My.Derived();
alert(obj.x); // alerts 21
This can be used with an override as follows:
Ext.define('My.DerivedOverride', {
override: 'My.Derived',
constructor: function(x) {
this.callParent([x*2]); // calls original My.Derived constructor
}
});
var obj = new My.Derived();
alert(obj.x); // now alerts 42
This also works with static and private methods.
Ext.define('My.Derived2', {
extend: 'My.Base',
// privates: {
statics: {
method: function(x) {
return this.callParent([x*2]); // calls My.Base.method
}
}
});
alert(My.Base.method(10)); // alerts 10
alert(My.Derived2.method(10)); // alerts 20
Lastly, it also works with overridden static methods.
Ext.define('My.Derived2Override', {
override: 'My.Derived2',
// privates: {
statics: {
method: function(x) {
return this.callParent([x*2]); // calls My.Derived2.method
}
}
});
alert(My.Derived2.method(10); // now alerts 40
To override a method and replace it and also call the superclass method, use method-callSuper. This is often done to patch a method to fix a bug.
args : Array/Arguments
The arguments, either an array or the arguments
object
from the current method, for example: this.callParent(arguments)
Returns the result of calling the parent method
let element = document.body.querySelector('ext-calendar_timefield');
let callSuper = element.callSuper(args);
This method is used by an override to call the superclass method but bypass any overridden method. This is often done to "patch" a method that contains a bug but for whatever reason cannot be fixed directly.
Consider:
Ext.define('Ext.some.Class', {
method: function() {
console.log('Good');
}
});
Ext.define('Ext.some.DerivedClass', {
extend: 'Ext.some.Class',
method: function() {
console.log('Bad');
// ... logic but with a bug ...
this.callParent();
}
});
To patch the bug in Ext.some.DerivedClass.method
, the typical solution is to create an
override:
Ext.define('App.patches.DerivedClass', {
override: 'Ext.some.DerivedClass',
method: function() {
console.log('Fixed');
// ... logic but with bug fixed ...
this.callSuper();
}
});
The patch method cannot use method-callParent to call the superclass
method
since that would call the overridden method containing the bug. In
other words, the above patch would only produce "Fixed" then "Good" in the
console log, whereas, using callParent
would produce "Fixed" then "Bad"
then "Good".
args : Array/Arguments
The arguments, either an array or the arguments
object
from the current method, for example: this.callSuper(arguments)
Returns the result of calling the superclass method
let element = document.body.querySelector('ext-calendar_timefield');
let center = element.center();
Center this cfg-floated or positioned Component in its parent.
this
let element = document.body.querySelector('ext-calendar_timefield');
element.clearDelegatedListeners();
Clears all listeners that were attached using the "delegate" event option. Users should not invoke this method directly. It is called automatically as part of normal clearListeners processing.
let element = document.body.querySelector('ext-calendar_timefield');
element.clearInvalid();
Mark field as valid.
Available since: 6.5.0
Deprecated since version 6.5.0
Use setError(null) instead. (for classic compatibility)
let element = document.body.querySelector('ext-calendar_timefield');
element.clearListeners();
Removes all listeners for this object including the managed listeners
let element = document.body.querySelector('ext-calendar_timefield');
element.clearManagedListeners();
Removes all managed listeners for this object.
let element = document.body.querySelector('ext-calendar_timefield');
element.clearValue();
Clears the value of this field.
let element = document.body.querySelector('ext-calendar_timefield');
element.collapseIf(e);
Runs on touchstart of doc to check to see if we should collapse the picker.
e : Object
let element = document.body.querySelector('ext-calendar_timefield');
element.completeEdit();
Called when focus leaves this input field. Used to postprocess raw values and perform conversion and validation.
let element = document.body.querySelector('ext-calendar_timefield');
element.constructor(config);
Creates new Component.
config : Object
The standard configuration object.
let element = document.body.querySelector('ext-calendar_timefield');
let createEnteredRecord = element.createEnteredRecord(value);
This is used by the field to create a new record if forceSelection
is false
.
value : Object
The created record, if it can be created from the passed value.
let element = document.body.querySelector('ext-calendar_timefield');
let createPlugin = element.createPlugin(config);
Converts the provided type or config object into a plugin instance.
config : String/Object/Ext.plugin.Abstract
The plugin type, config object or instance.
let element = document.body.querySelector('ext-calendar_timefield');
let createRelayer = element.createRelayer(newName, beginEnd);
Creates an event handling function which re-fires the event from this object as the passed event name.
newName : String
The name under which to re-fire the passed parameters.
beginEnd : Array (optional)
The caller can specify on which indices to slice.
let element = document.body.querySelector('ext-calendar_timefield');
let createSelectionRecord = element.createSelectionRecord(data);
This method is called to create a temporary record when the value entered does not
match a record in the store
(when forceSelection is false
).
The data
object passed contains the typed value in both the valueField
and the displayField.
The record created and returned from this method will be the selection value in this non-matching state.
Available since: 6.5.1
data : Object
The data object used to create the new record.
The new record.
This is a template method. a hook into the functionality of this class. Feel free to override it in child classes.
let element = document.body.querySelector('ext-calendar_timefield');
element.createTrigger(name, trigger);
name : Object
trigger : Object
let element = document.body.querySelector('ext-calendar_timefield');
element.destroy();
Destroys the Widget. This method should not be overridden in custom Widgets, because it sets the flags and does final cleanup that must go last. Instead, override doDestroy method to add functionality at destruction time.
let element = document.body.querySelector('ext-calendar_timefield');
element.destroyMembers(args);
Destroys member properties by name.
If a property name is the name of a config, the getter is not invoked, so if the config has not been initialized, nothing will be done.
The property will be destroyed, and the corrected name (if the property is a config
and config names are prefixed) will set to null
in this object's dictionary.
args : String...
One or more names of the properties to destroy and remove from the object.
let element = document.body.querySelector('ext-calendar_timefield');
let destroyPlugin = element.destroyPlugin(plugin);
Removes and destroys a plugin.
Note: Not all plugins are designed to be removable. Consult the documentation for the specific plugin in question to be sure.
Available since: 6.2.0
plugin : String/Ext.plugin.Abstract
The plugin or its id
to remove.
plugin instance or null
if not found.
let element = document.body.querySelector('ext-calendar_timefield');
element.didValueChange(newVal, oldVal);
Checks if the value has changed. Allows subclasses to override for any more complex logic.
newVal : Object
oldVal : Object
let element = document.body.querySelector('ext-calendar_timefield');
element.disable();
Disables this Component
let element = document.body.querySelector('ext-calendar_timefield');
element.doAddListener(name, fn, scope, options, order, caller, manager);
name : Object
fn : Object
scope : Object
options : Object
order : Object
caller : Object
manager : Object
let element = document.body.querySelector('ext-calendar_timefield');
element.doClearIconTap();
let element = document.body.querySelector('ext-calendar_timefield');
element.doDestroy();
Perform the actual destruction sequence. This is the method to override in your subclasses to add steps specific to the destruction of custom Component.
If the Component is currently added to a Container it will first be removed from that Container. All Ext.Element references are also deleted and the Component is de-registered from Ext.ComponentManager.
As a rule of thumb, subclasses should destroy their child Components, Elements, and/or other objects before calling parent method. Any object references will be nulled after this method has finished, to prevent the possibility of memory leaks.
Available since: 6.2.0
let element = document.body.querySelector('ext-calendar_timefield');
element.doFireDelegatedEvent(eventName, args);
Fires a delegated event. Users should not invoke this method directly. It is called automatically by the framework as needed (see the "delegate" event option of addListener for more details.
eventName : Object
args : Object
let element = document.body.querySelector('ext-calendar_timefield');
element.doFireEvent(eventName, args, bubbles);
Continue to fire event.
eventName : String
args : Array
bubbles : Boolean
let element = document.body.querySelector('ext-calendar_timefield');
element.doInheritUi();
let element = document.body.querySelector('ext-calendar_timefield');
element.doKeyUp(me, e);
Called when a key has been pressed in the <input>
me : Object
e : Object
let element = document.body.querySelector('ext-calendar_timefield');
element.doUninheritUi();
let element = document.body.querySelector('ext-calendar_timefield');
element.doValidate(value, errors, skipLazy);
This method is called by validate if the value is both
non-empty (not null
, undefined
or ''
) and if the value can be parsed by the
parseValue method. This parsing concern is technically
only in play for <ext-textfield/>
and derived classes (such as <ext-datefield/> <ext-datepickerfield/>
and
<ext-numberfield/>
) but the guarantee here is that the value
will be a parsed
value and not the raw string and if the value cannot be parsed, this method will
not be called.
value : Mixed
The (parsed) value
errors : String[]
The array of validation errors
skipLazy : Boolean (optional)
false
(the default) to run all validators.
let element = document.body.querySelector('ext-calendar_timefield');
element.enable();
Enables this Component
let element = document.body.querySelector('ext-calendar_timefield');
element.enableBubble(eventNames);
Enables events fired by this Observable to bubble up an owner hierarchy by calling
this.getBubbleTarget()
if present. There is no implementation in the Observable
base class.
This is commonly used by Ext.Components to bubble events to owner Containers. See Ext.Component#getBubbleTarget. The default implementation in Ext.Component returns the Component's immediate owner. But if a known target is required, this can be overridden to access the required target more quickly.
Example:
Ext.define('Ext.overrides.form.field.Base', {
override: 'Ext.form.field.Base',
// Add functionality to Field's initComponent to enable
// the change event to bubble
initComponent: function () {
this.callParent();
this.enableBubble('change');
}
});
var myForm = Ext.create('Ext.form.Panel', {
title: 'User Details',
items: [{
...
}],
listeners: {
change: function() {
// Title goes red if form has been modified.
myForm.header.setStyle('color', 'red');
}
}
});
eventNames : String/String[]
The event name to bubble, or an Array of event names.
let element = document.body.querySelector('ext-calendar_timefield');
element.filterPicked(record);
Filter function to implement filterPickList. Filter out records which are in the valueCollection.
record : Ext.data.Model
The record to test for presence in the valueCollection.
let element = document.body.querySelector('ext-calendar_timefield');
element.findFloatParent(needsShow);
The method finds this floated component's floatParent. That means a DOM positioning container which acts as a root element for sibling floated components, and allows allows floated components to be absolutely positioned, and their encapsulating elements to be reordered to produce a visual stacking effect.
This component's element is appended to its floatParent.
There is a global floatParent element, created on demand when the first top level
floated component is shown. This may be an item child of a container configured with
cfg-floated: true
, or a free floated
component which is programatically
shown.
Child items of components inside a floated component may also be configured floated
.
These are give a floatParent which is created on demand wrapping the nearest floated
ancestor. This means that when that ancestor's element is brought to the top of the
stack (by moving its element to the end of its own floatParent), the descendant elements
will automatically remain above.
needsShow : Object
let element = document.body.querySelector('ext-calendar_timefield');
let findFocusTarget = element.findFocusTarget();
Finds an alternate Component to focus if this Component is disabled while focused, or focused while disabled, or otherwise unable to focus.
In both cases, focus must not be lost to document.body, but must move to an intuitively connectible Component, either a sibling, or uncle or nephew.
This is both for the convenience of keyboard users, and also for when focus is tracked within a Component tree such as for ComboBoxes and their dropdowns.
For example, a ComboBox with a PagingToolbar in is BoundList. If the "Next Page" button is hit, the LoadMask shows and focuses, the next page is the last page, so the "Next Page" button is disabled. When the LoadMask hides, it attempt to focus the last focused Component which is the disabled "Next Page" button. In this situation, focus should move to a sibling within the PagingToolbar.
A closely related focusable Component to which focus can move.
let element = document.body.querySelector('ext-calendar_timefield');
let findPlugin = element.findPlugin(type);
Retrieves plugin by its type
alias. For example:
var list = Ext.create({
xtype: 'list',
itemTpl: '<div class="item">{title}</div>',
store: 'Items',
plugins: ['listpaging', 'pullrefresh']
});
list.findPlugin('pullrefresh').setPullRefreshText('Pull to refresh...');
Note: See also getPlugin.
Available since: 6.2.0
type : String
The Plugin's type
as specified by the class's
alias configuration.
plugin instance or null
if not found.
let element = document.body.querySelector('ext-calendar_timefield');
let findRecordByDisplay = element.findRecordByDisplay(value);
Finds the record by searching values in the displayField.
value : Object
The value to match the field against.
The matched record or false
.
let element = document.body.querySelector('ext-calendar_timefield');
let findRecordByValue = element.findRecordByValue(value);
Finds the record in the store, or the valueCollection which has the valueField matching the passed value.
The valueCollection is included because of the createNewOnEnter, createNewOnBlur, and forceSelection configs which allow for insertion into the valueCollection of newly created records which are not in the configured store.
Also, a currently selected value may be filtered out of visibility in the configured store.
value : String
The value to match the valueField against.
The matched record or null.
let element = document.body.querySelector('ext-calendar_timefield');
element.finishSyncChildDirty();
This method is called when the component hierarchy has changed after the current set
of descendants has reasserted their dirty
state. This method is only called on
nameHolder
containers.
let element = document.body.querySelector('ext-calendar_timefield');
element.fireAction(eventName, args, fn, scope, options, order);
Fires the specified event with the passed parameters and executes a function (action).
By default, the action function will be executed after any "before" event handlers
(as specified using the order
option of
addListener
), but before any other
handlers are fired. This gives the "before" handlers an opportunity to
cancel the event by returning false
, and prevent the action function from
being called.
The action can also be configured to run after normal handlers, but before any "after"
handlers (as specified using the order
event option) by passing 'after'
as the order
parameter. This configuration gives any event handlers except
for "after" handlers the opportunity to cancel the event and prevent the action
function from being called.
eventName : String
The name of the event to fire.
args : Array
Arguments to pass to handlers and to the action function.
fn : Function
The action function.
scope : Object (optional)
The scope (this
reference) in which the handler function is
executed. If omitted, defaults to the object which fired the event.
options : Object (optional)
Event options for the action function. Accepts any
of the options of addListener
order : String (optional)
The order to call the action function relative
too the event handlers ('before'
or 'after'
). Note that this option is
simply used to sort the action function relative to the event handlers by "priority".
An order of 'before'
is equivalent to a priority of 99.5
, while an order of
'after'
is equivalent to a priority of -99.5
. See the priority
option
of addListener
for more details.
Defaults to: 'before'
Deprecated since version 5.5
Use fireEventedAction instead.
let element = document.body.querySelector('ext-calendar_timefield');
element.fireDirtyChange();
let element = document.body.querySelector('ext-calendar_timefield');
let fireEvent = element.fireEvent(eventName, args);
Fires the specified event with the passed parameters (minus the event name, plus
the options
object passed to addListener).
An event may be set to bubble up an Observable parent hierarchy (See Ext.Component#getBubbleTarget) by calling enableBubble.
eventName : String
The name of the event to fire.
args : Object...
Variable number of parameters are passed to handlers.
returns false if any of the handlers return false otherwise it returns true.
let element = document.body.querySelector('ext-calendar_timefield');
let fireEventArgs = element.fireEventArgs(eventName, args);
Fires the specified event with the passed parameter list.
An event may be set to bubble up an Observable parent hierarchy (See Ext.Component#getBubbleTarget) by calling enableBubble.
eventName : String
The name of the event to fire.
args : Object[]
An array of parameters which are passed to handlers.
returns false if any of the handlers return false otherwise it returns true.
let element = document.body.querySelector('ext-calendar_timefield');
let fireEventedAction = element.fireEventedAction(eventName, args, fn, scope, fnArgs);
Fires the specified event with the passed parameters and executes a function (action). Evented Actions will automatically dispatch a 'before' event passing. This event will be given a special controller that allows for pausing/resuming of the event flow.
By pausing the controller the updater and events will not run until resumed. Pausing, however, will not stop the processing of any other before events.
eventName : String
The name of the event to fire.
args : Array
Arguments to pass to handlers and to the action function.
fn : Function/String
The action function.
scope : Object (optional)
The scope (this
reference) in which the handler function is
executed. If omitted, defaults to the object which fired the event.
fnArgs : Array/Boolean (optional)
Optional arguments for the action fn
. If not
given, the normal args
will be used to call fn
. If false
is passed, the
args
are used but if the first argument is this instance it will be removed
from the args passed to the action function.
let element = document.body.querySelector('ext-calendar_timefield');
element.fireKey(e);
e : Object
let element = document.body.querySelector('ext-calendar_timefield');
element.fixDirtyState();
This method is called after _fixReference()
during the reference sync sweep. We
need to inform our parent if we are a leaf component and if we are dirty. If we are
a nameHolder
then we'll inform the parent in finishSyncChildDirty
.
let element = document.body.querySelector('ext-calendar_timefield');
let focus = element.focus(selectText);
Try to focus this component.
If this component is disabled or otherwise not focusable, a close relation will be targeted for focus instead to keep focus localized for keyboard users.
selectText : Boolean/Number[] (optional)
If applicable, true
to also select all the text
in this component, or an array consisting of start and end (defaults to start)
position of selection.
true
if focus target was found and focusing was attempted,
false
if no focusing attempt was made.
let element = document.body.querySelector('ext-calendar_timefield');
let formatErrors = element.formatErrors(errors);
Formats the given error(s) based on the given errorTpl and the specified errorTarget.
Available since: 6.5.0
errors : String[]
let element = document.body.querySelector('ext-calendar_timefield');
element.getAlignRegion(component, alignment, options);
component : Object
alignment : Object
options : Object
let element = document.body.querySelector('ext-calendar_timefield');
element.getAlignmentInfo(component, alignment);
Prepares information on aligning this to component using alignment. Also checks to see if this is already aligned to component according to alignment.
component : Object
alignment : Object
let element = document.body.querySelector('ext-calendar_timefield');
let getAriaLabelEl = element.getAriaLabelEl(reference);
Find component(s) that label or describe this component, and return the id(s) of their ariaEl elements.
reference : Function/String/String[] (optional)
Component reference, or array of component references, or a function that should return the proper attribute string. The function will be called in the context of the labelled component.
Element id string, or null
let element = document.body.querySelector('ext-calendar_timefield');
let getBubbleParent = element.getBubbleParent();
Gets the bubbling parent for an Observable
The bubble parent. null is returned if no bubble target exists
let element = document.body.querySelector('ext-calendar_timefield');
element.getClassCls();
let element = document.body.querySelector('ext-calendar_timefield');
let getConfig = element.getConfig(name, peek, ifInitialized);
Returns a specified config property value. If the name parameter is not passed, all current configuration options will be returned as key value pairs.
name : String (optional)
The name of the config property to get.
peek : Boolean (optional)
true
to peek at the raw value without calling the getter.
Defaults to: false
ifInitialized : Boolean (optional)
true
to only return the initialized property
value, not the raw config value, and not to trigger initialization. Returns
undefined
if the property has not yet been initialized.
Defaults to: false
The config property value.
let element = document.body.querySelector('ext-calendar_timefield');
element.getCurrentAlignmentInfo();
Current Alignment information from the last alignTo call
let element = document.body.querySelector('ext-calendar_timefield');
element.getCurrentConfig();