<!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-TreeNode-method-constructor'><span id='Ext-tree-TreeNode-cfg-editable'><span id='Ext-tree-TreeNode-cfg-allowChildren'><span id='Ext-tree-TreeNode-cfg-isTarget'><span id='Ext-tree-TreeNode-cfg-draggable'><span id='Ext-tree-TreeNode-cfg-checked'><span id='Ext-tree-TreeNode-cfg-uiProvider'><span id='Ext-tree-TreeNode-cfg-singleClickExpand'><span id='Ext-tree-TreeNode-cfg-qtipCfg'><span id='Ext-tree-TreeNode-cfg-expandable'><span id='Ext-tree-TreeNode-cfg-qtip'><span id='Ext-tree-TreeNode-cfg-hidden'><span id='Ext-tree-TreeNode-cfg-hrefTarget'><span id='Ext-tree-TreeNode-cfg-href'><span id='Ext-tree-TreeNode-cfg-iconCls'><span id='Ext-tree-TreeNode-cfg-cls'><span id='Ext-tree-TreeNode-cfg-icon'><span id='Ext-tree-TreeNode-cfg-disabled'><span id='Ext-tree-TreeNode-cfg-allowDrop'><span id='Ext-tree-TreeNode-cfg-allowDrag'><span id='Ext-tree-TreeNode-cfg-expanded'><span id='Ext-tree-TreeNode-cfg-text'><span id='Ext-tree-TreeNode'>/**
</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.TreeNode
* @extends Ext.data.Node
* @cfg {String} text The text for this node
* @cfg {Boolean} expanded true to start the node expanded
* @cfg {Boolean} allowDrag False to make this node undraggable if {@link #draggable} = true (defaults to true)
* @cfg {Boolean} allowDrop False if this node cannot have child nodes dropped on it (defaults to true)
* @cfg {Boolean} disabled true to start the node disabled
* @cfg {String} icon The path to an icon for the node. The preferred way to do this
* is to use the cls or iconCls attributes and add the icon via a CSS background image.
* @cfg {String} cls A css class to be added to the node
* @cfg {String} iconCls A css class to be added to the nodes icon element for applying css background images
* @cfg {String} href URL of the link used for the node (defaults to #)
* @cfg {String} hrefTarget target frame for the link
* @cfg {Boolean} hidden True to render hidden. (Defaults to false).
* @cfg {String} qtip An Ext QuickTip for the node
* @cfg {Boolean} expandable If set to true, the node will always show a plus/minus icon, even when empty
* @cfg {String} qtipCfg An Ext QuickTip config for the node (used instead of qtip)
* @cfg {Boolean} singleClickExpand True for single click expand on this node
* @cfg {Function} uiProvider A UI <b>class</b> to use for this node (defaults to Ext.tree.TreeNodeUI)
* @cfg {Boolean} checked True to render a checked checkbox for this node, false to render an unchecked checkbox
* (defaults to undefined with no checkbox rendered)
* @cfg {Boolean} draggable True to make this node draggable (defaults to false)
* @cfg {Boolean} isTarget False to not allow this node to act as a drop target (defaults to true)
* @cfg {Boolean} allowChildren False to not allow this node to have child nodes (defaults to true)
* @cfg {Boolean} editable False to not allow this node to be edited by an {@link Ext.tree.TreeEditor} (defaults to true)
* @constructor
* @param {Object/String} attributes The attributes/config for the node or just a string with the text for the node
*/
Ext.tree.TreeNode = Ext.extend(Ext.data.Node, {
constructor : function(attributes){
attributes = attributes || {};
if(Ext.isString(attributes)){
attributes = {text: attributes};
}
this.childrenRendered = false;
this.rendered = false;
Ext.tree.TreeNode.superclass.constructor.call(this, attributes);
this.expanded = attributes.expanded === true;
this.isTarget = attributes.isTarget !== false;
this.draggable = attributes.draggable !== false && attributes.allowDrag !== false;
this.allowChildren = attributes.allowChildren !== false && attributes.allowDrop !== false;
<span id='Ext-tree-TreeNode-property-text'> /**
</span> * Read-only. The text for this node. To change it use <code>{@link #setText}</code>.
* @type String
*/
this.text = attributes.text;
<span id='Ext-tree-TreeNode-property-disabled'> /**
</span> * True if this node is disabled.
* @type Boolean
*/
this.disabled = attributes.disabled === true;
<span id='Ext-tree-TreeNode-property-hidden'> /**
</span> * True if this node is hidden.
* @type Boolean
*/
this.hidden = attributes.hidden === true;
this.addEvents(
<span id='Ext-tree-TreeNode-event-textchange'> /**
</span> * @event textchange
* Fires when the text for this node is changed
* @param {Node} this This node
* @param {String} text The new text
* @param {String} oldText The old text
*/
'textchange',
<span id='Ext-tree-TreeNode-event-beforeexpand'> /**
</span> * @event beforeexpand
* Fires before this node is expanded, return false to cancel.
* @param {Node} this This node
* @param {Boolean} deep
* @param {Boolean} anim
*/
'beforeexpand',
<span id='Ext-tree-TreeNode-event-beforecollapse'> /**
</span> * @event beforecollapse
* Fires before this node is collapsed, return false to cancel.
* @param {Node} this This node
* @param {Boolean} deep
* @param {Boolean} anim
*/
'beforecollapse',
<span id='Ext-tree-TreeNode-event-expand'> /**
</span> * @event expand
* Fires when this node is expanded
* @param {Node} this This node
*/
'expand',
<span id='Ext-tree-TreeNode-event-disabledchange'> /**
</span> * @event disabledchange
* Fires when the disabled status of this node changes
* @param {Node} this This node
* @param {Boolean} disabled
*/
'disabledchange',
<span id='Ext-tree-TreeNode-event-collapse'> /**
</span> * @event collapse
* Fires when this node is collapsed
* @param {Node} this This node
*/
'collapse',
<span id='Ext-tree-TreeNode-event-beforeclick'> /**
</span> * @event beforeclick
* Fires before click processing. Return false to cancel the default action.
* @param {Node} this This node
* @param {Ext.EventObject} e The event object
*/
'beforeclick',
<span id='Ext-tree-TreeNode-event-click'> /**
</span> * @event click
* Fires when this node is clicked
* @param {Node} this This node
* @param {Ext.EventObject} e The event object
*/
'click',
<span id='Ext-tree-TreeNode-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-TreeNode-event-beforedblclick'> /**
</span> * @event beforedblclick
* Fires before double click processing. Return false to cancel the default action.
* @param {Node} this This node
* @param {Ext.EventObject} e The event object
*/
'beforedblclick',
<span id='Ext-tree-TreeNode-event-dblclick'> /**
</span> * @event dblclick
* Fires when this node is double clicked
* @param {Node} this This node
* @param {Ext.EventObject} e The event object
*/
'dblclick',
<span id='Ext-tree-TreeNode-event-contextmenu'> /**
</span> * @event contextmenu
* Fires when this node is right clicked
* @param {Node} this This node
* @param {Ext.EventObject} e The event object
*/
'contextmenu',
<span id='Ext-tree-TreeNode-event-beforechildrenrendered'> /**
</span> * @event beforechildrenrendered
* Fires right before the child nodes for this node are rendered
* @param {Node} this This node
*/
'beforechildrenrendered'
);
var uiClass = this.attributes.uiProvider || this.defaultUI || Ext.tree.TreeNodeUI;
<span id='Ext-tree-TreeNode-property-ui'> /**
</span> * Read-only. The UI for this node
* @type TreeNodeUI
*/
this.ui = new uiClass(this);
},
<span id='Ext-tree-TreeNode-property-preventHScroll'> preventHScroll : true,
</span><span id='Ext-tree-TreeNode-method-isExpanded'> /**
</span> * Returns true if this node is expanded
* @return {Boolean}
*/
isExpanded : function(){
return this.expanded;
},
<span id='Ext-tree-TreeNode-method-getUI'>/**
</span> * Returns the UI object for this node.
* @return {TreeNodeUI} The object which is providing the user interface for this tree
* node. Unless otherwise specified in the {@link #uiProvider}, this will be an instance
* of {@link Ext.tree.TreeNodeUI}
*/
getUI : function(){
return this.ui;
},
<span id='Ext-tree-TreeNode-method-getLoader'> getLoader : function(){
</span> var owner;
return this.loader || ((owner = this.getOwnerTree()) && owner.loader ? owner.loader : (this.loader = new Ext.tree.TreeLoader()));
},
<span id='Ext-tree-TreeNode-method-setFirstChild'> // private override
</span> setFirstChild : function(node){
var of = this.firstChild;
Ext.tree.TreeNode.superclass.setFirstChild.call(this, node);
if(this.childrenRendered && of && node != of){
of.renderIndent(true, true);
}
if(this.rendered){
this.renderIndent(true, true);
}
},
<span id='Ext-tree-TreeNode-method-setLastChild'> // private override
</span> setLastChild : function(node){
var ol = this.lastChild;
Ext.tree.TreeNode.superclass.setLastChild.call(this, node);
if(this.childrenRendered && ol && node != ol){
ol.renderIndent(true, true);
}
if(this.rendered){
this.renderIndent(true, true);
}
},
<span id='Ext-tree-TreeNode-method-appendChild'> // these methods are overridden to provide lazy rendering support
</span> // private override
appendChild : function(n){
if(!n.render && !Ext.isArray(n)){
n = this.getLoader().createNode(n);
}
var node = Ext.tree.TreeNode.superclass.appendChild.call(this, n);
if(node && this.childrenRendered){
node.render();
}
this.ui.updateExpandIcon();
return node;
},
<span id='Ext-tree-TreeNode-method-removeChild'> // private override
</span> removeChild : function(node, destroy){
this.ownerTree.getSelectionModel().unselect(node);
Ext.tree.TreeNode.superclass.removeChild.apply(this, arguments);
// only update the ui if we're not destroying
if(!destroy){
var rendered = node.ui.rendered;
// if it's been rendered remove dom node
if(rendered){
node.ui.remove();
}
if(rendered && this.childNodes.length < 1){
this.collapse(false, false);
}else{
this.ui.updateExpandIcon();
}
if(!this.firstChild && !this.isHiddenRoot()){
this.childrenRendered = false;
}
}
return node;
},
<span id='Ext-tree-TreeNode-method-insertBefore'> // private override
</span> insertBefore : function(node, refNode){
if(!node.render){
node = this.getLoader().createNode(node);
}
var newNode = Ext.tree.TreeNode.superclass.insertBefore.call(this, node, refNode);
if(newNode && refNode && this.childrenRendered){
node.render();
}
this.ui.updateExpandIcon();
return newNode;
},
<span id='Ext-tree-TreeNode-method-setText'> /**
</span> * Sets the text for this node
* @param {String} text
*/
setText : function(text){
var oldText = this.text;
this.text = this.attributes.text = text;
if(this.rendered){ // event without subscribing
this.ui.onTextChange(this, text, oldText);
}
this.fireEvent('textchange', this, text, oldText);
},
<span id='Ext-tree-TreeNode-method-setIconCls'> /**
</span> * Sets the icon class for this node.
* @param {String} cls
*/
setIconCls : function(cls){
var old = this.attributes.iconCls;
this.attributes.iconCls = cls;
if(this.rendered){
this.ui.onIconClsChange(this, cls, old);
}
},
<span id='Ext-tree-TreeNode-method-setTooltip'> /**
</span> * Sets the tooltip for this node.
* @param {String} tip The text for the tip
* @param {String} title (Optional) The title for the tip
*/
setTooltip : function(tip, title){
this.attributes.qtip = tip;
this.attributes.qtipTitle = title;
if(this.rendered){
this.ui.onTipChange(this, tip, title);
}
},
<span id='Ext-tree-TreeNode-method-setIcon'> /**
</span> * Sets the icon for this node.
* @param {String} icon
*/
setIcon : function(icon){
this.attributes.icon = icon;
if(this.rendered){
this.ui.onIconChange(this, icon);
}
},
<span id='Ext-tree-TreeNode-method-setHref'> /**
</span> * Sets the href for the node.
* @param {String} href The href to set
* @param {String} (Optional) target The target of the href
*/
setHref : function(href, target){
this.attributes.href = href;
this.attributes.hrefTarget = target;
if(this.rendered){
this.ui.onHrefChange(this, href, target);
}
},
<span id='Ext-tree-TreeNode-method-setCls'> /**
</span> * Sets the class on this node.
* @param {String} cls
*/
setCls : function(cls){
var old = this.attributes.cls;
this.attributes.cls = cls;
if(this.rendered){
this.ui.onClsChange(this, cls, old);
}
},
<span id='Ext-tree-TreeNode-method-select'> /**
</span> * Triggers selection of this node
*/
select : function(){
var t = this.getOwnerTree();
if(t){
t.getSelectionModel().select(this);
}
},
<span id='Ext-tree-TreeNode-method-unselect'> /**
</span> * Triggers deselection of this node
* @param {Boolean} silent (optional) True to stop selection change events from firing.
*/
unselect : function(silent){
var t = this.getOwnerTree();
if(t){
t.getSelectionModel().unselect(this, silent);
}
},
<span id='Ext-tree-TreeNode-method-isSelected'> /**
</span> * Returns true if this node is selected
* @return {Boolean}
*/
isSelected : function(){
var t = this.getOwnerTree();
return t ? t.getSelectionModel().isSelected(this) : false;
},
<span id='Ext-tree-TreeNode-method-expand'> /**
</span> * Expand this node.
* @param {Boolean} deep (optional) True to expand all children as well
* @param {Boolean} anim (optional) false to cancel the default animation
* @param {Function} callback (optional) A callback to be called when
* expanding this node completes (does not wait for deep expand to complete).
* Called with 1 parameter, this node.
* @param {Object} scope (optional) The scope (<code>this</code> reference) in which the callback is executed. Defaults to this TreeNode.
*/
expand : function(deep, anim, callback, scope){
if(!this.expanded){
if(this.fireEvent('beforeexpand', this, deep, anim) === false){
return;
}
if(!this.childrenRendered){
this.renderChildren();
}
this.expanded = true;
if(!this.isHiddenRoot() && (this.getOwnerTree().animate && anim !== false) || anim){
this.ui.animExpand(function(){
this.fireEvent('expand', this);
this.runCallback(callback, scope || this, [this]);
if(deep === true){
this.expandChildNodes(true, true);
}
}.createDelegate(this));
return;
}else{
this.ui.expand();
this.fireEvent('expand', this);
this.runCallback(callback, scope || this, [this]);
}
}else{
this.runCallback(callback, scope || this, [this]);
}
if(deep === true){
this.expandChildNodes(true);
}
},
<span id='Ext-tree-TreeNode-method-runCallback'> runCallback : function(cb, scope, args){
</span> if(Ext.isFunction(cb)){
cb.apply(scope, args);
}
},
<span id='Ext-tree-TreeNode-method-isHiddenRoot'> isHiddenRoot : function(){
</span> return this.isRoot && !this.getOwnerTree().rootVisible;
},
<span id='Ext-tree-TreeNode-method-collapse'> /**
</span> * Collapse this node.
* @param {Boolean} deep (optional) True to collapse all children as well
* @param {Boolean} anim (optional) false to cancel the default animation
* @param {Function} callback (optional) A callback to be called when
* expanding this node completes (does not wait for deep expand to complete).
* Called with 1 parameter, this node.
* @param {Object} scope (optional) The scope (<code>this</code> reference) in which the callback is executed. Defaults to this TreeNode.
*/
collapse : function(deep, anim, callback, scope){
if(this.expanded && !this.isHiddenRoot()){
if(this.fireEvent('beforecollapse', this, deep, anim) === false){
return;
}
this.expanded = false;
if((this.getOwnerTree().animate && anim !== false) || anim){
this.ui.animCollapse(function(){
this.fireEvent('collapse', this);
this.runCallback(callback, scope || this, [this]);
if(deep === true){
this.collapseChildNodes(true);
}
}.createDelegate(this));
return;
}else{
this.ui.collapse();
this.fireEvent('collapse', this);
this.runCallback(callback, scope || this, [this]);
}
}else if(!this.expanded){
this.runCallback(callback, scope || this, [this]);
}
if(deep === true){
var cs = this.childNodes;
for(var i = 0, len = cs.length; i < len; i++) {
cs[i].collapse(true, false);
}
}
},
<span id='Ext-tree-TreeNode-method-delayedExpand'> // private
</span> delayedExpand : function(delay){
if(!this.expandProcId){
this.expandProcId = this.expand.defer(delay, this);
}
},
<span id='Ext-tree-TreeNode-method-cancelExpand'> // private
</span> cancelExpand : function(){
if(this.expandProcId){
clearTimeout(this.expandProcId);
}
this.expandProcId = false;
},
<span id='Ext-tree-TreeNode-method-toggle'> /**
</span> * Toggles expanded/collapsed state of the node
*/
toggle : function(){
if(this.expanded){
this.collapse();
}else{
this.expand();
}
},
<span id='Ext-tree-TreeNode-method-ensureVisible'> /**
</span> * Ensures all parent nodes are expanded, and if necessary, scrolls
* the node into view.
* @param {Function} callback (optional) A function to call when the node has been made visible.
* @param {Object} scope (optional) The scope (<code>this</code> reference) in which the callback is executed. Defaults to this TreeNode.
*/
ensureVisible : function(callback, scope){
var tree = this.getOwnerTree();
tree.expandPath(this.parentNode ? this.parentNode.getPath() : this.getPath(), false, function(){
var node = tree.getNodeById(this.id); // Somehow if we don't do this, we lose changes that happened to node in the meantime
tree.getTreeEl().scrollChildIntoView(node.ui.anchor);
this.runCallback(callback, scope || this, [this]);
}.createDelegate(this));
},
<span id='Ext-tree-TreeNode-method-expandChildNodes'> /**
</span> * Expand all child nodes
* @param {Boolean} deep (optional) true if the child nodes should also expand their child nodes
*/
expandChildNodes : function(deep, anim) {
var cs = this.childNodes,
i,
len = cs.length;
for (i = 0; i < len; i++) {
cs[i].expand(deep, anim);
}
},
<span id='Ext-tree-TreeNode-method-collapseChildNodes'> /**
</span> * Collapse all child nodes
* @param {Boolean} deep (optional) true if the child nodes should also collapse their child nodes
*/
collapseChildNodes : function(deep){
var cs = this.childNodes;
for(var i = 0, len = cs.length; i < len; i++) {
cs[i].collapse(deep);
}
},
<span id='Ext-tree-TreeNode-method-disable'> /**
</span> * Disables this node
*/
disable : function(){
this.disabled = true;
this.unselect();
if(this.rendered && this.ui.onDisableChange){ // event without subscribing
this.ui.onDisableChange(this, true);
}
this.fireEvent('disabledchange', this, true);
},
<span id='Ext-tree-TreeNode-method-enable'> /**
</span> * Enables this node
*/
enable : function(){
this.disabled = false;
if(this.rendered && this.ui.onDisableChange){ // event without subscribing
this.ui.onDisableChange(this, false);
}
this.fireEvent('disabledchange', this, false);
},
<span id='Ext-tree-TreeNode-method-renderChildren'> // private
</span> renderChildren : function(suppressEvent){
if(suppressEvent !== false){
this.fireEvent('beforechildrenrendered', this);
}
var cs = this.childNodes;
for(var i = 0, len = cs.length; i < len; i++){
cs[i].render(true);
}
this.childrenRendered = true;
},
<span id='Ext-tree-TreeNode-method-sort'> // private
</span> sort : function(fn, scope){
Ext.tree.TreeNode.superclass.sort.apply(this, arguments);
if(this.childrenRendered){
var cs = this.childNodes;
for(var i = 0, len = cs.length; i < len; i++){
cs[i].render(true);
}
}
},
<span id='Ext-tree-TreeNode-method-render'> // private
</span> render : function(bulkRender){
this.ui.render(bulkRender);
if(!this.rendered){
// make sure it is registered
this.getOwnerTree().registerNode(this);
this.rendered = true;
if(this.expanded){
this.expanded = false;
this.expand(false, false);
}
}
},
<span id='Ext-tree-TreeNode-method-renderIndent'> // private
</span> renderIndent : function(deep, refresh){
if(refresh){
this.ui.childIndent = null;
}
this.ui.renderIndent();
if(deep === true && this.childrenRendered){
var cs = this.childNodes;
for(var i = 0, len = cs.length; i < len; i++){
cs[i].renderIndent(true, refresh);
}
}
},
<span id='Ext-tree-TreeNode-method-beginUpdate'> beginUpdate : function(){
</span> this.childrenRendered = false;
},
<span id='Ext-tree-TreeNode-method-endUpdate'> endUpdate : function(){
</span> if(this.expanded && this.rendered){
this.renderChildren();
}
},
<span id='Ext-tree-TreeNode-method-destroy'> //inherit docs
</span> destroy : function(silent){
if(silent === true){
this.unselect(true);
}
Ext.tree.TreeNode.superclass.destroy.call(this, silent);
Ext.destroy(this.ui, this.loader);
this.ui = this.loader = null;
},
<span id='Ext-tree-TreeNode-method-onIdChange'> // private
</span> onIdChange : function(id){
this.ui.onIdChange(id);
}
});
Ext.tree.TreePanel.nodeTypes.node = Ext.tree.TreeNode;</pre>
</body>
</html>