Instance Methods
This method applies a versioned, deprecation declaration to this class. This
is typically called by the deprecated config.
Inserts node(s) as the last child node of this node.
If the node was previously a child node of another parent node, it will be removed from that node first.
node :
Ext.data.NodeInterface/Ext.data.NodeInterface[]/Object
The node or Array of nodes to append
suppressEvents :
Boolean
(optional)
True to suppress firing of
events.
Defaults to: false
commit :
Boolean
(optional)
Defaults to: false
:
Ext.data.NodeInterface
The appended node if single append, or null if an array was passed
Bubbles up the tree from this node, calling the specified function with each node. The arguments to the function
will be the args provided or the current node. If the function returns false at any point,
the bubble is stopped.
scope :
Object
(optional)
The scope (this reference) in which the function is executed. Defaults to the current Node.
args :
Array
(optional)
The args to call the function with. Defaults to passing the current Node.
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
Cascades down the tree from this node, calling the specified functions with each node. The arguments to the function
will be the args provided or the current node. If the before function returns false at any point,
the cascade is stopped on that branch.
Note that the 3 argument form passing fn, scope, args is still supported. The fn function is as before, called
before cascading down into child nodes. If it returns false, the child nodes are not traversed.
spec :
Object/Function
An object containing before and after
functions, scope and an argument list or simply the before function.
before :
Function
(optional)
A function to call on a node before
cascading down into child nodes. If it returns false, the child nodes
are not traversed.
after :
Function
(optional)
A function to call on a node after
cascading down into child nodes.
scope :
Object
(optional)
The scope (this reference) in which the
functions are executed. Defaults to the current Node.
args :
Array
(optional)
The args to call the function with. Defaults
to passing the current Node.
scope :
Object
(optional)
If spec is the before function instead of
an object, this argument is the this pointer.
args :
Array
(optional)
If spec is the before function instead of
an object, this argument is the args to pass.
after :
Function
(optional)
If spec is the before function instead of
an object, this argument is the after function to call.
Clears the node.
erase :
Boolean
(optional)
True to erase the node using the configured
proxy.
Defaults to: false
resetChildren :
Boolean
(optional)
True to reset child nodes
Defaults to: false
Collapse this node.
recursive :
Boolean
(optional)
True to recursively collapse all the children
Defaults to: false
callback :
Function
(optional)
The function to execute once the collapse completes
scope :
Object
(optional)
The scope to run the callback in
Collapse all the children of this node.
recursive :
Function
(optional)
True to recursively collapse all the children
Defaults to: false
callback :
Function
(optional)
The function to execute once all the children are collapsed
scope :
Object
(optional)
The scope to run the callback in
Returns true if this node is an ancestor (at any point) of the passed node.
node :
Ext.data.NodeInterface
:
Boolean
Creates a copy (clone) of this Node.
newId :
String
(optional)
A new id, defaults to this Node's id.
session :
Ext.data.session.Session
(optional)
The session to which the
new record belongs.
deep :
Boolean
(optional)
True to recursively copy all child nodes
into the new Node. False to copy without child Nodes.
Defaults to: false
:
Ext.data.NodeInterface
Ensures that the passed object is an instance of a Record with the NodeInterface applied
:
Ext.data.NodeInterface
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.
Iterates the child nodes of this node, calling the specified function
with each node. The arguments to the function will be the args
provided or the current node. If the function returns false at any
point, the iteration stops.
scope :
Object
(optional)
The scope (this reference) in which the
function is executed. Defaults to the Node on which eachChild is
called.
args :
Array
(optional)
The args to call the function with. Defaults to
passing the current Node.
Expand this node.
recursive :
Boolean
(optional)
True to recursively expand all the children
Defaults to: false
callback :
Function
(optional)
The function to execute once the expand completes
scope :
Object
(optional)
The scope to run the callback in
Expand all the children of this node.
recursive :
Boolean
(optional)
True to recursively expand all the children
Defaults to: false
callback :
Function
(optional)
The function to execute once all the children are expanded
scope :
Object
(optional)
The this pointer for the callback.
Finds the first child that has the attribute with the specified value.
deep :
Boolean
(optional)
True to search through nodes deeper than the immediate children
Defaults to: false
:
Ext.data.NodeInterface
The found child or null if none was found
Finds the first child by a custom function. The child matches if the function passed returns true.
fn :
Function
A function which must return true if the passed Node is the required Node.
scope :
Object
(optional)
The scope (this reference) in which the function is executed. Defaults to the Node being tested.
deep :
Boolean
(optional)
True to search through nodes deeper than the immediate children
Defaults to: false
:
Ext.data.NodeInterface
The found child or null if none was found
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.
:
Boolean
returns false if any of the handlers return false otherwise it returns true.
Returns the child node at the specified index.
:
Ext.data.NodeInterface
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.
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 tree this node is in.
:
Ext.tree.Panel
The tree panel which owns this node.
Gets the hierarchical path from the root of the current node.
field :
String
(optional)
The field to construct the path from. Defaults to the model idProperty.
separator :
String
(optional)
Defaults to: '/'
:
String
Returns the Ext.data.TreeStore which owns this node.
:
Ext.data.TreeStore
The TreeStore which owns this node.
Returns true if this node has one or more child nodes, else false.
:
Boolean
Returns the index of a child node
child :
Ext.data.NodeInterface
:
Number
The index of the child node or -1 if it was not found.
Returns the index of a child node that matches the id
id :
String
The id of the node to find
:
Number
The index of the node or -1 if it was not found
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
Inserts the first node before the second node in this nodes childNodes collection.
node :
Ext.data.NodeInterface/Ext.data.NodeInterface[]/Object
refNode :
Ext.data.NodeInterface
The node to insert before (if null the node is appended)
:
Ext.data.NodeInterface
Inserts a node into this node.
index :
Number
The zero-based index to insert the node at
node :
Ext.data.NodeInterface/Object
:
Ext.data.NodeInterface
The node you just inserted
Returns true if the passed node is an ancestor (at any point) of this node.
node :
Ext.data.NodeInterface
:
Boolean
Returns true if this node is a branch node, and the entire branch is fully loaded.
Using this method, it is possible to ascertain whether an
expandAll() call (classic toolkit TreePanel method) will have
access to all descendant nodes without incurring a store load.
:
Boolean
Returns true if this node has one or more child nodes, or if the expandable
node attribute is explicitly specified as true, otherwise returns false.
:
Boolean
Returns true if this node is expanded.
:
Boolean
Returns true if this node is the first child of its parent
:
Boolean
Returns true if this node is the last child of its parent
:
Boolean
Returns true if this node is a leaf
:
Boolean
Returns true if this node is loaded
:
Boolean
Returns true if this node is loading
:
Boolean
Returns true if this node is the root node
:
Boolean
Returns true if this node is visible. Note that visibility refers to
the structure of the tree, the Ext.tree.Panel#rootVisible
configuration is not taken into account here. If this method is called
on the root node, it will always be visible.
:
Boolean
Adds a "destroyable" object to an internal list of objects that will be destroyed
when this instance is destroyed (via destroy).
:
Object
Implement this method in a tree record subclass if it needs to track whenever it is registered
with a Ext.data.TreeStore.
treeStore :
Ext.data.TreeStore
The TreeStore to which the node is being registered.
This is a template method. a hook into the functionality of this
class. Feel free to override it in child classes.
Implement this method in a tree record subclass if it needs to track whenever it is unregistered
from a Ext.data.TreeStore.
treeStore :
Ext.data.TreeStore
The TreeStore from which the node is being unregistered.
This is a template method. a hook into the functionality of this
class. Feel free to override it in child classes.
Removes this node from its parent.
If the node is not phantom (only added in the client side), then it may be marked for removal.
If the owning Ext.data.TreeStore is set to track removed
then the node will be added to the stack of nodes due to be removed the next time the store is synced with the server.
If the owning Ext.data.TreeStore is set to auto synchronize
then the synchronize request will be initiated immediately.
erase :
Boolean
(optional)
True to erase the node using the configured proxy. This is only needed when the
owning Ext.data.TreeStore is not taking care of synchronization operations.
Defaults to: false
:
Ext.data.NodeInterface
Removes all child nodes from this node.
erase :
Boolean
(optional)
True to erase the node using the configured
proxy.
Defaults to: false
:
Ext.data.NodeInterface
Removes a child node from this node.
node :
Ext.data.NodeInterface
erase :
Boolean
(optional)
True to erase the record using the
configured proxy.
Defaults to: false
:
Ext.data.NodeInterface
Replaces one child node in this node with another.
newChild :
Ext.data.NodeInterface
oldChild :
Ext.data.NodeInterface
:
Ext.data.NodeInterface
Creates an object representation of this node including its children.
Sets the node into the collapsed state without affecting the UI.
This is called when a node is collapsed with the recursive flag. All the descendant
nodes will have been removed from the store, but descendant non-leaf nodes still
need to be set to the collapsed state without affecting the UI.
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
Sets the first child of this node
node :
Ext.data.NodeInterface
Sets the last child of this node
node :
Ext.data.NodeInterface
Sorts this nodes children using the supplied sort function.
sortFn :
Function
(optional)
A function which, when passed two Nodes, returns -1, 0 or 1 depending upon required sort order.
It omitted, the node is sorted according to the existing sorters in the owning Ext.data.TreeStore.
recursive :
Boolean
(optional)
True to apply this sort recursively
Defaults to: false
suppressEvent :
Boolean
(optional)
True to not fire a sort event.
Defaults to: false
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
Updates general data of this node like isFirst, isLast, depth. This
method is internally called after a node is moved. This shouldn't
have to be called by the developer unless they are creating custom
Tree plugins.
info :
Object
The info to update. May contain any of the following
:
String[]
The names of any persistent fields that were modified.
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
This method decorates a Model class such that it implements the interface of
a tree node. That is, it adds a set of methods, events, properties and fields
on every record.
modelClass :
Ext.Class/Ext.data.Model
The Model class or an instance of
the Model class you want to decorate. In either case, this method decorates
the class so all instances of that type will have the new capabilities.
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