/** * @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]); } } }; } } });