/*
|
This file is part of Ext JS 4.2
|
|
Copyright (c) 2011-2013 Sencha Inc
|
|
Contact: http://www.sencha.com/contact
|
|
GNU General Public License Usage
|
This file may be used under the terms of the GNU General Public License version 3.0 as
|
published by the Free Software Foundation and appearing in the file LICENSE included in the
|
packaging of this file.
|
|
Please review the following information to ensure the GNU General Public License version 3.0
|
requirements will be met: http://www.gnu.org/copyleft/gpl.html.
|
|
If you are unsure which license is appropriate for your use, please contact the sales department
|
at http://www.sencha.com/contact.
|
|
Build date: 2013-05-16 14:36:50 (f9be68accb407158ba2b1be2c226a6ce1f649314)
|
*/
|
/**
|
* Node Store
|
* @private
|
*/
|
Ext.define('Ext.data.NodeStore', {
|
extend: 'Ext.data.Store',
|
alias: 'store.node',
|
requires: ['Ext.data.NodeInterface'],
|
|
/**
|
* @property {Boolean} isNodeStore
|
* `true` in this class to identify an object as an instantiated NodeStore, or subclass thereof.
|
*/
|
isNodeStore: true,
|
|
/**
|
* @cfg {Ext.data.Model} node
|
* The Record you want to bind this Store to. Note that
|
* this record will be decorated with the Ext.data.NodeInterface if this is not the
|
* case yet.
|
*/
|
node: null,
|
|
/**
|
* @cfg {Boolean} recursive
|
* Set this to true if you want this NodeStore to represent
|
* all the descendents of the node in its flat data collection. This is useful for
|
* rendering a tree structure to a DataView and is being used internally by
|
* the TreeView. Any records that are moved, removed, inserted or appended to the
|
* node at any depth below the node this store is bound to will be automatically
|
* updated in this Store's internal flat data structure.
|
*/
|
recursive: false,
|
|
/**
|
* @cfg {Boolean} rootVisible
|
* False to not include the root node in this Stores collection.
|
*/
|
rootVisible: false,
|
|
/**
|
* @cfg {Ext.data.TreeStore} treeStore
|
* The TreeStore that is used by this NodeStore's Ext.tree.View.
|
*/
|
|
/**
|
* @protected
|
* Recursion level counter. Incremented when expansion or collaping of a node is initiated,
|
* including when nested nodes below the expanding/collapsing root begin expanding or collapsing.
|
*
|
* This ensures that collapsestart, collapsecomplete, expandstart and expandcomplete only
|
* fire on the top level node being collapsed/expanded.
|
*
|
* Also, allows listeners to the `add` and `remove` events to know whether a collapse of expand is in progress.
|
*/
|
isExpandingOrCollapsing: 0,
|
|
constructor: function(config) {
|
var me = this,
|
node;
|
|
config = config || {};
|
Ext.apply(me, config);
|
|
//<debug>
|
if (Ext.isDefined(me.proxy)) {
|
Ext.Error.raise("A NodeStore cannot be bound to a proxy. Instead bind it to a record " +
|
"decorated with the NodeInterface by setting the node config.");
|
}
|
me.useModelWarning = false;
|
//</debug>
|
|
config.proxy = {type: 'proxy'};
|
me.callParent([config]);
|
|
node = me.node;
|
if (node) {
|
me.node = null;
|
me.setNode(node);
|
}
|
},
|
|
// NodeStores are never buffered or paged. They are loaded from the TreeStore to reflect all visible
|
// nodes.
|
// BufferedRenderer always asks for the *total* count, so this must return the count.
|
getTotalCount: function() {
|
return this.getCount();
|
},
|
|
setNode: function(node) {
|
var me = this;
|
if (me.node && me.node != node) {
|
// We want to unbind our listeners on the old node
|
me.mun(me.node, {
|
expand: me.onNodeExpand,
|
collapse: me.onNodeCollapse,
|
append: me.onNodeAppend,
|
insert: me.onNodeInsert,
|
bulkremove: me.onBulkRemove,
|
remove: me.onNodeRemove,
|
sort: me.onNodeSort,
|
scope: me
|
});
|
me.node = null;
|
}
|
|
if (node) {
|
Ext.data.NodeInterface.decorate(node.self);
|
me.removeAll();
|
if (me.rootVisible) {
|
me.add(node);
|
} else if (!node.isExpanded() && me.treeStore.autoLoad !== false) {
|
node.expand();
|
}
|
|
me.mon(node, {
|
expand: me.onNodeExpand,
|
collapse: me.onNodeCollapse,
|
append: me.onNodeAppend,
|
insert: me.onNodeInsert,
|
bulkremove: me.onBulkRemove,
|
remove: me.onNodeRemove,
|
sort: me.onNodeSort,
|
scope: me
|
});
|
me.node = node;
|
if (node.isExpanded() && node.isLoaded()) {
|
me.onNodeExpand(node, node.childNodes, true);
|
}
|
}
|
},
|
|
onNodeSort: function(node, childNodes) {
|
var me = this;
|
|
if ((me.indexOf(node) !== -1 || (node === me.node && !me.rootVisible) && node.isExpanded())) {
|
Ext.suspendLayouts();
|
me.onNodeCollapse(node, childNodes, true);
|
me.onNodeExpand(node, childNodes, true);
|
Ext.resumeLayouts(true);
|
}
|
},
|
|
// Triggered by a NodeInterface's bubbled "expand" event.
|
onNodeExpand: function(parent, records, suppressEvent) {
|
var me = this,
|
insertIndex = me.indexOf(parent) + 1,
|
toAdd = [];
|
|
// Used by the TreeView to bracket recursive expand & collapse ops
|
// and refresh the size. This is most effective when folder nodes are loaded,
|
// and this method is able to recurse.
|
if (!suppressEvent) {
|
me.fireEvent('beforeexpand', parent, records, insertIndex);
|
}
|
|
me.handleNodeExpand(parent, records, toAdd);
|
|
// The add event from this insertion is handled by TreeView.onAdd.
|
// That implementation calls parent and then ensures the previous sibling's joining lines are correct.
|
// The datachanged event is relayed by the TreeStore. Internally, that's not used.
|
me.insert(insertIndex, toAdd);
|
|
// Triggers the TreeView's onExpand method which calls refreshSize,
|
// and fires its afteritemexpand event
|
if (!suppressEvent) {
|
me.fireEvent('expand', parent, records);
|
}
|
},
|
|
// Collects child nodes to remove into the passed toRemove array.
|
// When available, all descendant nodes are pushed into that array using recursion.
|
handleNodeExpand: function(parent, records, toAdd) {
|
var me = this,
|
ln = records ? records.length : 0,
|
i, record;
|
|
// recursive is hardcoded to true in TreeView.
|
if (!me.recursive && parent !== me.node) {
|
return;
|
}
|
|
if (parent !== this.node && !me.isVisible(parent)) {
|
return;
|
}
|
|
if (ln) {
|
// The view items corresponding to these are rendered.
|
// Loop through and expand any of the non-leaf nodes which are expanded
|
for (i = 0; i < ln; i++) {
|
record = records[i];
|
|
// Add to array being collected by recursion when child nodes are loaded.
|
// Must be done here in loop so that child nodes are inserted into the stream in place
|
// in recursive calls.
|
toAdd.push(record);
|
|
if (record.isExpanded()) {
|
if (record.isLoaded()) {
|
// Take a shortcut - appends to toAdd array
|
me.handleNodeExpand(record, record.childNodes, toAdd);
|
}
|
else {
|
// Might be asynchronous if child nodes are not immediately available
|
record.set('expanded', false);
|
record.expand();
|
}
|
}
|
}
|
}
|
},
|
|
// Triggered by NodeInterface's bubbled bulkremove event
|
onBulkRemove: function(parent, childNodes, isMove) {
|
this.onNodeCollapse(parent, childNodes, true);
|
},
|
|
// Triggered by a NodeInterface's bubbled "collapse" event.
|
onNodeCollapse: function(parent, records, suppressEvent, callback, scope) {
|
var me = this,
|
collapseIndex = me.indexOf(parent) + 1,
|
node, lastNodeIndexPlus, sibling, found;
|
|
if (!me.recursive && parent !== me.node) {
|
return;
|
}
|
|
// Used by the TreeView to bracket recursive expand & collapse ops.
|
// The TreeViewsets up the animWrap object if we are animating.
|
// It also caches the collapse callback to call when it receives the
|
// end collapse event. See below.
|
if (!suppressEvent) {
|
me.fireEvent('beforecollapse', parent, records, collapseIndex, callback, scope);
|
}
|
|
// Only attempt to remove the records if they are there.
|
// Collapsing an ancestor node *immediately removes from the view, ALL its descendant nodes at all levels*.
|
// But if the collapse was recursive, all descendant root nodes will still fire their
|
// events. But we must ignore those events here - we have nothing to do.
|
if (records.length && me.data.contains(records[0])) {
|
|
// Calculate the index *one beyond* the last node we are going to remove
|
// Need to loop up the tree to find the nearest view sibling, since it could
|
// exist at some level above the current node.
|
node = parent;
|
while (node.parentNode) {
|
sibling = node.nextSibling;
|
if (sibling) {
|
found = true;
|
lastNodeIndexPlus = me.indexOf(sibling);
|
break;
|
} else {
|
node = node.parentNode;
|
}
|
}
|
if (!found) {
|
lastNodeIndexPlus = me.getCount();
|
}
|
|
// Remove the whole collapsed node set.
|
me.removeAt(collapseIndex, lastNodeIndexPlus - collapseIndex);
|
}
|
|
// Triggers the TreeView's onCollapse method which calls refreshSize,
|
// and fires its afteritecollapse event
|
if (!suppressEvent) {
|
me.fireEvent('collapse', parent, records, collapseIndex);
|
}
|
},
|
|
onNodeAppend: function(parent, node, index) {
|
var me = this,
|
refNode, sibling;
|
|
// Only react to a node append if it is to a node which is expanded, and is part of a tree
|
if (me.isVisible(node)) {
|
if (index === 0) {
|
refNode = parent;
|
} else {
|
sibling = node.previousSibling;
|
while (sibling.isExpanded() && sibling.lastChild) {
|
sibling = sibling.lastChild;
|
}
|
refNode = sibling;
|
}
|
me.insert(me.indexOf(refNode) + 1, node);
|
if (!node.isLeaf() && node.isExpanded()) {
|
if (node.isLoaded()) {
|
// Take a shortcut
|
me.onNodeExpand(node, node.childNodes, true);
|
} else if (!me.treeStore.fillCount ) {
|
// If the node has been marked as expanded, it means the children
|
// should be provided as part of the raw data. If we're filling the nodes,
|
// the children may not have been loaded yet, so only do this if we're
|
// not in the middle of populating the nodes.
|
node.set('expanded', false);
|
node.expand();
|
}
|
}
|
}
|
},
|
|
onNodeInsert: function(parent, node, refNode) {
|
var me = this,
|
index = this.indexOf(refNode);
|
|
if (index != -1 && me.isVisible(node)) {
|
me.insert(index, node);
|
if (!node.isLeaf() && node.isExpanded()) {
|
if (node.isLoaded()) {
|
// Take a shortcut
|
me.onNodeExpand(node, node.childNodes, true);
|
}
|
else {
|
node.set('expanded', false);
|
node.expand();
|
}
|
}
|
}
|
},
|
|
onNodeRemove: function(parent, node, isMove) {
|
var me = this;
|
if (me.indexOf(node) != -1) {
|
|
// If the removed node is a non-leaf and is expanded, use the onCollapse method to get rid
|
// of all descendants at any level.
|
if (!node.isLeaf() && node.isExpanded()) {
|
|
// onCollapse expects to be able to use the "collapsing" node's parentNode
|
// and nextSibling pointers so temporarily reinstate them.
|
// Reinstating them is safe because we pass the suppressEvents flag, and no user code
|
// is executed.
|
node.parentNode = node.removeContext.parentNode;
|
node.nextSibling = node.removeContext.nextSibling;
|
me.onNodeCollapse(node, node.childNodes, true);
|
node.parentNode = node.nextSibling = null;
|
}
|
me.remove(node);
|
}
|
},
|
|
isVisible: function(node) {
|
var parent = node.parentNode;
|
while (parent) {
|
// Hit root and it is expanded, the node is visible
|
if (parent === this.node && parent.data.expanded) {
|
return true;
|
}
|
|
// Hit a collapsed ancestor, the node is not visible
|
if (!parent.data.expanded) {
|
return false;
|
}
|
|
parent = parent.parentNode;
|
}
|
// Walked off the top - the node is not part of the tree structure
|
return false;
|
}
|
});
|
