/**
* @class Ext.data.NodeInterface
* This class is meant to be used as a set of methods that are applied to the prototype of a
* Record to decorate it with a Node API. This means that models used in conjunction with a tree
* will have all of the tree related methods available on the model. In general this class will
* not be used directly by the developer.
*/
Ext.define('Ext.data.NodeInterface', {
requires: ['Ext.data.Field'],
statics: {
/**
* This method allows you to decorate a Record's prototype to implement the NodeInterface.
* This adds a set of methods, new events, new properties and new fields on every Record
* with the same Model as the passed Record.
* @param {Ext.data.Record} record The Record you want to decorate the prototype of.
* @static
*/
decorate: function(record) {
if (!record.isNode) {
// Apply the methods and fields to the prototype
// @TODO: clean this up to use proper class system stuff
var mgr = Ext.ModelManager,
modelName = record.modelName,
modelClass = mgr.getModel(modelName),
idName = modelClass.prototype.idProperty,
newFields = [],
i, newField, len;
// Start by adding the NodeInterface methods to the Model's prototype
modelClass.override(this.getPrototypeBody());
newFields = this.applyFields(modelClass, [
{name: idName, type: 'string', defaultValue: null},
{name: 'parentId', type: 'string', defaultValue: null},
{name: 'index', type: 'int', defaultValue: null},
{name: 'depth', type: 'int', defaultValue: 0},
{name: 'expanded', type: 'bool', defaultValue: false, persist: false},
{name: 'expandable', type: 'bool', defaultValue: true, persist: false},
{name: 'checked', type: 'auto', defaultValue: null},
{name: 'leaf', type: 'bool', defaultValue: false, persist: false},
{name: 'cls', type: 'string', defaultValue: null, persist: false},
{name: 'iconCls', type: 'string', defaultValue: null, persist: false},
{name: 'root', type: 'boolean', defaultValue: false, persist: false},
{name: 'isLast', type: 'boolean', defaultValue: false, persist: false},
{name: 'isFirst', type: 'boolean', defaultValue: false, persist: false},
{name: 'allowDrop', type: 'boolean', defaultValue: true, persist: false},
{name: 'allowDrag', type: 'boolean', defaultValue: true, persist: false},
{name: 'loaded', type: 'boolean', defaultValue: false, persist: false},
{name: 'loading', type: 'boolean', defaultValue: false, persist: false},
{name: 'href', type: 'string', defaultValue: null, persist: false},
{name: 'hrefTarget', type: 'string', defaultValue: null, persist: false},
{name: 'qtip', type: 'string', defaultValue: null, persist: false},
{name: 'qtitle', type: 'string', defaultValue: null, persist: false}
]);
len = newFields.length;
// Set default values
for (i = 0; i < len; ++i) {
newField = newFields[i];
if (record.get(newField.name) === undefined) {
record.data[newField.name] = newField.defaultValue;
}
}
}
Ext.applyIf(record, {
firstChild: null,
lastChild: null,
parentNode: null,
previousSibling: null,
nextSibling: null,
childNodes: []
});
// Commit any fields so the record doesn't show as dirty initially
record.commit(true);
record.enableBubble([
/**
* @event append
* Fires when a new child node is appended
* @param {Node} this This node
* @param {Node} node The newly appended node
* @param {Number} index The index of the newly appended node
*/
"append",
/**
* @event remove
* Fires when a child node is removed
* @param {Node} this This node
* @param {Node} node The removed node
*/
"remove",
/**
* @event move
* Fires when this node is moved to a new location in the tree
* @param {Node} this This node
* @param {Node} oldParent The old parent of this node
* @param {Node} newParent The new parent of this node
* @param {Number} index The index it was moved to
*/
"move",
/**
* @event insert
* Fires when a new child node is inserted.
* @param {Node} this This node
* @param {Node} node The child node inserted
* @param {Node} refNode The child node the node was inserted before
*/
"insert",
/**
* @event beforeappend
* Fires before a new child is appended, return false to cancel the append.
* @param {Node} this This node
* @param {Node} node The child node to be appended
*/
"beforeappend",
/**
* @event beforeremove
* Fires before a child is removed, return false to cancel the remove.
* @param {Node} this This node
* @param {Node} node The child node to be removed
*/
"beforeremove",
/**
* @event beforemove
* Fires before this node is moved to a new location in the tree. Return false to cancel the move.
* @param {Node} this This node
* @param {Node} oldParent The parent of this node
* @param {Node} newParent The new parent this node is moving to
* @param {Number} index The index it is being moved to
*/
"beforemove",
/**
* @event beforeinsert
* Fires before a new child is inserted, return false to cancel the insert.
* @param {Node} this This node
* @param {Node} node The child node to be inserted
* @param {Node} refNode The child node the node is being inserted before
*/
"beforeinsert",
/**
* @event expand
* Fires when this node is expanded.
* @param {Node} this The expanding node
*/
"expand",
/**
* @event collapse
* Fires when this node is collapsed.
* @param {Node} this The collapsing node
*/
"collapse",
/**
* @event beforeexpand
* Fires before this node is expanded.
* @param {Node} this The expanding node
*/
"beforeexpand",
/**
* @event beforecollapse
* Fires before this node is collapsed.
* @param {Node} this The collapsing node
*/
"beforecollapse",
/**
* @event sort
* Fires when this node's childNodes are sorted.
* @param {Node} this This node.
* @param {Array} The childNodes of this node.
*/
"sort"
]);
return record;
},
applyFields: function(modelClass, addFields) {
var modelPrototype = modelClass.prototype,
fields = modelPrototype.fields,
keys = fields.keys,
ln = addFields.length,
addField, i, name,
newFields = [];
for (i = 0; i < ln; i++) {
addField = addFields[i];
if (!Ext.Array.contains(keys, addField.name)) {
addField = Ext.create('data.field', addField);
newFields.push(addField);
fields.add(addField);
}
}
return newFields;
},
getPrototypeBody: function() {
return {
isNode: true,
/**
* Ensures that the passed object is an instance of a Record with the NodeInterface applied
* @return {Boolean}
*/
createNode: function(node) {
if (Ext.isObject(node) && !node.isModel) {
node = Ext.ModelManager.create(node, this.modelName);
}
// Make sure the node implements the node interface
return Ext.data.NodeInterface.decorate(node);
},
/**
* Returns true if this node is a leaf
* @return {Boolean}
*/
isLeaf : function() {
return this.get('leaf') === true;
},
/**
* Sets the first child of this node
* @private
* @param {Ext.data.NodeInterface} node
*/
setFirstChild : function(node) {
this.firstChild = node;
},
/**
* Sets the last child of this node
* @private
* @param {Ext.data.NodeInterface} node
*/
setLastChild : function(node) {
this.lastChild = node;
},
/**
* 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.
* @return {Boolean}
*/
updateInfo: function(silent) {
var me = this,
isRoot = me.isRoot(),
parentNode = me.parentNode,
isFirst = (!parentNode ? true : parentNode.firstChild == me),
isLast = (!parentNode ? true : parentNode.lastChild == me),
depth = 0,
parent = me,
children = me.childNodes,
len = children.length,
i = 0;
while (parent.parentNode) {
++depth;
parent = parent.parentNode;
}
me.beginEdit();
me.set({
isFirst: isFirst,
isLast: isLast,
depth: depth,
index: parentNode ? parentNode.indexOf(me) : 0,
parentId: parentNode ? parentNode.getId() : null
});
me.endEdit(silent);
if (silent) {
me.commit();
}
for (i = 0; i < len; i++) {
children[i].updateInfo(silent);
}
},
/**
* Returns true if this node is the last child of its parent
* @return {Boolean}
*/
isLast : function() {
return this.get('isLast');
},
/**
* Returns true if this node is the first child of its parent
* @return {Boolean}
*/
isFirst : function() {
return this.get('isFirst');
},
/**
* Returns true if this node has one or more child nodes, else false.
* @return {Boolean}
*/
hasChildNodes : function() {
return !this.isLeaf() && this.childNodes.length > 0;
},
/**
* Returns true if this node has one or more child nodes, or if the <tt>expandable</tt>
* node attribute is explicitly specified as true (see {@link #attributes}), otherwise returns false.
* @return {Boolean}
*/
isExpandable : function() {
var me = this;
if (me.get('expandable')) {
return !(me.isLeaf() || (me.isLoaded() && !me.hasChildNodes()));
}
return false;
},
/**
* <p>Insert node(s) as the last child node of this node.</p>
* <p>If the node was previously a child node of another parent node, it will be removed from that node first.</p>
* @param {Node/Array} node The node or Array of nodes to append
* @return {Node} The appended node if single append, or null if an array was passed
*/
appendChild : function(node, suppressEvents, suppressNodeUpdate) {
var me = this,
i, ln,
index,
oldParent,
ps;
// if passed an array or multiple args do them one by one
if (Ext.isArray(node)) {
for (i = 0, ln = node.length; i < ln; i++) {
me.appendChild(node[i]);
}
} else {
// Make sure it is a record
node = me.createNode(node);
if (suppressEvents !== true && me.fireEvent("beforeappend", me, node) === false) {
return false;
}
index = me.childNodes.length;
oldParent = node.parentNode;
// it's a move, make sure we move it cleanly
if (oldParent) {
if (suppressEvents !== true && node.fireEvent("beforemove", node, oldParent, me, index) === false) {
return false;
}
oldParent.removeChild(node, null, false, true);
}
index = me.childNodes.length;
if (index === 0) {
me.setFirstChild(node);
}
me.childNodes.push(node);
node.parentNode = me;
node.nextSibling = null;
me.setLastChild(node);
ps = me.childNodes[index - 1];
if (ps) {
node.previousSibling = ps;
ps.nextSibling = node;
ps.updateInfo(suppressNodeUpdate);
} else {
node.previousSibling = null;
}
node.updateInfo(suppressNodeUpdate);
// As soon as we append a child to this node, we are loaded
if (!me.isLoaded()) {
me.set('loaded', true);
}
// If this node didnt have any childnodes before, update myself
else if (me.childNodes.length === 1) {
me.set('loaded', me.isLoaded());
}
if (suppressEvents !== true) {
me.fireEvent("append", me, node, index);
if (oldParent) {
node.fireEvent("move", node, oldParent, me, index);
}
}
return node;
}
},
/**
* Returns the bubble target for this node
* @private
* @return {Object} The bubble target
*/
getBubbleTarget: function() {
return this.parentNode;
},
/**
* Removes a child node from this node.
* @param {Node} node The node to remove
* @param {Boolean} destroy <tt>true</tt> to destroy the node upon removal. Defaults to <tt>false</tt>.
* @return {Node} The removed node
*/
removeChild : function(node, destroy, suppressEvents, suppressNodeUpdate) {
var me = this,
index = me.indexOf(node);
if (index == -1 || (suppressEvents !== true && me.fireEvent("beforeremove", me, node) === false)) {
return false;
}
// remove it from childNodes collection
Ext.Array.erase(me.childNodes, index, 1);
// update child refs
if (me.firstChild == node) {
me.setFirstChild(node.nextSibling);
}
if (me.lastChild == node) {
me.setLastChild(node.previousSibling);
}
// update siblings
if (node.previousSibling) {
node.previousSibling.nextSibling = node.nextSibling;
node.previousSibling.updateInfo(suppressNodeUpdate);
}
if (node.nextSibling) {
node.nextSibling.previousSibling = node.previousSibling;
node.nextSibling.updateInfo(suppressNodeUpdate);
}
if (suppressEvents !== true) {
me.fireEvent("remove", me, node);
}
// If this node suddenly doesnt have childnodes anymore, update myself
if (!me.childNodes.length) {
me.set('loaded', me.isLoaded());
}
if (destroy) {
node.destroy(true);
} else {
node.clear();
}
return node;
},
/**
* Creates a copy (clone) of this Node.
* @param {String} id (optional) A new id, defaults to this Node's id. See <code>{@link #id}</code>.
* @param {Boolean} deep (optional) <p>If passed as <code>true</code>, all child Nodes are recursively copied into the new Node.</p>
* <p>If omitted or false, the copy will have no child Nodes.</p>
* @return {Node} A copy of this Node.
*/
copy: function(newId, deep) {
var me = this,
result = me.callOverridden(arguments),
len = me.childNodes ? me.childNodes.length : 0,
i;
// Move child nodes across to the copy if required
if (deep) {
for (i = 0; i < len; i++) {
result.appendChild(me.childNodes[i].copy(true));
}
}
return result;
},
/**
* Clear the node.
* @private
* @param {Boolean} destroy True to destroy the node.
*/
clear : function(destroy) {
var me = this;
// clear any references from the node
me.parentNode = me.previousSibling = me.nextSibling = null;
if (destroy) {
me.firstChild = me.lastChild = null;
}
},
/**
* Destroys the node.
*/
destroy : function(silent) {
/*
* Silent is to be used in a number of cases
* 1) When setRoot is called.
* 2) When destroy on the tree is called
* 3) For destroying child nodes on a node
*/
var me = this,
options = me.destroyOptions;
if (silent === true) {
me.clear(true);
Ext.each(me.childNodes, function(n) {
n.destroy(true);
});
me.childNodes = null;
delete me.destroyOptions;
me.callOverridden([options]);
} else {
me.destroyOptions = silent;
// overridden method will be called, since remove will end up calling destroy(true);
me.remove(true);
}
},
/**
* Inserts the first node before the second node in this nodes childNodes collection.
* @param {Node} node The node to insert
* @param {Node} refNode The node to insert before (if null the node is appended)
* @return {Node} The inserted node
*/
insertBefore : function(node, refNode, suppressEvents) {
var me = this,
index = me.indexOf(refNode),
oldParent = node.parentNode,
refIndex = index,
ps;
if (!refNode) { // like standard Dom, refNode can be null for append
return me.appendChild(node);
}
// nothing to do
if (node == refNode) {
return false;
}
// Make sure it is a record with the NodeInterface
node = me.createNode(node);
if (suppressEvents !== true && me.fireEvent("beforeinsert", me, node, refNode) === false) {
return false;
}
// when moving internally, indexes will change after remove
if (oldParent == me && me.indexOf(node) < index) {
refIndex--;
}
// it's a move, make sure we move it cleanly
if (oldParent) {
if (suppressEvents !== true && node.fireEvent("beforemove", node, oldParent, me, index, refNode) === false) {
return false;
}
oldParent.removeChild(node);
}
if (refIndex === 0) {
me.setFirstChild(node);
}
Ext.Array.splice(me.childNodes, refIndex, 0, node);
node.parentNode = me;
node.nextSibling = refNode;
refNode.previousSibling = node;
ps = me.childNodes[refIndex - 1];
if (ps) {
node.previousSibling = ps;
ps.nextSibling = node;
ps.updateInfo();
} else {
node.previousSibling = null;
}
node.updateInfo();
if (!me.isLoaded()) {
me.set('loaded', true);
}
// If this node didnt have any childnodes before, update myself
else if (me.childNodes.length === 1) {
me.set('loaded', me.isLoaded());
}
if (suppressEvents !== true) {
me.fireEvent("insert", me, node, refNode);
if (oldParent) {
node.fireEvent("move", node, oldParent, me, refIndex, refNode);
}
}
return node;
},
/**
* Insert a node into this node
* @param {Number} index The zero-based index to insert the node at
* @param {Ext.data.Model} node The node to insert
* @return {Ext.data.Record} The record you just inserted
*/
insertChild: function(index, node) {
var sibling = this.childNodes[index];
if (sibling) {
return this.insertBefore(node, sibling);
}
else {
return this.appendChild(node);
}
},
/**
* Removes this node from its parent
* @param {Boolean} destroy <tt>true</tt> to destroy the node upon removal. Defaults to <tt>false</tt>.
* @return {Node} this
*/
remove : function(destroy, suppressEvents) {
var parentNode = this.parentNode;
if (parentNode) {
parentNode.removeChild(this, destroy, suppressEvents, true);
}
return this;
},
/**
* Removes all child nodes from this node.
* @param {Boolean} destroy <tt>true</tt> to destroy the node upon removal. Defaults to <tt>false</tt>.
* @return {Node} this
*/
removeAll : function(destroy, suppressEvents) {
var cn = this.childNodes,
n;
while ((n = cn[0])) {
this.removeChild(n, destroy, suppressEvents);
}
return this;
},
/**
* Returns the child node at the specified index.
* @param {Number} index
* @return {Node}
*/
getChildAt : function(index) {
return this.childNodes[index];
},
/**
* Replaces one child node in this node with another.
* @param {Node} newChild The replacement node
* @param {Node} oldChild The node to replace
* @return {Node} The replaced node
*/
replaceChild : function(newChild, oldChild, suppressEvents) {
var s = oldChild ? oldChild.nextSibling : null;
this.removeChild(oldChild, suppressEvents);
this.insertBefore(newChild, s, suppressEvents);
return oldChild;
},
/**
* Returns the index of a child node
* @param {Node} node
* @return {Number} The index of the node or -1 if it was not found
*/
indexOf : function(child) {
return Ext.Array.indexOf(this.childNodes, child);
},
/**
* Returns depth of this node (the root node has a depth of 0)
* @return {Number}
*/
getDepth : function() {
return this.get('depth');
},
/**
* 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.
* @param {Function} fn The function to call
* @param {Object} scope (optional) The scope (<code>this</code> reference) in which the function is executed. Defaults to the current Node.
* @param {Array} args (optional) The args to call the function with (default to passing the current Node)
*/
bubble : function(fn, scope, args) {
var p = this;
while (p) {
if (fn.apply(scope || p, args || [p]) === false) {
break;
}
p = p.parentNode;
}
},
//<deprecated since=0.99>
cascade: function() {
if (Ext.isDefined(Ext.global.console)) {
Ext.global.console.warn('Ext.data.Node: cascade has been deprecated. Please use cascadeBy instead.');
}
return this.cascadeBy.apply(this, arguments);
},
//</deprecated>
/**
* Cascades down 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 cascade is stopped on that branch.
* @param {Function} fn The function to call
* @param {Object} scope (optional) The scope (<code>this</code> reference) in which the function is executed. Defaults to the current Node.
* @param {Array} args (optional) The args to call the function with (default to passing the current Node)
*/
cascadeBy : function(fn, scope, args) {
if (fn.apply(scope || this, args || [this]) !== false) {
var childNodes = this.childNodes,
length = childNodes.length,
i;
for (i = 0; i < length; i++) {
childNodes[i].cascadeBy(fn, scope, args);
}
}
},
/**
* Interates 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.
* @param {Function} fn The function to call
* @param {Object} scope (optional) The scope (<code>this</code> reference) in which the function is executed. Defaults to the current Node in the iteration.
* @param {Array} args (optional) The args to call the function with (default to passing the current Node)
*/
eachChild : function(fn, scope, args) {
var childNodes = this.childNodes,
length = childNodes.length,
i;
for (i = 0; i < length; i++) {
if (fn.apply(scope || this, args || [childNodes[i]]) === false) {
break;
}
}
},
/**
* Finds the first child that has the attribute with the specified value.
* @param {String} attribute The attribute name
* @param {Mixed} value The value to search for
* @param {Boolean} deep (Optional) True to search through nodes deeper than the immediate children
* @return {Node} The found child or null if none was found
*/
findChild : function(attribute, value, deep) {
return this.findChildBy(function() {
return this.get(attribute) == value;
}, null, deep);
},
/**
* Finds the first child by a custom function. The child matches if the function passed returns <code>true</code>.
* @param {Function} fn A function which must return <code>true</code> if the passed Node is the required Node.
* @param {Object} scope (optional) The scope (<code>this</code> reference) in which the function is executed. Defaults to the Node being tested.
* @param {Boolean} deep (Optional) True to search through nodes deeper than the immediate children
* @return {Node} The found child or null if none was found
*/
findChildBy : function(fn, scope, deep) {
var cs = this.childNodes,
len = cs.length,
i = 0, n, res;
for (; i < len; i++) {
n = cs[i];
if (fn.call(scope || n, n) === true) {
return n;
}
else if (deep) {
res = n.findChildBy(fn, scope, deep);
if (res !== null) {
return res;
}
}
}
return null;
},
/**
* Returns true if this node is an ancestor (at any point) of the passed node.
* @param {Node} node
* @return {Boolean}
*/
contains : function(node) {
return node.isAncestor(this);
},
/**
* Returns true if the passed node is an ancestor (at any point) of this node.
* @param {Node} node
* @return {Boolean}
*/
isAncestor : function(node) {
var p = this.parentNode;
while (p) {
if (p == node) {
return true;
}
p = p.parentNode;
}
return false;
},
/**
* Sorts this nodes children using the supplied sort function.
* @param {Function} fn A function which, when passed two Nodes, returns -1, 0 or 1 depending upon required sort order.
* @param {Boolean} recursive Whether or not to apply this sort recursively
* @param {Boolean} suppressEvent Set to true to not fire a sort event.
*/
sort : function(sortFn, recursive, suppressEvent) {
var cs = this.childNodes,
ln = cs.length,
i, n;
if (ln > 0) {
Ext.Array.sort(cs, sortFn);
for (i = 0; i < ln; i++) {
n = cs[i];
n.previousSibling = cs[i-1];
n.nextSibling = cs[i+1];
if (i === 0) {
this.setFirstChild(n);
n.updateInfo();
}
if (i == ln - 1) {
this.setLastChild(n);
n.updateInfo();
}
if (recursive && !n.isLeaf()) {
n.sort(sortFn, true, true);
}
}
if (suppressEvent !== true) {
this.fireEvent('sort', this, cs);
}
}
},
/**
* Returns true if this node is expaned
* @return {Boolean}
*/
isExpanded: function() {
return this.get('expanded');
},
/**
* Returns true if this node is loaded
* @return {Boolean}
*/
isLoaded: function() {
return this.get('loaded');
},
/**
* Returns true if this node is loading
* @return {Boolean}
*/
isLoading: function() {
return this.get('loading');
},
/**
* Returns true if this node is the root node
* @return {Boolean}
*/
isRoot: function() {
return !this.parentNode;
},
/**
* Returns true if this node is visible
* @return {Boolean}
*/
isVisible: function() {
var parent = this.parentNode;
while (parent) {
if (!parent.isExpanded()) {
return false;
}
parent = parent.parentNode;
}
return true;
},
/**
* Expand this node.
* @param {Function} recursive (Optional) True to recursively expand all the children
* @param {Function} callback (Optional) The function to execute once the expand completes
* @param {Object} scope (Optional) The scope to run the callback in
*/
expand: function(recursive, callback, scope) {
var me = this;
// all paths must call the callback (eventually) or things like
// selectPath fail
// First we start by checking if this node is a parent
if (!me.isLeaf()) {
// Now we check if this record is already expanding or expanded
if (!me.isLoading() && !me.isExpanded()) {
// The TreeStore actually listens for the beforeexpand method and checks
// whether we have to asynchronously load the children from the server
// first. Thats why we pass a callback function to the event that the
// store can call once it has loaded and parsed all the children.
me.fireEvent('beforeexpand', me, function() {
me.set('expanded', true);
me.fireEvent('expand', me, me.childNodes, false);
// Call the expandChildren method if recursive was set to true
if (recursive) {
me.expandChildren(true, callback, scope);
}
else {
Ext.callback(callback, scope || me, [me.childNodes]);
}
}, me);
}
// If it is is already expanded but we want to recursively expand then call expandChildren
else if (recursive) {
me.expandChildren(true, callback, scope);
}
else {
Ext.callback(callback, scope || me, [me.childNodes]);
}
// TODO - if the node isLoading, we probably need to defer the
// callback until it is loaded (e.g., selectPath would need us
// to not make the callback until the childNodes exist).
}
// If it's not then we fire the callback right away
else {
Ext.callback(callback, scope || me); // leaf = no childNodes
}
},
/**
* Expand all the children of this node.
* @param {Function} recursive (Optional) True to recursively expand all the children
* @param {Function} callback (Optional) The function to execute once all the children are expanded
* @param {Object} scope (Optional) The scope to run the callback in
*/
expandChildren: function(recursive, callback, scope) {
var me = this,
i = 0,
nodes = me.childNodes,
ln = nodes.length,
node,
expanding = 0;
for (; i < ln; ++i) {
node = nodes[i];
if (!node.isLeaf() && !node.isExpanded()) {
expanding++;
nodes[i].expand(recursive, function () {
expanding--;
if (callback && !expanding) {
Ext.callback(callback, scope || me, [me.childNodes]);
}
});
}
}
if (!expanding && callback) {
Ext.callback(callback, scope || me, [me.childNodes]); }
},
/**
* Collapse this node.
* @param {Function} recursive (Optional) True to recursively collapse all the children
* @param {Function} callback (Optional) The function to execute once the collapse completes
* @param {Object} scope (Optional) The scope to run the callback in
*/
collapse: function(recursive, callback, scope) {
var me = this;
// First we start by checking if this node is a parent
if (!me.isLeaf()) {
// Now we check if this record is already collapsing or collapsed
if (!me.collapsing && me.isExpanded()) {
me.fireEvent('beforecollapse', me, function() {
me.set('expanded', false);
me.fireEvent('collapse', me, me.childNodes, false);
// Call the collapseChildren method if recursive was set to true
if (recursive) {
me.collapseChildren(true, callback, scope);
}
else {
Ext.callback(callback, scope || me, [me.childNodes]);
}
}, me);
}
// If it is is already collapsed but we want to recursively collapse then call collapseChildren
else if (recursive) {
me.collapseChildren(true, callback, scope);
}
}
// If it's not then we fire the callback right away
else {
Ext.callback(callback, scope || me, [me.childNodes]);
}
},
/**
* Collapse all the children of this node.
* @param {Function} recursive (Optional) True to recursively collapse all the children
* @param {Function} callback (Optional) The function to execute once all the children are collapsed
* @param {Object} scope (Optional) The scope to run the callback in
*/
collapseChildren: function(recursive, callback, scope) {
var me = this,
i = 0,
nodes = me.childNodes,
ln = nodes.length,
node,
collapsing = 0;
for (; i < ln; ++i) {
node = nodes[i];
if (!node.isLeaf() && node.isExpanded()) {
collapsing++;
nodes[i].collapse(recursive, function () {
collapsing--;
if (callback && !collapsing) {
Ext.callback(callback, scope || me, [me.childNodes]);
}
});
}
}
if (!collapsing && callback) {
Ext.callback(callback, scope || me, [me.childNodes]);
}
}
};
}
}
});