986 lines
39 KiB
HTML
986 lines
39 KiB
HTML
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
|
|
<title>The source code</title>
|
|
<link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
|
|
<script type="text/javascript" src="../resources/prettify/prettify.js"></script>
|
|
<style type="text/css">
|
|
.highlight { display: block; background-color: #ddd; }
|
|
</style>
|
|
<script type="text/javascript">
|
|
function highlight() {
|
|
document.getElementById(location.hash.replace(/#/, "")).className = "highlight";
|
|
}
|
|
</script>
|
|
</head>
|
|
<body onload="prettyPrint(); highlight();">
|
|
<pre class="prettyprint lang-js"><span id='Ext-tree-TreePanel-method-constructor'><span id='Ext-tree-TreePanel-cfg-requestMethod'><span id='Ext-tree-TreePanel-cfg-useArrows'><span id='Ext-tree-TreePanel-cfg-pathSeparator'><span id='Ext-tree-TreePanel-cfg-loader'><span id='Ext-tree-TreePanel-cfg-trackMouseOver'><span id='Ext-tree-TreePanel-cfg-selModel'><span id='Ext-tree-TreePanel-cfg-singleExpand'><span id='Ext-tree-TreePanel-cfg-animate'><span id='Ext-tree-TreePanel-cfg-hlColor'><span id='Ext-tree-TreePanel-cfg-hlDrop'><span id='Ext-tree-TreePanel-cfg-containerScroll'><span id='Ext-tree-TreePanel-cfg-ddScroll'><span id='Ext-tree-TreePanel-cfg-ddAppendOnly'><span id='Ext-tree-TreePanel-cfg-ddGroup'><span id='Ext-tree-TreePanel-cfg-dropConfig'><span id='Ext-tree-TreePanel-cfg-dragConfig'><span id='Ext-tree-TreePanel-cfg-enableDrop'><span id='Ext-tree-TreePanel-cfg-enableDrag'><span id='Ext-tree-TreePanel-cfg-enableDD'><span id='Ext-tree-TreePanel-cfg-lines'><span id='Ext-tree-TreePanel-cfg-rootVisible'><span id='Ext-tree-TreePanel-cfg-root'><span id='Ext-tree-TreePanel'>/**
|
|
</span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span> * @class Ext.tree.TreePanel
|
|
* @extends Ext.Panel
|
|
* <p>The TreePanel provides tree-structured UI representation of tree-structured data.</p>
|
|
* <p>{@link Ext.tree.TreeNode TreeNode}s added to the TreePanel may each contain metadata
|
|
* used by your application in their {@link Ext.tree.TreeNode#attributes attributes} property.</p>
|
|
* <p><b>A TreePanel must have a {@link #root} node before it is rendered.</b> This may either be
|
|
* specified using the {@link #root} config option, or using the {@link #setRootNode} method.
|
|
* <p>An example of tree rendered to an existing div:</p><pre><code>
|
|
var tree = new Ext.tree.TreePanel({
|
|
renderTo: 'tree-div',
|
|
useArrows: true,
|
|
autoScroll: true,
|
|
animate: true,
|
|
enableDD: true,
|
|
containerScroll: true,
|
|
border: false,
|
|
// auto create TreeLoader
|
|
dataUrl: 'get-nodes.php',
|
|
|
|
root: {
|
|
nodeType: 'async',
|
|
text: 'Ext JS',
|
|
draggable: false,
|
|
id: 'source'
|
|
}
|
|
});
|
|
|
|
tree.getRootNode().expand();
|
|
* </code></pre>
|
|
* <p>The example above would work with a data packet similar to this:</p><pre><code>
|
|
[{
|
|
"text": "adapter",
|
|
"id": "source\/adapter",
|
|
"cls": "folder"
|
|
}, {
|
|
"text": "dd",
|
|
"id": "source\/dd",
|
|
"cls": "folder"
|
|
}, {
|
|
"text": "debug.js",
|
|
"id": "source\/debug.js",
|
|
"leaf": true,
|
|
"cls": "file"
|
|
}]
|
|
* </code></pre>
|
|
* <p>An example of tree within a Viewport:</p><pre><code>
|
|
new Ext.Viewport({
|
|
layout: 'border',
|
|
items: [{
|
|
region: 'west',
|
|
collapsible: true,
|
|
title: 'Navigation',
|
|
xtype: 'treepanel',
|
|
width: 200,
|
|
autoScroll: true,
|
|
split: true,
|
|
loader: new Ext.tree.TreeLoader(),
|
|
root: new Ext.tree.AsyncTreeNode({
|
|
expanded: true,
|
|
children: [{
|
|
text: 'Menu Option 1',
|
|
leaf: true
|
|
}, {
|
|
text: 'Menu Option 2',
|
|
leaf: true
|
|
}, {
|
|
text: 'Menu Option 3',
|
|
leaf: true
|
|
}]
|
|
}),
|
|
rootVisible: false,
|
|
listeners: {
|
|
click: function(n) {
|
|
Ext.Msg.alert('Navigation Tree Click', 'You clicked: "' + n.attributes.text + '"');
|
|
}
|
|
}
|
|
}, {
|
|
region: 'center',
|
|
xtype: 'tabpanel',
|
|
// remaining code not shown ...
|
|
}]
|
|
});
|
|
</code></pre>
|
|
*
|
|
* @cfg {Ext.tree.TreeNode} root The root node for the tree.
|
|
* @cfg {Boolean} rootVisible <tt>false</tt> to hide the root node (defaults to <tt>true</tt>)
|
|
* @cfg {Boolean} lines <tt>false</tt> to disable tree lines (defaults to <tt>true</tt>)
|
|
* @cfg {Boolean} enableDD <tt>true</tt> to enable drag and drop
|
|
* @cfg {Boolean} enableDrag <tt>true</tt> to enable just drag
|
|
* @cfg {Boolean} enableDrop <tt>true</tt> to enable just drop
|
|
* @cfg {Object} dragConfig Custom config to pass to the {@link Ext.tree.TreeDragZone} instance
|
|
* @cfg {Object} dropConfig Custom config to pass to the {@link Ext.tree.TreeDropZone} instance
|
|
* @cfg {String} ddGroup The DD group this TreePanel belongs to
|
|
* @cfg {Boolean} ddAppendOnly <tt>true</tt> if the tree should only allow append drops (use for trees which are sorted)
|
|
* @cfg {Boolean} ddScroll <tt>true</tt> to enable body scrolling
|
|
* @cfg {Boolean} containerScroll <tt>true</tt> to register this container with ScrollManager
|
|
* @cfg {Boolean} hlDrop <tt>false</tt> to disable node highlight on drop (defaults to the value of {@link Ext#enableFx})
|
|
* @cfg {String} hlColor The color of the node highlight (defaults to <tt>'C3DAF9'</tt>)
|
|
* @cfg {Boolean} animate <tt>true</tt> to enable animated expand/collapse (defaults to the value of {@link Ext#enableFx})
|
|
* @cfg {Boolean} singleExpand <tt>true</tt> if only 1 node per branch may be expanded
|
|
* @cfg {Object} selModel A tree selection model to use with this TreePanel (defaults to an {@link Ext.tree.DefaultSelectionModel})
|
|
* @cfg {Boolean} trackMouseOver <tt>false</tt> to disable mouse over highlighting
|
|
* @cfg {Ext.tree.TreeLoader} loader A {@link Ext.tree.TreeLoader} for use with this TreePanel
|
|
* @cfg {String} pathSeparator The token used to separate sub-paths in path strings (defaults to <tt>'/'</tt>)
|
|
* @cfg {Boolean} useArrows <tt>true</tt> to use Vista-style arrows in the tree (defaults to <tt>false</tt>)
|
|
* @cfg {String} requestMethod The HTTP request method for loading data (defaults to the value of {@link Ext.Ajax#method}).
|
|
*
|
|
* @constructor
|
|
* @param {Object} config
|
|
* @xtype treepanel
|
|
*/
|
|
Ext.tree.TreePanel = Ext.extend(Ext.Panel, {
|
|
<span id='Ext-tree-TreePanel-property-rootVisible'> rootVisible : true,
|
|
</span><span id='Ext-tree-TreePanel-property-animate'> animate : Ext.enableFx,
|
|
</span><span id='Ext-tree-TreePanel-property-lines'> lines : true,
|
|
</span><span id='Ext-tree-TreePanel-property-enableDD'> enableDD : false,
|
|
</span><span id='Ext-tree-TreePanel-property-hlDrop'> hlDrop : Ext.enableFx,
|
|
</span><span id='Ext-tree-TreePanel-property-pathSeparator'> pathSeparator : '/',
|
|
</span>
|
|
<span id='Ext-tree-TreePanel-cfg-bubbleEvents'> /**
|
|
</span> * @cfg {Array} bubbleEvents
|
|
* <p>An array of events that, when fired, should be bubbled to any parent container.
|
|
* See {@link Ext.util.Observable#enableBubble}.
|
|
* Defaults to <tt>[]</tt>.
|
|
*/
|
|
bubbleEvents : [],
|
|
|
|
<span id='Ext-tree-TreePanel-method-initComponent'> initComponent : function(){
|
|
</span> Ext.tree.TreePanel.superclass.initComponent.call(this);
|
|
|
|
if(!this.eventModel){
|
|
this.eventModel = new Ext.tree.TreeEventModel(this);
|
|
}
|
|
|
|
// initialize the loader
|
|
var l = this.loader;
|
|
if(!l){
|
|
l = new Ext.tree.TreeLoader({
|
|
dataUrl: this.dataUrl,
|
|
requestMethod: this.requestMethod
|
|
});
|
|
}else if(Ext.isObject(l) && !l.load){
|
|
l = new Ext.tree.TreeLoader(l);
|
|
}
|
|
this.loader = l;
|
|
|
|
this.nodeHash = {};
|
|
|
|
<span id='Ext-tree-TreePanel-property-root'> /**
|
|
</span> * The root node of this tree.
|
|
* @type Ext.tree.TreeNode
|
|
* @property root
|
|
*/
|
|
if(this.root){
|
|
var r = this.root;
|
|
delete this.root;
|
|
this.setRootNode(r);
|
|
}
|
|
|
|
|
|
this.addEvents(
|
|
|
|
<span id='Ext-tree-TreePanel-event-append'> /**
|
|
</span> * @event append
|
|
* Fires when a new child node is appended to a node in this tree.
|
|
* @param {Tree} tree The owner tree
|
|
* @param {Node} parent The parent node
|
|
* @param {Node} node The newly appended node
|
|
* @param {Number} index The index of the newly appended node
|
|
*/
|
|
'append',
|
|
<span id='Ext-tree-TreePanel-event-remove'> /**
|
|
</span> * @event remove
|
|
* Fires when a child node is removed from a node in this tree.
|
|
* @param {Tree} tree The owner tree
|
|
* @param {Node} parent The parent node
|
|
* @param {Node} node The child node removed
|
|
*/
|
|
'remove',
|
|
<span id='Ext-tree-TreePanel-event-movenode'> /**
|
|
</span> * @event movenode
|
|
* Fires when a node is moved to a new location in the tree
|
|
* @param {Tree} tree The owner tree
|
|
* @param {Node} node The node moved
|
|
* @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
|
|
*/
|
|
'movenode',
|
|
<span id='Ext-tree-TreePanel-event-insert'> /**
|
|
</span> * @event insert
|
|
* Fires when a new child node is inserted in a node in this tree.
|
|
* @param {Tree} tree The owner tree
|
|
* @param {Node} parent The parent node
|
|
* @param {Node} node The child node inserted
|
|
* @param {Node} refNode The child node the node was inserted before
|
|
*/
|
|
'insert',
|
|
<span id='Ext-tree-TreePanel-event-beforeappend'> /**
|
|
</span> * @event beforeappend
|
|
* Fires before a new child is appended to a node in this tree, return false to cancel the append.
|
|
* @param {Tree} tree The owner tree
|
|
* @param {Node} parent The parent node
|
|
* @param {Node} node The child node to be appended
|
|
*/
|
|
'beforeappend',
|
|
<span id='Ext-tree-TreePanel-event-beforeremove'> /**
|
|
</span> * @event beforeremove
|
|
* Fires before a child is removed from a node in this tree, return false to cancel the remove.
|
|
* @param {Tree} tree The owner tree
|
|
* @param {Node} parent The parent node
|
|
* @param {Node} node The child node to be removed
|
|
*/
|
|
'beforeremove',
|
|
<span id='Ext-tree-TreePanel-event-beforemovenode'> /**
|
|
</span> * @event beforemovenode
|
|
* Fires before a node is moved to a new location in the tree. Return false to cancel the move.
|
|
* @param {Tree} tree The owner tree
|
|
* @param {Node} node The node being moved
|
|
* @param {Node} oldParent The parent of the node
|
|
* @param {Node} newParent The new parent the node is moving to
|
|
* @param {Number} index The index it is being moved to
|
|
*/
|
|
'beforemovenode',
|
|
<span id='Ext-tree-TreePanel-event-beforeinsert'> /**
|
|
</span> * @event beforeinsert
|
|
* Fires before a new child is inserted in a node in this tree, return false to cancel the insert.
|
|
* @param {Tree} tree The owner tree
|
|
* @param {Node} parent The parent node
|
|
* @param {Node} node The child node to be inserted
|
|
* @param {Node} refNode The child node the node is being inserted before
|
|
*/
|
|
'beforeinsert',
|
|
|
|
<span id='Ext-tree-TreePanel-event-beforeload'> /**
|
|
</span> * @event beforeload
|
|
* Fires before a node is loaded, return false to cancel
|
|
* @param {Node} node The node being loaded
|
|
*/
|
|
'beforeload',
|
|
<span id='Ext-tree-TreePanel-event-load'> /**
|
|
</span> * @event load
|
|
* Fires when a node is loaded
|
|
* @param {Node} node The node that was loaded
|
|
*/
|
|
'load',
|
|
<span id='Ext-tree-TreePanel-event-textchange'> /**
|
|
</span> * @event textchange
|
|
* Fires when the text for a node is changed
|
|
* @param {Node} node The node
|
|
* @param {String} text The new text
|
|
* @param {String} oldText The old text
|
|
*/
|
|
'textchange',
|
|
<span id='Ext-tree-TreePanel-event-beforeexpandnode'> /**
|
|
</span> * @event beforeexpandnode
|
|
* Fires before a node is expanded, return false to cancel.
|
|
* @param {Node} node The node
|
|
* @param {Boolean} deep
|
|
* @param {Boolean} anim
|
|
*/
|
|
'beforeexpandnode',
|
|
<span id='Ext-tree-TreePanel-event-beforecollapsenode'> /**
|
|
</span> * @event beforecollapsenode
|
|
* Fires before a node is collapsed, return false to cancel.
|
|
* @param {Node} node The node
|
|
* @param {Boolean} deep
|
|
* @param {Boolean} anim
|
|
*/
|
|
'beforecollapsenode',
|
|
<span id='Ext-tree-TreePanel-event-expandnode'> /**
|
|
</span> * @event expandnode
|
|
* Fires when a node is expanded
|
|
* @param {Node} node The node
|
|
*/
|
|
'expandnode',
|
|
<span id='Ext-tree-TreePanel-event-disabledchange'> /**
|
|
</span> * @event disabledchange
|
|
* Fires when the disabled status of a node changes
|
|
* @param {Node} node The node
|
|
* @param {Boolean} disabled
|
|
*/
|
|
'disabledchange',
|
|
<span id='Ext-tree-TreePanel-event-collapsenode'> /**
|
|
</span> * @event collapsenode
|
|
* Fires when a node is collapsed
|
|
* @param {Node} node The node
|
|
*/
|
|
'collapsenode',
|
|
<span id='Ext-tree-TreePanel-event-beforeclick'> /**
|
|
</span> * @event beforeclick
|
|
* Fires before click processing on a node. Return false to cancel the default action.
|
|
* @param {Node} node The node
|
|
* @param {Ext.EventObject} e The event object
|
|
*/
|
|
'beforeclick',
|
|
<span id='Ext-tree-TreePanel-event-click'> /**
|
|
</span> * @event click
|
|
* Fires when a node is clicked
|
|
* @param {Node} node The node
|
|
* @param {Ext.EventObject} e The event object
|
|
*/
|
|
'click',
|
|
<span id='Ext-tree-TreePanel-event-containerclick'> /**
|
|
</span> * @event containerclick
|
|
* Fires when the tree container is clicked
|
|
* @param {Tree} this
|
|
* @param {Ext.EventObject} e The event object
|
|
*/
|
|
'containerclick',
|
|
<span id='Ext-tree-TreePanel-event-checkchange'> /**
|
|
</span> * @event checkchange
|
|
* Fires when a node with a checkbox's checked property changes
|
|
* @param {Node} this This node
|
|
* @param {Boolean} checked
|
|
*/
|
|
'checkchange',
|
|
<span id='Ext-tree-TreePanel-event-beforedblclick'> /**
|
|
</span> * @event beforedblclick
|
|
* Fires before double click processing on a node. Return false to cancel the default action.
|
|
* @param {Node} node The node
|
|
* @param {Ext.EventObject} e The event object
|
|
*/
|
|
'beforedblclick',
|
|
<span id='Ext-tree-TreePanel-event-dblclick'> /**
|
|
</span> * @event dblclick
|
|
* Fires when a node is double clicked
|
|
* @param {Node} node The node
|
|
* @param {Ext.EventObject} e The event object
|
|
*/
|
|
'dblclick',
|
|
<span id='Ext-tree-TreePanel-event-containerdblclick'> /**
|
|
</span> * @event containerdblclick
|
|
* Fires when the tree container is double clicked
|
|
* @param {Tree} this
|
|
* @param {Ext.EventObject} e The event object
|
|
*/
|
|
'containerdblclick',
|
|
<span id='Ext-tree-TreePanel-event-contextmenu'> /**
|
|
</span> * @event contextmenu
|
|
* Fires when a node is right clicked. To display a context menu in response to this
|
|
* event, first create a Menu object (see {@link Ext.menu.Menu} for details), then add
|
|
* a handler for this event:<pre><code>
|
|
new Ext.tree.TreePanel({
|
|
title: 'My TreePanel',
|
|
root: new Ext.tree.AsyncTreeNode({
|
|
text: 'The Root',
|
|
children: [
|
|
{ text: 'Child node 1', leaf: true },
|
|
{ text: 'Child node 2', leaf: true }
|
|
]
|
|
}),
|
|
contextMenu: new Ext.menu.Menu({
|
|
items: [{
|
|
id: 'delete-node',
|
|
text: 'Delete Node'
|
|
}],
|
|
listeners: {
|
|
itemclick: function(item) {
|
|
switch (item.id) {
|
|
case 'delete-node':
|
|
var n = item.parentMenu.contextNode;
|
|
if (n.parentNode) {
|
|
n.remove();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}),
|
|
listeners: {
|
|
contextmenu: function(node, e) {
|
|
// Register the context node with the menu so that a Menu Item's handler function can access
|
|
// it via its {@link Ext.menu.BaseItem#parentMenu parentMenu} property.
|
|
node.select();
|
|
var c = node.getOwnerTree().contextMenu;
|
|
c.contextNode = node;
|
|
c.showAt(e.getXY());
|
|
}
|
|
}
|
|
});
|
|
</code></pre>
|
|
* @param {Node} node The node
|
|
* @param {Ext.EventObject} e The event object
|
|
*/
|
|
'contextmenu',
|
|
<span id='Ext-tree-TreePanel-event-containercontextmenu'> /**
|
|
</span> * @event containercontextmenu
|
|
* Fires when the tree container is right clicked
|
|
* @param {Tree} this
|
|
* @param {Ext.EventObject} e The event object
|
|
*/
|
|
'containercontextmenu',
|
|
<span id='Ext-tree-TreePanel-event-beforechildrenrendered'> /**
|
|
</span> * @event beforechildrenrendered
|
|
* Fires right before the child nodes for a node are rendered
|
|
* @param {Node} node The node
|
|
*/
|
|
'beforechildrenrendered',
|
|
<span id='Ext-tree-TreePanel-event-startdrag'> /**
|
|
</span> * @event startdrag
|
|
* Fires when a node starts being dragged
|
|
* @param {Ext.tree.TreePanel} this
|
|
* @param {Ext.tree.TreeNode} node
|
|
* @param {event} e The raw browser event
|
|
*/
|
|
'startdrag',
|
|
<span id='Ext-tree-TreePanel-event-enddrag'> /**
|
|
</span> * @event enddrag
|
|
* Fires when a drag operation is complete
|
|
* @param {Ext.tree.TreePanel} this
|
|
* @param {Ext.tree.TreeNode} node
|
|
* @param {event} e The raw browser event
|
|
*/
|
|
'enddrag',
|
|
<span id='Ext-tree-TreePanel-event-dragdrop'> /**
|
|
</span> * @event dragdrop
|
|
* Fires when a dragged node is dropped on a valid DD target
|
|
* @param {Ext.tree.TreePanel} this
|
|
* @param {Ext.tree.TreeNode} node
|
|
* @param {DD} dd The dd it was dropped on
|
|
* @param {event} e The raw browser event
|
|
*/
|
|
'dragdrop',
|
|
<span id='Ext-tree-TreePanel-event-beforenodedrop'> /**
|
|
</span> * @event beforenodedrop
|
|
* Fires when a DD object is dropped on a node in this tree for preprocessing. Return false to cancel the drop. The dropEvent
|
|
* passed to handlers has the following properties:<br />
|
|
* <ul style="padding:5px;padding-left:16px;">
|
|
* <li>tree - The TreePanel</li>
|
|
* <li>target - The node being targeted for the drop</li>
|
|
* <li>data - The drag data from the drag source</li>
|
|
* <li>point - The point of the drop - append, above or below</li>
|
|
* <li>source - The drag source</li>
|
|
* <li>rawEvent - Raw mouse event</li>
|
|
* <li>dropNode - Drop node(s) provided by the source <b>OR</b> you can supply node(s)
|
|
* to be inserted by setting them on this object.</li>
|
|
* <li>cancel - Set this to true to cancel the drop.</li>
|
|
* <li>dropStatus - If the default drop action is cancelled but the drop is valid, setting this to true
|
|
* will prevent the animated 'repair' from appearing.</li>
|
|
* </ul>
|
|
* @param {Object} dropEvent
|
|
*/
|
|
'beforenodedrop',
|
|
<span id='Ext-tree-TreePanel-event-nodedrop'> /**
|
|
</span> * @event nodedrop
|
|
* Fires after a DD object is dropped on a node in this tree. The dropEvent
|
|
* passed to handlers has the following properties:<br />
|
|
* <ul style="padding:5px;padding-left:16px;">
|
|
* <li>tree - The TreePanel</li>
|
|
* <li>target - The node being targeted for the drop</li>
|
|
* <li>data - The drag data from the drag source</li>
|
|
* <li>point - The point of the drop - append, above or below</li>
|
|
* <li>source - The drag source</li>
|
|
* <li>rawEvent - Raw mouse event</li>
|
|
* <li>dropNode - Dropped node(s).</li>
|
|
* </ul>
|
|
* @param {Object} dropEvent
|
|
*/
|
|
'nodedrop',
|
|
<span id='Ext-tree-TreePanel-event-nodedragover'> /**
|
|
</span> * @event nodedragover
|
|
* Fires when a tree node is being targeted for a drag drop, return false to signal drop not allowed. The dragOverEvent
|
|
* passed to handlers has the following properties:<br />
|
|
* <ul style="padding:5px;padding-left:16px;">
|
|
* <li>tree - The TreePanel</li>
|
|
* <li>target - The node being targeted for the drop</li>
|
|
* <li>data - The drag data from the drag source</li>
|
|
* <li>point - The point of the drop - append, above or below</li>
|
|
* <li>source - The drag source</li>
|
|
* <li>rawEvent - Raw mouse event</li>
|
|
* <li>dropNode - Drop node(s) provided by the source.</li>
|
|
* <li>cancel - Set this to true to signal drop not allowed.</li>
|
|
* </ul>
|
|
* @param {Object} dragOverEvent
|
|
*/
|
|
'nodedragover'
|
|
);
|
|
if(this.singleExpand){
|
|
this.on('beforeexpandnode', this.restrictExpand, this);
|
|
}
|
|
},
|
|
|
|
<span id='Ext-tree-TreePanel-method-proxyNodeEvent'> // private
|
|
</span> proxyNodeEvent : function(ename, a1, a2, a3, a4, a5, a6){
|
|
if(ename == 'collapse' || ename == 'expand' || ename == 'beforecollapse' || ename == 'beforeexpand' || ename == 'move' || ename == 'beforemove'){
|
|
ename = ename+'node';
|
|
}
|
|
// args inline for performance while bubbling events
|
|
return this.fireEvent(ename, a1, a2, a3, a4, a5, a6);
|
|
},
|
|
|
|
|
|
<span id='Ext-tree-TreePanel-method-getRootNode'> /**
|
|
</span> * Returns this root node for this tree
|
|
* @return {Node}
|
|
*/
|
|
getRootNode : function(){
|
|
return this.root;
|
|
},
|
|
|
|
<span id='Ext-tree-TreePanel-method-setRootNode'> /**
|
|
</span> * Sets the root node for this tree. If the TreePanel has already rendered a root node, the
|
|
* previous root node (and all of its descendants) are destroyed before the new root node is rendered.
|
|
* @param {Node} node
|
|
* @return {Node}
|
|
*/
|
|
setRootNode : function(node){
|
|
this.destroyRoot();
|
|
if(!node.render){ // attributes passed
|
|
node = this.loader.createNode(node);
|
|
}
|
|
this.root = node;
|
|
node.ownerTree = this;
|
|
node.isRoot = true;
|
|
this.registerNode(node);
|
|
if(!this.rootVisible){
|
|
var uiP = node.attributes.uiProvider;
|
|
node.ui = uiP ? new uiP(node) : new Ext.tree.RootTreeNodeUI(node);
|
|
}
|
|
if(this.innerCt){
|
|
this.clearInnerCt();
|
|
this.renderRoot();
|
|
}
|
|
return node;
|
|
},
|
|
|
|
<span id='Ext-tree-TreePanel-method-clearInnerCt'> clearInnerCt : function(){
|
|
</span> this.innerCt.update('');
|
|
},
|
|
|
|
<span id='Ext-tree-TreePanel-method-renderRoot'> // private
|
|
</span> renderRoot : function(){
|
|
this.root.render();
|
|
if(!this.rootVisible){
|
|
this.root.renderChildren();
|
|
}
|
|
},
|
|
|
|
<span id='Ext-tree-TreePanel-method-getNodeById'> /**
|
|
</span> * Gets a node in this tree by its id
|
|
* @param {String} id
|
|
* @return {Node}
|
|
*/
|
|
getNodeById : function(id){
|
|
return this.nodeHash[id];
|
|
},
|
|
|
|
<span id='Ext-tree-TreePanel-method-registerNode'> // private
|
|
</span> registerNode : function(node){
|
|
this.nodeHash[node.id] = node;
|
|
},
|
|
|
|
<span id='Ext-tree-TreePanel-method-unregisterNode'> // private
|
|
</span> unregisterNode : function(node){
|
|
delete this.nodeHash[node.id];
|
|
},
|
|
|
|
<span id='Ext-tree-TreePanel-method-toString'> // private
|
|
</span> toString : function(){
|
|
return '[Tree'+(this.id?' '+this.id:'')+']';
|
|
},
|
|
|
|
<span id='Ext-tree-TreePanel-method-restrictExpand'> // private
|
|
</span> restrictExpand : function(node){
|
|
var p = node.parentNode;
|
|
if(p){
|
|
if(p.expandedChild && p.expandedChild.parentNode == p){
|
|
p.expandedChild.collapse();
|
|
}
|
|
p.expandedChild = node;
|
|
}
|
|
},
|
|
|
|
<span id='Ext-tree-TreePanel-method-getChecked'> /**
|
|
</span> * Retrieve an array of checked nodes, or an array of a specific attribute of checked nodes (e.g. 'id')
|
|
* @param {String} attribute (optional) Defaults to null (return the actual nodes)
|
|
* @param {TreeNode} startNode (optional) The node to start from, defaults to the root
|
|
* @return {Array}
|
|
*/
|
|
getChecked : function(a, startNode){
|
|
startNode = startNode || this.root;
|
|
var r = [];
|
|
var f = function(){
|
|
if(this.attributes.checked){
|
|
r.push(!a ? this : (a == 'id' ? this.id : this.attributes[a]));
|
|
}
|
|
};
|
|
startNode.cascade(f);
|
|
return r;
|
|
},
|
|
|
|
<span id='Ext-tree-TreePanel-method-getLoader'> /**
|
|
</span> * Returns the default {@link Ext.tree.TreeLoader} for this TreePanel.
|
|
* @return {Ext.tree.TreeLoader} The TreeLoader for this TreePanel.
|
|
*/
|
|
getLoader : function(){
|
|
return this.loader;
|
|
},
|
|
|
|
<span id='Ext-tree-TreePanel-method-expandAll'> /**
|
|
</span> * Expand all nodes
|
|
*/
|
|
expandAll : function(){
|
|
this.root.expand(true);
|
|
},
|
|
|
|
<span id='Ext-tree-TreePanel-method-collapseAll'> /**
|
|
</span> * Collapse all nodes
|
|
*/
|
|
collapseAll : function(){
|
|
this.root.collapse(true);
|
|
},
|
|
|
|
<span id='Ext-tree-TreePanel-method-getSelectionModel'> /**
|
|
</span> * Returns the selection model used by this TreePanel.
|
|
* @return {TreeSelectionModel} The selection model used by this TreePanel
|
|
*/
|
|
getSelectionModel : function(){
|
|
if(!this.selModel){
|
|
this.selModel = new Ext.tree.DefaultSelectionModel();
|
|
}
|
|
return this.selModel;
|
|
},
|
|
|
|
<span id='Ext-tree-TreePanel-method-expandPath'> /**
|
|
</span> * Expands a specified path in this TreePanel. A path can be retrieved from a node with {@link Ext.data.Node#getPath}
|
|
* @param {String} path
|
|
* @param {String} attr (optional) The attribute used in the path (see {@link Ext.data.Node#getPath} for more info)
|
|
* @param {Function} callback (optional) The callback to call when the expand is complete. The callback will be called with
|
|
* (bSuccess, oLastNode) where bSuccess is if the expand was successful and oLastNode is the last node that was expanded.
|
|
*/
|
|
expandPath : function(path, attr, callback){
|
|
if(Ext.isEmpty(path)){
|
|
if(callback){
|
|
callback(false, undefined);
|
|
}
|
|
return;
|
|
}
|
|
attr = attr || 'id';
|
|
var keys = path.split(this.pathSeparator);
|
|
var curNode = this.root;
|
|
if(curNode.attributes[attr] != keys[1]){ // invalid root
|
|
if(callback){
|
|
callback(false, null);
|
|
}
|
|
return;
|
|
}
|
|
var index = 1;
|
|
var f = function(){
|
|
if(++index == keys.length){
|
|
if(callback){
|
|
callback(true, curNode);
|
|
}
|
|
return;
|
|
}
|
|
var c = curNode.findChild(attr, keys[index]);
|
|
if(!c){
|
|
if(callback){
|
|
callback(false, curNode);
|
|
}
|
|
return;
|
|
}
|
|
curNode = c;
|
|
c.expand(false, false, f);
|
|
};
|
|
curNode.expand(false, false, f);
|
|
},
|
|
|
|
<span id='Ext-tree-TreePanel-method-selectPath'> /**
|
|
</span> * Selects the node in this tree at the specified path. A path can be retrieved from a node with {@link Ext.data.Node#getPath}
|
|
* @param {String} path
|
|
* @param {String} attr (optional) The attribute used in the path (see {@link Ext.data.Node#getPath} for more info)
|
|
* @param {Function} callback (optional) The callback to call when the selection is complete. The callback will be called with
|
|
* (bSuccess, oSelNode) where bSuccess is if the selection was successful and oSelNode is the selected node.
|
|
*/
|
|
selectPath : function(path, attr, callback){
|
|
if(Ext.isEmpty(path)){
|
|
if(callback){
|
|
callback(false, undefined);
|
|
}
|
|
return;
|
|
}
|
|
attr = attr || 'id';
|
|
var keys = path.split(this.pathSeparator),
|
|
v = keys.pop();
|
|
if(keys.length > 1){
|
|
var f = function(success, node){
|
|
if(success && node){
|
|
var n = node.findChild(attr, v);
|
|
if(n){
|
|
n.select();
|
|
if(callback){
|
|
callback(true, n);
|
|
}
|
|
}else if(callback){
|
|
callback(false, n);
|
|
}
|
|
}else{
|
|
if(callback){
|
|
callback(false, n);
|
|
}
|
|
}
|
|
};
|
|
this.expandPath(keys.join(this.pathSeparator), attr, f);
|
|
}else{
|
|
this.root.select();
|
|
if(callback){
|
|
callback(true, this.root);
|
|
}
|
|
}
|
|
},
|
|
|
|
<span id='Ext-tree-TreePanel-method-getTreeEl'> /**
|
|
</span> * Returns the underlying Element for this tree
|
|
* @return {Ext.Element} The Element
|
|
*/
|
|
getTreeEl : function(){
|
|
return this.body;
|
|
},
|
|
|
|
<span id='Ext-tree-TreePanel-method-onRender'> // private
|
|
</span> onRender : function(ct, position){
|
|
Ext.tree.TreePanel.superclass.onRender.call(this, ct, position);
|
|
this.el.addClass('x-tree');
|
|
this.innerCt = this.body.createChild({tag:'ul',
|
|
cls:'x-tree-root-ct ' +
|
|
(this.useArrows ? 'x-tree-arrows' : this.lines ? 'x-tree-lines' : 'x-tree-no-lines')});
|
|
},
|
|
|
|
<span id='Ext-tree-TreePanel-method-initEvents'> // private
|
|
</span> initEvents : function(){
|
|
Ext.tree.TreePanel.superclass.initEvents.call(this);
|
|
|
|
if(this.containerScroll){
|
|
Ext.dd.ScrollManager.register(this.body);
|
|
}
|
|
if((this.enableDD || this.enableDrop) && !this.dropZone){
|
|
<span id='Ext-tree-TreePanel-property-dropZone'> /**
|
|
</span> * The dropZone used by this tree if drop is enabled (see {@link #enableDD} or {@link #enableDrop})
|
|
* @property dropZone
|
|
* @type Ext.tree.TreeDropZone
|
|
*/
|
|
this.dropZone = new Ext.tree.TreeDropZone(this, this.dropConfig || {
|
|
ddGroup: this.ddGroup || 'TreeDD', appendOnly: this.ddAppendOnly === true
|
|
});
|
|
}
|
|
if((this.enableDD || this.enableDrag) && !this.dragZone){
|
|
<span id='Ext-tree-TreePanel-property-dragZone'> /**
|
|
</span> * The dragZone used by this tree if drag is enabled (see {@link #enableDD} or {@link #enableDrag})
|
|
* @property dragZone
|
|
* @type Ext.tree.TreeDragZone
|
|
*/
|
|
this.dragZone = new Ext.tree.TreeDragZone(this, this.dragConfig || {
|
|
ddGroup: this.ddGroup || 'TreeDD',
|
|
scroll: this.ddScroll
|
|
});
|
|
}
|
|
this.getSelectionModel().init(this);
|
|
},
|
|
|
|
<span id='Ext-tree-TreePanel-method-afterRender'> // private
|
|
</span> afterRender : function(){
|
|
Ext.tree.TreePanel.superclass.afterRender.call(this);
|
|
this.renderRoot();
|
|
},
|
|
|
|
<span id='Ext-tree-TreePanel-method-beforeDestroy'> beforeDestroy : function(){
|
|
</span> if(this.rendered){
|
|
Ext.dd.ScrollManager.unregister(this.body);
|
|
Ext.destroy(this.dropZone, this.dragZone);
|
|
}
|
|
this.destroyRoot();
|
|
Ext.destroy(this.loader);
|
|
this.nodeHash = this.root = this.loader = null;
|
|
Ext.tree.TreePanel.superclass.beforeDestroy.call(this);
|
|
},
|
|
|
|
<span id='Ext-tree-TreePanel-method-destroyRoot'> /**
|
|
</span> * Destroy the root node. Not included by itself because we need to pass the silent parameter.
|
|
* @private
|
|
*/
|
|
destroyRoot : function(){
|
|
if(this.root && this.root.destroy){
|
|
this.root.destroy(true);
|
|
}
|
|
}
|
|
|
|
<span id='Ext-tree-TreePanel-cfg-activeItem'> /**
|
|
</span> * @cfg {String/Number} activeItem
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-cfg-autoDestroy'> /**
|
|
</span> * @cfg {Boolean} autoDestroy
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-cfg-autoLoad'> /**
|
|
</span> * @cfg {Object/String/Function} autoLoad
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-cfg-autoWidth'> /**
|
|
</span> * @cfg {Boolean} autoWidth
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-cfg-bufferResize'> /**
|
|
</span> * @cfg {Boolean/Number} bufferResize
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-cfg-defaultType'> /**
|
|
</span> * @cfg {String} defaultType
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-cfg-defaults'> /**
|
|
</span> * @cfg {Object} defaults
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-cfg-hideBorders'> /**
|
|
</span> * @cfg {Boolean} hideBorders
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-cfg-items'> /**
|
|
</span> * @cfg {Mixed} items
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-cfg-layout'> /**
|
|
</span> * @cfg {String} layout
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-cfg-layoutConfig'> /**
|
|
</span> * @cfg {Object} layoutConfig
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-cfg-monitorResize'> /**
|
|
</span> * @cfg {Boolean} monitorResize
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-property-items'> /**
|
|
</span> * @property items
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-method-cascade'> /**
|
|
</span> * @method cascade
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-method-doLayout'> /**
|
|
</span> * @method doLayout
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-method-find'> /**
|
|
</span> * @method find
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-method-findBy'> /**
|
|
</span> * @method findBy
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-method-findById'> /**
|
|
</span> * @method findById
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-method-findByType'> /**
|
|
</span> * @method findByType
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-method-getComponent'> /**
|
|
</span> * @method getComponent
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-method-getLayout'> /**
|
|
</span> * @method getLayout
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-method-getUpdater'> /**
|
|
</span> * @method getUpdater
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-method-insert'> /**
|
|
</span> * @method insert
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-method-load'> /**
|
|
</span> * @method load
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-method-remove'> /**
|
|
</span> * @method remove
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-event-add'> /**
|
|
</span> * @event add
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-method-removeAll'> /**
|
|
</span> * @method removeAll
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-event-afterLayout'> /**
|
|
</span> * @event afterLayout
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-event-beforeadd'> /**
|
|
</span> * @event beforeadd
|
|
* @hide
|
|
*/
|
|
|
|
|
|
|
|
<span id='Ext-tree-TreePanel-cfg-allowDomMove'> /**
|
|
</span> * @cfg {String} allowDomMove @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-cfg-autoEl'> /**
|
|
</span> * @cfg {String} autoEl @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-cfg-applyTo'> /**
|
|
</span> * @cfg {String} applyTo @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-cfg-contentEl'> /**
|
|
</span> * @cfg {String} contentEl @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-cfg-data'> /**
|
|
</span> * @cfg {Mixed} data @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-cfg-tpl'> /**
|
|
</span> * @cfg {Mixed} tpl @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-cfg-tplWriteMode'> /**
|
|
</span> * @cfg {String} tplWriteMode @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-cfg-disabledClass'> /**
|
|
</span> * @cfg {String} disabledClass @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-cfg-elements'> /**
|
|
</span> * @cfg {String} elements @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-cfg-html'> /**
|
|
</span> * @cfg {String} html @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-cfg-preventBodyReset'> /**
|
|
</span> * @cfg {Boolean} preventBodyReset
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-property-disabled'> /**
|
|
</span> * @property disabled
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-method-applyToMarkup'> /**
|
|
</span> * @method applyToMarkup
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-method-enable'> /**
|
|
</span> * @method enable
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-method-disable'> /**
|
|
</span> * @method disable
|
|
* @hide
|
|
*/
|
|
<span id='Ext-tree-TreePanel-method-setDisabled'> /**
|
|
</span> * @method setDisabled
|
|
* @hide
|
|
*/
|
|
});
|
|
|
|
Ext.tree.TreePanel.nodeTypes = {};
|
|
|
|
Ext.reg('treepanel', Ext.tree.TreePanel);</pre>
|
|
</body>
|
|
</html>
|