Instance Methods
This method applies a versioned, deprecation declaration to this class. This
is typically called by the deprecated config.
A utility for grouping a set of modifications which may trigger value changes into a single transaction, to
prevent excessive firing of change events. This is useful for instance if the field has sub-fields which
are being updated as a group; you don't want the container field to check its own changed state for each subfield
change.
fn :
Function
The function to call with change checks suspended.
Template method before a field is reset.
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)
:
Object
Returns the result of calling the overridden method
Deprecated since version 4.1.0
Use method-callParent instead.
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)
:
Object
Returns the result of calling the parent method
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)
:
Object
Returns the result of calling the superclass method
Checks the isDirty state of the field and if it has changed since the last time it was checked,
fires the dirtychange event.
Cleans up values initialized by this Field mixin on the current instance.
Components using this mixin should call this method before being destroyed.
Clear any invalid styles/messages for this field. Components using this mixin should implement this method to
update the components rendering to clear any existing messages.
Note: this method does not cause the Field's validate or isValid methods to return true
if the value does not pass validation. So simply clearing a field's errors will not necessarily allow
submission of forms submitted with the Ext.form.action.Submit#clientValidation option set.
This method is called to cleanup an object and its resources. After calling
this method, the object should not be used any further in any way, including
access to its methods and properties.
To prevent potential memory leaks, all object references will be nulled
at the end of destruction sequence, unless clearPropertiesOnDestroy
is set to false.
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.
Checks if the value has changed. Allows subclasses to override for
any more complex logic.
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
:
Object
The config property value.
Runs this field's validators and returns an array of error messages for any validation failures. This is called
internally during validation and would not usually need to be used manually.
Each subclass should override or augment the return value to provide their own errors.
value :
Object
The value to get errors for (defaults to the current field value)
:
String[]
All error messages for this field; an empty Array if none.
Returns the initial configuration passed to the constructor when
instantiating this class.
Given this example Ext.button.Button definition and instance:
Ext.define('MyApp.view.Button', {
extend: 'Ext.button.Button',
xtype: 'mybutton',
scale: 'large',
enableToggle: true
});
var btn = Ext.create({
xtype: 'mybutton',
renderTo: Ext.getBody(),
text: 'Test Button'
});
Calling btn.getInitialConfig() would return an object including the config
options passed to the create method:
xtype: 'mybutton',
renderTo: // The document body itself
text: 'Test Button'
Calling btn.getInitialConfig('text')returns 'Test Button'.
name :
String
(optional)
Name of the config option to return.
:
Object/Mixed
The full config object or a single config value
when name parameter specified.
Returns the value(s) that should be saved to the Ext.data.Model instance for this field, when Ext.form.Basic#updateRecord is called. Typically this will be an object with a single name-value pair, the name
being this field's name and the value being its current data value. More advanced field
implementations may return more than one name-value pair. The returned values will be saved to the corresponding
field names in the Model.
Note that the values returned from this method are not guaranteed to have been successfully validated.
includeEmptyText :
Boolean
Whether or not to include empty text
:
Object
A mapping of submit parameter names to values; each value should be a string, or an array of
strings if that particular name has multiple values. It can also return null if there are no parameters to be
submitted.
Returns the parameter(s) that would be included in a standard form submit for this field. Typically this will be
an object with a single name-value pair, the name being this field's name and the value being
its current stringified value. More advanced field implementations may return more than one name-value pair.
Note that the values returned from this method are not guaranteed to have been successfully validated.
:
Object
A mapping of submit parameter names to values; each value should be a string, or an array of
strings if that particular name has multiple values. It can also return null if there are no parameters to be
submitted.
Initialize configuration for this class. a typical example:
Ext.define('My.awesome.Class', {
// The default config
config: {
name: 'Awesome',
isAwesome: true
},
constructor: function(config) {
this.initConfig(config);
}
});
var awesome = new My.awesome.Class({
name: 'Super Awesome'
});
alert(awesome.getName()); // 'Super Awesome'
:
Ext.Base
Initializes this Field mixin on the current instance. Components using this mixin should call this method during
their own initialization process.
Initializes the field's value based on the initial config.
Returns true if the value of this Field has been changed from its originalValue.
Will always return false if the field is disabled.
Note that if the owning Ext.form.Basic was configured with
trackResetOnLoad then the originalValue is updated when
the values are loaded by Ext.form.Basic.setValues.
:
Boolean
True if this field has been changed from its original value (and is not disabled),
false otherwise.
Returns whether two field values are logically equal. Field implementations may override this
to provide custom comparison logic appropriate for the particular field's data type.
value1 :
Object
The first value to compare
value2 :
Object
The second value to compare
:
Boolean
True if the values are equal, false if inequal.
Returns whether two values are logically equal.
Similar to isEqual, however null or undefined values will be treated as empty strings.
value1 :
Object
The first value to compare
value2 :
Object
The second value to compare
:
Boolean
True if the values are equal, false if inequal.
Returns whether this Field is a file upload field; if it returns true, forms will use special techniques for
submitting the form via AJAX. See Ext.form.Basic#hasUpload for details. If
this returns true, the extractFileInput method must also be implemented to return the corresponding file
input element.
:
Boolean
Returns whether or not the field value is currently valid by validating the field's current
value. The validitychange event will not be fired; use validate instead if you want the event
to fire. Note: disabled fields are always treated as valid.
Implementations are encouraged to ensure that this method does not have side-effects such as triggering error
message display.
:
Boolean
True if the value is valid, else false
Adds a "destroyable" object to an internal list of objects that will be destroyed
when this instance is destroyed (via destroy).
:
Object
Display one or more error messages associated with this field, using
Ext.form.Labelable#msgTarget to determine how to display the messages and
applying Ext.form.Labelable#invalidCls to the field's UI element.
var formPanel = Ext.create('Ext.form.Panel', {
title: 'Contact Info',
width: 300,
bodyPadding: 10,
renderTo: Ext.getBody(),
items: [{
xtype: 'textfield',
name: 'name',
id: 'nameId',
fieldLabel: 'Name'
}],
bbar: [{
text: 'Mark both fields invalid',
handler: function() {
var nameField = formPanel.getForm().findField('name');
nameField.markInvalid('Name invalid message');
// multiple error string syntax
// nameField.markInvalid(['First message', 'Second message']);
}
}]
});
Note: this method does not cause the Field's validate or
isValid methods to return false if the value does pass validation.
So simply marking a Field as invalid will not prevent submission of forms
submitted with the Ext.form.action.Submit#clientValidation option set.
errors :
String/String[]
The validation message(s) to display.
Called when the field's value changes. Performs validation if the validateOnChange
config is enabled, and invokes the dirty check.
Called when the field's dirty state changes.
Publish the value of this field.
Sets a single/multiple configuration options.
name :
String/Object
The name of the property to set, or a set of key value pairs to set.
value :
Object
(optional)
The value to set for the name parameter.
:
Ext.Base
Get the reference to the class from which this object was instantiated. Note that unlike Ext.Base#self,
this.statics() is scope-independent and it always returns the class from which it was called, regardless of what
this points to during run-time
Ext.define('My.Cat', {
statics: {
totalCreated: 0,
speciesName: 'Cat' // My.Cat.speciesName = 'Cat'
},
constructor: function() {
var statics = this.statics();
alert(statics.speciesName); // always equals to 'Cat' no matter what 'this' refers to
// equivalent to: My.Cat.speciesName
alert(this.self.speciesName); // dependent on 'this'
statics.totalCreated++;
},
clone: function() {
var cloned = new this.self(); // dependent on 'this'
cloned.groupName = this.statics().speciesName; // equivalent to: My.Cat.speciesName
return cloned;
}
});
Ext.define('My.SnowLeopard', {
extend: 'My.Cat',
statics: {
speciesName: 'Snow Leopard' // My.SnowLeopard.speciesName = 'Snow Leopard'
},
constructor: function() {
this.callParent();
}
});
var cat = new My.Cat(); // alerts 'Cat', then alerts 'Cat'
var snowLeopard = new My.SnowLeopard(); // alerts 'Cat', then alerts 'Snow Leopard'
var clone = snowLeopard.clone();
alert(Ext.getClassName(clone)); // alerts 'My.SnowLeopard'
alert(clone.groupName); // alerts 'Cat'
alert(My.Cat.totalCreated); // alerts 3
:
Ext.Class
Destroys a given set of linked objects. This is only needed if
the linked object is being destroyed before this instance.
names :
String[]
The names of the linked objects to destroy.
:
Ext.Base
Returns whether or not the field value is currently valid by validating the field's current
value, and fires the validitychange event if the field's validity has changed since the last validation.
Note: disabled fields are always treated as valid.
Custom implementations of this method are allowed to have side-effects such as triggering error message display.
To validate without side-effects, use isValid.
:
Boolean
True if the value is valid, else false
Static Methods
Adds new config properties to this class. This is called for classes when they
are declared, then for any mixins that class may define and finally for any
overrides defined that target the class.
mixinClass :
Ext.Class
(optional)
The mixin class if the configs are from a mixin.
Add methods / properties to the prototype of this class.
Ext.define('My.awesome.Cat', {
constructor: function() {
...
}
});
My.awesome.Cat.addMembers({
meow: function() {
alert('Meowww...');
}
});
var kitty = new My.awesome.Cat();
kitty.meow();
members :
Object
The members to add to this class.
isStatic :
Boolean
(optional)
Pass true if the members are static.
Defaults to: false
privacy :
Boolean
(optional)
Pass true if the members are private. This
only has meaning in debug mode and only for methods.
Defaults to: false
:
Add / override static properties of this class.
Ext.define('My.cool.Class', {
...
});
My.cool.Class.addStatics({
someProperty: 'someValue', // My.cool.Class.someProperty = 'someValue'
method1: function() { ... }, // My.cool.Class.method1 = function() { ... };
method2: function() { ... } // My.cool.Class.method2 = function() { ... };
});
:
Ext.Base
Borrow another class' members to the prototype of this class.
Ext.define('Bank', {
money: '$$$',
printMoney: function() {
alert('$$$$$$$');
}
});
Ext.define('Thief', {
...
});
Thief.borrow(Bank, ['money', 'printMoney']);
var steve = new Thief();
alert(steve.money); // alerts '$$$'
steve.printMoney(); // alerts '$$$$$$$'
fromClass :
Ext.Base
The class to borrow members from
members :
Array/String
The names of the members to borrow
:
Ext.Base
Create a new instance of this Class.
Ext.define('My.cool.Class', {
...
});
My.cool.Class.create({
someConfig: true
});
All parameters are passed to the constructor of the class.
:
Object
Create aliases for existing prototype methods. Example:
Ext.define('My.cool.Class', {
method1: function() { ... },
method2: function() { ... }
});
var test = new My.cool.Class();
My.cool.Class.createAlias({
method3: 'method1',
method4: 'method2'
});
test.method3(); // test.method1()
My.cool.Class.createAlias('method5', 'method3');
test.method5(); // test.method3() -> test.method1()
alias :
String/Object
The new method name, or an object to set multiple aliases. See
flexSetter
Get the current class' name in string format.
Ext.define('My.cool.Class', {
constructor: function() {
alert(this.self.getName()); // alerts 'My.cool.Class'
}
});
My.cool.Class.getName(); // 'My.cool.Class'
:
String
Used internally by the mixins pre-processor
:
Override members of this class. Overridden methods can be invoked via
callParent.
Ext.define('My.Cat', {
constructor: function() {
alert("I'm a cat!");
}
});
My.Cat.override({
constructor: function() {
alert("I'm going to be a cat!");
this.callParent(arguments);
alert("Meeeeoooowwww");
}
});
var kitty = new My.Cat(); // alerts "I'm going to be a cat!"
// alerts "I'm a cat!"
// alerts "Meeeeoooowwww"
Direct use of this method should be rare. Use Ext.define
instead:
Ext.define('My.CatOverride', {
override: 'My.Cat',
constructor: function() {
alert("I'm going to be a cat!");
this.callParent(arguments);
alert("Meeeeoooowwww");
}
});
The above accomplishes the same result but can be managed by the Ext.Loader
which can properly order the override and its target class and the build process
can determine whether the override is needed based on the required state of the
target class (My.Cat).
members :
Object
The properties to add to this class. This should be
specified as an object literal containing one or more properties.
:
Ext.Base
Ext JS | Terms of Use
