689 lines
24 KiB
HTML
689 lines
24 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-TreeNodeUI'>/**
|
|
</span> * @class Ext.tree.TreeNodeUI
|
|
* This class provides the default UI implementation for Ext TreeNodes.
|
|
* The TreeNode UI implementation is separate from the
|
|
* tree implementation, and allows customizing of the appearance of
|
|
* tree nodes.<br>
|
|
* <p>
|
|
* If you are customizing the Tree's user interface, you
|
|
* may need to extend this class, but you should never need to instantiate this class.<br>
|
|
* <p>
|
|
* This class provides access to the user interface components of an Ext TreeNode, through
|
|
* {@link Ext.tree.TreeNode#getUI}
|
|
*/
|
|
Ext.tree.TreeNodeUI = Ext.extend(Object, {
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-constructor'> constructor : function(node){
|
|
</span> Ext.apply(this, {
|
|
node: node,
|
|
rendered: false,
|
|
animating: false,
|
|
wasLeaf: true,
|
|
ecc: 'x-tree-ec-icon x-tree-elbow',
|
|
emptyIcon: Ext.BLANK_IMAGE_URL
|
|
});
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-removeChild'> // private
|
|
</span> removeChild : function(node){
|
|
if(this.rendered){
|
|
this.ctNode.removeChild(node.ui.getEl());
|
|
}
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-beforeLoad'> // private
|
|
</span> beforeLoad : function(){
|
|
this.addClass("x-tree-node-loading");
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-afterLoad'> // private
|
|
</span> afterLoad : function(){
|
|
this.removeClass("x-tree-node-loading");
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-onTextChange'> // private
|
|
</span> onTextChange : function(node, text, oldText){
|
|
if(this.rendered){
|
|
this.textNode.innerHTML = text;
|
|
}
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-onIconClsChange'> // private
|
|
</span> onIconClsChange : function(node, cls, oldCls){
|
|
if(this.rendered){
|
|
Ext.fly(this.iconNode).replaceClass(oldCls, cls);
|
|
}
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-onIconChange'> // private
|
|
</span> onIconChange : function(node, icon){
|
|
if(this.rendered){
|
|
//'<img src="', a.icon || this.emptyIcon, '" class="x-tree-node-icon',(a.icon ? " x-tree-node-inline-icon" : ""),(a.iconCls ? " "+a.iconCls : ""),'" unselectable="on" />',
|
|
var empty = Ext.isEmpty(icon);
|
|
this.iconNode.src = empty ? this.emptyIcon : icon;
|
|
Ext.fly(this.iconNode)[empty ? 'removeClass' : 'addClass']('x-tree-node-inline-icon');
|
|
}
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-onTipChange'> // private
|
|
</span> onTipChange : function(node, tip, title){
|
|
if(this.rendered){
|
|
var hasTitle = Ext.isDefined(title);
|
|
if(this.textNode.setAttributeNS){
|
|
this.textNode.setAttributeNS("ext", "qtip", tip);
|
|
if(hasTitle){
|
|
this.textNode.setAttributeNS("ext", "qtitle", title);
|
|
}
|
|
}else{
|
|
this.textNode.setAttribute("ext:qtip", tip);
|
|
if(hasTitle){
|
|
this.textNode.setAttribute("ext:qtitle", title);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-onHrefChange'> // private
|
|
</span> onHrefChange : function(node, href, target){
|
|
if(this.rendered){
|
|
this.anchor.href = this.getHref(href);
|
|
if(Ext.isDefined(target)){
|
|
this.anchor.target = target;
|
|
}
|
|
}
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-onClsChange'> // private
|
|
</span> onClsChange : function(node, cls, oldCls){
|
|
if(this.rendered){
|
|
Ext.fly(this.elNode).replaceClass(oldCls, cls);
|
|
}
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-onDisableChange'> // private
|
|
</span> onDisableChange : function(node, state){
|
|
this.disabled = state;
|
|
if (this.checkbox) {
|
|
this.checkbox.disabled = state;
|
|
}
|
|
this[state ? 'addClass' : 'removeClass']('x-tree-node-disabled');
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-onSelectedChange'> // private
|
|
</span> onSelectedChange : function(state){
|
|
if(state){
|
|
this.focus();
|
|
this.addClass("x-tree-selected");
|
|
}else{
|
|
//this.blur();
|
|
this.removeClass("x-tree-selected");
|
|
}
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-onMove'> // private
|
|
</span> onMove : function(tree, node, oldParent, newParent, index, refNode){
|
|
this.childIndent = null;
|
|
if(this.rendered){
|
|
var targetNode = newParent.ui.getContainer();
|
|
if(!targetNode){//target not rendered
|
|
this.holder = document.createElement("div");
|
|
this.holder.appendChild(this.wrap);
|
|
return;
|
|
}
|
|
var insertBefore = refNode ? refNode.ui.getEl() : null;
|
|
if(insertBefore){
|
|
targetNode.insertBefore(this.wrap, insertBefore);
|
|
}else{
|
|
targetNode.appendChild(this.wrap);
|
|
}
|
|
this.node.renderIndent(true, oldParent != newParent);
|
|
}
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-addClass'>/**
|
|
</span> * Adds one or more CSS classes to the node's UI element.
|
|
* Duplicate classes are automatically filtered out.
|
|
* @param {String/Array} className The CSS class to add, or an array of classes
|
|
*/
|
|
addClass : function(cls){
|
|
if(this.elNode){
|
|
Ext.fly(this.elNode).addClass(cls);
|
|
}
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-removeClass'>/**
|
|
</span> * Removes one or more CSS classes from the node's UI element.
|
|
* @param {String/Array} className The CSS class to remove, or an array of classes
|
|
*/
|
|
removeClass : function(cls){
|
|
if(this.elNode){
|
|
Ext.fly(this.elNode).removeClass(cls);
|
|
}
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-remove'> // private
|
|
</span> remove : function(){
|
|
if(this.rendered){
|
|
this.holder = document.createElement("div");
|
|
this.holder.appendChild(this.wrap);
|
|
}
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-fireEvent'> // private
|
|
</span> fireEvent : function(){
|
|
return this.node.fireEvent.apply(this.node, arguments);
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-initEvents'> // private
|
|
</span> initEvents : function(){
|
|
this.node.on("move", this.onMove, this);
|
|
|
|
if(this.node.disabled){
|
|
this.onDisableChange(this.node, true);
|
|
}
|
|
if(this.node.hidden){
|
|
this.hide();
|
|
}
|
|
var ot = this.node.getOwnerTree();
|
|
var dd = ot.enableDD || ot.enableDrag || ot.enableDrop;
|
|
if(dd && (!this.node.isRoot || ot.rootVisible)){
|
|
Ext.dd.Registry.register(this.elNode, {
|
|
node: this.node,
|
|
handles: this.getDDHandles(),
|
|
isHandle: false
|
|
});
|
|
}
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-getDDHandles'> // private
|
|
</span> getDDHandles : function(){
|
|
return [this.iconNode, this.textNode, this.elNode];
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-hide'>/**
|
|
</span> * Hides this node.
|
|
*/
|
|
hide : function(){
|
|
this.node.hidden = true;
|
|
if(this.wrap){
|
|
this.wrap.style.display = "none";
|
|
}
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-show'>/**
|
|
</span> * Shows this node.
|
|
*/
|
|
show : function(){
|
|
this.node.hidden = false;
|
|
if(this.wrap){
|
|
this.wrap.style.display = "";
|
|
}
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-onContextMenu'> // private
|
|
</span> onContextMenu : function(e){
|
|
if (this.node.hasListener("contextmenu") || this.node.getOwnerTree().hasListener("contextmenu")) {
|
|
e.preventDefault();
|
|
this.focus();
|
|
this.fireEvent("contextmenu", this.node, e);
|
|
}
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-onClick'> // private
|
|
</span> onClick : function(e){
|
|
if(this.dropping){
|
|
e.stopEvent();
|
|
return;
|
|
}
|
|
if(this.fireEvent("beforeclick", this.node, e) !== false){
|
|
var a = e.getTarget('a');
|
|
if(!this.disabled && this.node.attributes.href && a){
|
|
this.fireEvent("click", this.node, e);
|
|
return;
|
|
}else if(a && e.ctrlKey){
|
|
e.stopEvent();
|
|
}
|
|
e.preventDefault();
|
|
if(this.disabled){
|
|
return;
|
|
}
|
|
|
|
if(this.node.attributes.singleClickExpand && !this.animating && this.node.isExpandable()){
|
|
this.node.toggle();
|
|
}
|
|
|
|
this.fireEvent("click", this.node, e);
|
|
}else{
|
|
e.stopEvent();
|
|
}
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-onDblClick'> // private
|
|
</span> onDblClick : function(e){
|
|
e.preventDefault();
|
|
if(this.disabled){
|
|
return;
|
|
}
|
|
if(this.fireEvent("beforedblclick", this.node, e) !== false){
|
|
if(this.checkbox){
|
|
this.toggleCheck();
|
|
}
|
|
if(!this.animating && this.node.isExpandable()){
|
|
this.node.toggle();
|
|
}
|
|
this.fireEvent("dblclick", this.node, e);
|
|
}
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-onOver'> onOver : function(e){
|
|
</span> this.addClass('x-tree-node-over');
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-onOut'> onOut : function(e){
|
|
</span> this.removeClass('x-tree-node-over');
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-onCheckChange'> // private
|
|
</span> onCheckChange : function(){
|
|
var checked = this.checkbox.checked;
|
|
// fix for IE6
|
|
this.checkbox.defaultChecked = checked;
|
|
this.node.attributes.checked = checked;
|
|
this.fireEvent('checkchange', this.node, checked);
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-ecClick'> // private
|
|
</span> ecClick : function(e){
|
|
if(!this.animating && this.node.isExpandable()){
|
|
this.node.toggle();
|
|
}
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-startDrop'> // private
|
|
</span> startDrop : function(){
|
|
this.dropping = true;
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-endDrop'> // delayed drop so the click event doesn't get fired on a drop
|
|
</span> endDrop : function(){
|
|
setTimeout(function(){
|
|
this.dropping = false;
|
|
}.createDelegate(this), 50);
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-expand'> // private
|
|
</span> expand : function(){
|
|
this.updateExpandIcon();
|
|
this.ctNode.style.display = "";
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-focus'> // private
|
|
</span> focus : function(){
|
|
if(!this.node.preventHScroll){
|
|
try{this.anchor.focus();
|
|
}catch(e){}
|
|
}else{
|
|
try{
|
|
var noscroll = this.node.getOwnerTree().getTreeEl().dom;
|
|
var l = noscroll.scrollLeft;
|
|
this.anchor.focus();
|
|
noscroll.scrollLeft = l;
|
|
}catch(e){}
|
|
}
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-toggleCheck'>/**
|
|
</span> * Sets the checked status of the tree node to the passed value, or, if no value was passed,
|
|
* toggles the checked status. If the node was rendered with no checkbox, this has no effect.
|
|
* @param {Boolean} value (optional) The new checked status.
|
|
*/
|
|
toggleCheck : function(value){
|
|
var cb = this.checkbox;
|
|
if(cb){
|
|
cb.checked = (value === undefined ? !cb.checked : value);
|
|
this.onCheckChange();
|
|
}
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-blur'> // private
|
|
</span> blur : function(){
|
|
try{
|
|
this.anchor.blur();
|
|
}catch(e){}
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-animExpand'> // private
|
|
</span> animExpand : function(callback){
|
|
var ct = Ext.get(this.ctNode);
|
|
ct.stopFx();
|
|
if(!this.node.isExpandable()){
|
|
this.updateExpandIcon();
|
|
this.ctNode.style.display = "";
|
|
Ext.callback(callback);
|
|
return;
|
|
}
|
|
this.animating = true;
|
|
this.updateExpandIcon();
|
|
|
|
ct.slideIn('t', {
|
|
callback : function(){
|
|
this.animating = false;
|
|
Ext.callback(callback);
|
|
},
|
|
scope: this,
|
|
duration: this.node.ownerTree.duration || .25
|
|
});
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-highlight'> // private
|
|
</span> highlight : function(){
|
|
var tree = this.node.getOwnerTree();
|
|
Ext.fly(this.wrap).highlight(
|
|
tree.hlColor || "C3DAF9",
|
|
{endColor: tree.hlBaseColor}
|
|
);
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-collapse'> // private
|
|
</span> collapse : function(){
|
|
this.updateExpandIcon();
|
|
this.ctNode.style.display = "none";
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-animCollapse'> // private
|
|
</span> animCollapse : function(callback){
|
|
var ct = Ext.get(this.ctNode);
|
|
ct.enableDisplayMode('block');
|
|
ct.stopFx();
|
|
|
|
this.animating = true;
|
|
this.updateExpandIcon();
|
|
|
|
ct.slideOut('t', {
|
|
callback : function(){
|
|
this.animating = false;
|
|
Ext.callback(callback);
|
|
},
|
|
scope: this,
|
|
duration: this.node.ownerTree.duration || .25
|
|
});
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-getContainer'> // private
|
|
</span> getContainer : function(){
|
|
return this.ctNode;
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-getEl'>/**
|
|
</span> * Returns the element which encapsulates this node.
|
|
* @return {HtmlElement} The DOM element. The default implementation uses a <code>&lt;li></code>.
|
|
*/
|
|
getEl : function(){
|
|
return this.wrap;
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-appendDDGhost'> // private
|
|
</span> appendDDGhost : function(ghostNode){
|
|
ghostNode.appendChild(this.elNode.cloneNode(true));
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-getDDRepairXY'> // private
|
|
</span> getDDRepairXY : function(){
|
|
return Ext.lib.Dom.getXY(this.iconNode);
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-onRender'> // private
|
|
</span> onRender : function(){
|
|
this.render();
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-render'> // private
|
|
</span> render : function(bulkRender){
|
|
var n = this.node, a = n.attributes;
|
|
var targetNode = n.parentNode ?
|
|
n.parentNode.ui.getContainer() : n.ownerTree.innerCt.dom;
|
|
|
|
if(!this.rendered){
|
|
this.rendered = true;
|
|
|
|
this.renderElements(n, a, targetNode, bulkRender);
|
|
|
|
if(a.qtip){
|
|
this.onTipChange(n, a.qtip, a.qtipTitle);
|
|
}else if(a.qtipCfg){
|
|
a.qtipCfg.target = Ext.id(this.textNode);
|
|
Ext.QuickTips.register(a.qtipCfg);
|
|
}
|
|
this.initEvents();
|
|
if(!this.node.expanded){
|
|
this.updateExpandIcon(true);
|
|
}
|
|
}else{
|
|
if(bulkRender === true) {
|
|
targetNode.appendChild(this.wrap);
|
|
}
|
|
}
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-renderElements'> // private
|
|
</span> renderElements : function(n, a, targetNode, bulkRender){
|
|
// add some indent caching, this helps performance when rendering a large tree
|
|
this.indentMarkup = n.parentNode ? n.parentNode.ui.getChildIndent() : '';
|
|
|
|
var cb = Ext.isBoolean(a.checked),
|
|
nel,
|
|
href = this.getHref(a.href),
|
|
buf = ['<li class="x-tree-node"><div ext:tree-node-id="',n.id,'" class="x-tree-node-el x-tree-node-leaf x-unselectable ', a.cls,'" unselectable="on">',
|
|
'<span class="x-tree-node-indent">',this.indentMarkup,"</span>",
|
|
'<img alt="" src="', this.emptyIcon, '" class="x-tree-ec-icon x-tree-elbow" />',
|
|
'<img alt="" src="', a.icon || this.emptyIcon, '" class="x-tree-node-icon',(a.icon ? " x-tree-node-inline-icon" : ""),(a.iconCls ? " "+a.iconCls : ""),'" unselectable="on" />',
|
|
cb ? ('<input class="x-tree-node-cb" type="checkbox" ' + (a.checked ? 'checked="checked" />' : '/>')) : '',
|
|
'<a hidefocus="on" class="x-tree-node-anchor" href="',href,'" tabIndex="1" ',
|
|
a.hrefTarget ? ' target="'+a.hrefTarget+'"' : "", '><span unselectable="on">',n.text,"</span></a></div>",
|
|
'<ul class="x-tree-node-ct" style="display:none;"></ul>',
|
|
"</li>"].join('');
|
|
|
|
if(bulkRender !== true && n.nextSibling && (nel = n.nextSibling.ui.getEl())){
|
|
this.wrap = Ext.DomHelper.insertHtml("beforeBegin", nel, buf);
|
|
}else{
|
|
this.wrap = Ext.DomHelper.insertHtml("beforeEnd", targetNode, buf);
|
|
}
|
|
|
|
this.elNode = this.wrap.childNodes[0];
|
|
this.ctNode = this.wrap.childNodes[1];
|
|
var cs = this.elNode.childNodes;
|
|
this.indentNode = cs[0];
|
|
this.ecNode = cs[1];
|
|
this.iconNode = cs[2];
|
|
var index = 3;
|
|
if(cb){
|
|
this.checkbox = cs[3];
|
|
// fix for IE6
|
|
this.checkbox.defaultChecked = this.checkbox.checked;
|
|
index++;
|
|
}
|
|
this.anchor = cs[index];
|
|
this.textNode = cs[index].firstChild;
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-getHref'> /**
|
|
</span> * @private Gets a normalized href for the node.
|
|
* @param {String} href
|
|
*/
|
|
getHref : function(href){
|
|
return Ext.isEmpty(href) ? (Ext.isGecko ? '' : '#') : href;
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-getAnchor'>/**
|
|
</span> * Returns the &lt;a> element that provides focus for the node's UI.
|
|
* @return {HtmlElement} The DOM anchor element.
|
|
*/
|
|
getAnchor : function(){
|
|
return this.anchor;
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-getTextEl'>/**
|
|
</span> * Returns the text node.
|
|
* @return {HtmlNode} The DOM text node.
|
|
*/
|
|
getTextEl : function(){
|
|
return this.textNode;
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-getIconEl'>/**
|
|
</span> * Returns the icon &lt;img> element.
|
|
* @return {HtmlElement} The DOM image element.
|
|
*/
|
|
getIconEl : function(){
|
|
return this.iconNode;
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-isChecked'>/**
|
|
</span> * Returns the checked status of the node. If the node was rendered with no
|
|
* checkbox, it returns false.
|
|
* @return {Boolean} The checked flag.
|
|
*/
|
|
isChecked : function(){
|
|
return this.checkbox ? this.checkbox.checked : false;
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-updateExpandIcon'> // private
|
|
</span> updateExpandIcon : function(){
|
|
if(this.rendered){
|
|
var n = this.node,
|
|
c1,
|
|
c2,
|
|
cls = n.isLast() ? "x-tree-elbow-end" : "x-tree-elbow",
|
|
hasChild = n.hasChildNodes();
|
|
if(hasChild || n.attributes.expandable){
|
|
if(n.expanded){
|
|
cls += "-minus";
|
|
c1 = "x-tree-node-collapsed";
|
|
c2 = "x-tree-node-expanded";
|
|
}else{
|
|
cls += "-plus";
|
|
c1 = "x-tree-node-expanded";
|
|
c2 = "x-tree-node-collapsed";
|
|
}
|
|
if(this.wasLeaf){
|
|
this.removeClass("x-tree-node-leaf");
|
|
this.wasLeaf = false;
|
|
}
|
|
if(this.c1 != c1 || this.c2 != c2){
|
|
Ext.fly(this.elNode).replaceClass(c1, c2);
|
|
this.c1 = c1; this.c2 = c2;
|
|
}
|
|
}else{
|
|
if(!this.wasLeaf){
|
|
Ext.fly(this.elNode).replaceClass("x-tree-node-expanded", "x-tree-node-collapsed");
|
|
delete this.c1;
|
|
delete this.c2;
|
|
this.wasLeaf = true;
|
|
}
|
|
}
|
|
var ecc = "x-tree-ec-icon "+cls;
|
|
if(this.ecc != ecc){
|
|
this.ecNode.className = ecc;
|
|
this.ecc = ecc;
|
|
}
|
|
}
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-onIdChange'> // private
|
|
</span> onIdChange: function(id){
|
|
if(this.rendered){
|
|
this.elNode.setAttribute('ext:tree-node-id', id);
|
|
}
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-getChildIndent'> // private
|
|
</span> getChildIndent : function(){
|
|
if(!this.childIndent){
|
|
var buf = [],
|
|
p = this.node;
|
|
while(p){
|
|
if(!p.isRoot || (p.isRoot && p.ownerTree.rootVisible)){
|
|
if(!p.isLast()) {
|
|
buf.unshift('<img alt="" src="'+this.emptyIcon+'" class="x-tree-elbow-line" />');
|
|
} else {
|
|
buf.unshift('<img alt="" src="'+this.emptyIcon+'" class="x-tree-icon" />');
|
|
}
|
|
}
|
|
p = p.parentNode;
|
|
}
|
|
this.childIndent = buf.join("");
|
|
}
|
|
return this.childIndent;
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-renderIndent'> // private
|
|
</span> renderIndent : function(){
|
|
if(this.rendered){
|
|
var indent = "",
|
|
p = this.node.parentNode;
|
|
if(p){
|
|
indent = p.ui.getChildIndent();
|
|
}
|
|
if(this.indentMarkup != indent){ // don't rerender if not required
|
|
this.indentNode.innerHTML = indent;
|
|
this.indentMarkup = indent;
|
|
}
|
|
this.updateExpandIcon();
|
|
}
|
|
},
|
|
|
|
<span id='Ext-tree-TreeNodeUI-method-destroy'> destroy : function(){
|
|
</span> if(this.elNode){
|
|
Ext.dd.Registry.unregister(this.elNode.id);
|
|
}
|
|
|
|
Ext.each(['textnode', 'anchor', 'checkbox', 'indentNode', 'ecNode', 'iconNode', 'elNode', 'ctNode', 'wrap', 'holder'], function(el){
|
|
if(this[el]){
|
|
Ext.fly(this[el]).remove();
|
|
delete this[el];
|
|
}
|
|
}, this);
|
|
delete this.node;
|
|
}
|
|
});
|
|
|
|
<span id='Ext-tree-RootTreeNodeUI'>/**
|
|
</span> * @class Ext.tree.RootTreeNodeUI
|
|
* This class provides the default UI implementation for <b>root</b> Ext TreeNodes.
|
|
* The RootTreeNode UI implementation allows customizing the appearance of the root tree node.<br>
|
|
* <p>
|
|
* If you are customizing the Tree's user interface, you
|
|
* may need to extend this class, but you should never need to instantiate this class.<br>
|
|
*/
|
|
Ext.tree.RootTreeNodeUI = Ext.extend(Ext.tree.TreeNodeUI, {
|
|
<span id='Ext-tree-RootTreeNodeUI-method-render'> // private
|
|
</span> render : function(){
|
|
if(!this.rendered){
|
|
var targetNode = this.node.ownerTree.innerCt.dom;
|
|
this.node.expanded = true;
|
|
targetNode.innerHTML = '<div class="x-tree-root-node"></div>';
|
|
this.wrap = this.ctNode = targetNode.firstChild;
|
|
}
|
|
},
|
|
<span id='Ext-tree-RootTreeNodeUI-method-collapse'> collapse : Ext.emptyFn,
|
|
</span><span id='Ext-tree-RootTreeNodeUI-method-expand'> expand : Ext.emptyFn
|
|
</span>});</pre>
|
|
</body>
|
|
</html>
|