/* Copyright (c) 2007, Yahoo! Inc. All rights reserved. Code licensed under the BSD License: http://developer.yahoo.net/yui/license.txt version: 2.2.2 */ /** * The treeview widget is a generic tree building tool. * @module treeview * @title TreeView Widget * @requires yahoo, event * @optional animation * @namespace YAHOO.widget */ /** * Contains the tree view state data and the root node. * * @class TreeView * @uses YAHOO.util.EventProvider * @constructor * @param {string|HTMLElement} id The id of the element, or the element * itself that the tree will be inserted into. */ YAHOO.widget.TreeView = function(id) { if (id) { this.init(id); } }; YAHOO.widget.TreeView.prototype = { /** * The id of tree container element * @property id * @type String */ id: null, /** * The host element for this tree * @property _el * @private */ _el: null, /** * Flat collection of all nodes in this tree. This is a sparse * array, so the length property can't be relied upon for a * node count for the tree. * @property _nodes * @type Node[] * @private */ _nodes: null, /** * We lock the tree control while waiting for the dynamic loader to return * @property locked * @type boolean */ locked: false, /** * The animation to use for expanding children, if any * @property _expandAnim * @type string * @private */ _expandAnim: null, /** * The animation to use for collapsing children, if any * @property _collapseAnim * @type string * @private */ _collapseAnim: null, /** * The current number of animations that are executing * @property _animCount * @type int * @private */ _animCount: 0, /** * The maximum number of animations to run at one time. * @property maxAnim * @type int */ maxAnim: 2, /** * Sets up the animation for expanding children * @method setExpandAnim * @param {string} type the type of animation (acceptable values defined * in YAHOO.widget.TVAnim) */ setExpandAnim: function(type) { if (YAHOO.widget.TVAnim.isValid(type)) { this._expandAnim = type; } }, /** * Sets up the animation for collapsing children * @method setCollapseAnim * @param {string} the type of animation (acceptable values defined in * YAHOO.widget.TVAnim) */ setCollapseAnim: function(type) { if (YAHOO.widget.TVAnim.isValid(type)) { this._collapseAnim = type; } }, /** * Perform the expand animation if configured, or just show the * element if not configured or too many animations are in progress * @method animateExpand * @param el {HTMLElement} the element to animate * @param node {YAHOO.util.Node} the node that was expanded * @return {boolean} true if animation could be invoked, false otherwise */ animateExpand: function(el, node) { if (this._expandAnim && this._animCount < this.maxAnim) { // this.locked = true; var tree = this; var a = YAHOO.widget.TVAnim.getAnim(this._expandAnim, el, function() { tree.expandComplete(node); }); if (a) { ++this._animCount; this.fireEvent("animStart", { "node": node, "type": "expand" }); a.animate(); } return true; } return false; }, /** * Perform the collapse animation if configured, or just show the * element if not configured or too many animations are in progress * @method animateCollapse * @param el {HTMLElement} the element to animate * @param node {YAHOO.util.Node} the node that was expanded * @return {boolean} true if animation could be invoked, false otherwise */ animateCollapse: function(el, node) { if (this._collapseAnim && this._animCount < this.maxAnim) { // this.locked = true; var tree = this; var a = YAHOO.widget.TVAnim.getAnim(this._collapseAnim, el, function() { tree.collapseComplete(node); }); if (a) { ++this._animCount; this.fireEvent("animStart", { "node": node, "type": "collapse" }); a.animate(); } return true; } return false; }, /** * Function executed when the expand animation completes * @method expandComplete */ expandComplete: function(node) { --this._animCount; this.fireEvent("animComplete", { "node": node, "type": "expand" }); // this.locked = false; }, /** * Function executed when the collapse animation completes * @method collapseComplete */ collapseComplete: function(node) { --this._animCount; this.fireEvent("animComplete", { "node": node, "type": "collapse" }); // this.locked = false; }, /** * Initializes the tree * @method init * @parm {string|HTMLElement} id the id of the element that will hold the tree * @private */ init: function(id) { this.id = id; if ("string" !== typeof id) { this._el = id; this.id = this.generateId(id); } /** * When animation is enabled, this event fires when the animation * starts * @event animStart * @type CustomEvent * @param {YAHOO.widget.Node} node the node that is expanding/collapsing * @parm {String} type the type of animation ("expand" or "collapse") */ this.createEvent("animStart", this); /** * When animation is enabled, this event fires when the animation * completes * @event animComplete * @type CustomEvent * @param {YAHOO.widget.Node} node the node that is expanding/collapsing * @parm {String} type the type of animation ("expand" or "collapse") */ this.createEvent("animComplete", this); /** * Fires when a node is going to be collapsed. Return false to stop * the collapse. * @event collapse * @type CustomEvent * @param {YAHOO.widget.Node} node the node that is collapsing */ this.createEvent("collapse", this); /** * Fires after a node is successfully collapsed. This event will not fire * if the "collapse" event was cancelled. * @event collapseComplete * @type CustomEvent * @param {YAHOO.widget.Node} node the node that was collapsed */ this.createEvent("collapseComplete", this); /** * Fires when a node is going to be expanded. Return false to stop * the collapse. * @event expand * @type CustomEvent * @param {YAHOO.widget.Node} node the node that is expanding */ this.createEvent("expand", this); /** * Fires after a node is successfully expanded. This event will not fire * if the "expand" event was cancelled. * @event expandComplete * @type CustomEvent * @param {YAHOO.widget.Node} node the node that was expanded */ this.createEvent("expandComplete", this); this._nodes = []; // store a global reference YAHOO.widget.TreeView.trees[this.id] = this; // Set up the root node this.root = new YAHOO.widget.RootNode(this); //YAHOO.util.Event.onContentReady(this.id, this.handleAvailable, this, true); YAHOO.util.Event.on(this.id, "click", this.handleClick, this, true); }, //handleAvailable: function() { //var Event = YAHOO.util.Event; //Event.on(this.id, //}, /** * Renders the tree boilerplate and visible nodes * @method draw */ draw: function() { var html = this.root.getHtml(); this.getEl().innerHTML = html; this.firstDraw = false; }, /** * Returns the tree's host element * @method getEl * @return {HTMLElement} the host element */ getEl: function() { if (! this._el) { this._el = document.getElementById(this.id); } return this._el; }, /** * Nodes register themselves with the tree instance when they are created. * @method regNode * @param node {Node} the node to register * @private */ regNode: function(node) { this._nodes[node.index] = node; }, /** * Returns the root node of this tree * @method getRoot * @return {Node} the root node */ getRoot: function() { return this.root; }, /** * Configures this tree to dynamically load all child data * @method setDynamicLoad * @param {function} fnDataLoader the function that will be called to get the data * @param iconMode {int} configures the icon that is displayed when a dynamic * load node is expanded the first time without children. By default, the * "collapse" icon will be used. If set to 1, the leaf node icon will be * displayed. */ setDynamicLoad: function(fnDataLoader, iconMode) { this.root.setDynamicLoad(fnDataLoader, iconMode); }, /** * Expands all child nodes. Note: this conflicts with the "multiExpand" * node property. If expand all is called in a tree with nodes that * do not allow multiple siblings to be displayed, only the last sibling * will be expanded. * @method expandAll */ expandAll: function() { if (!this.locked) { this.root.expandAll(); } }, /** * Collapses all expanded child nodes in the entire tree. * @method collapseAll */ collapseAll: function() { if (!this.locked) { this.root.collapseAll(); } }, /** * Returns a node in the tree that has the specified index (this index * is created internally, so this function probably will only be used * in html generated for a given node.) * @method getNodeByIndex * @param {int} nodeIndex the index of the node wanted * @return {Node} the node with index=nodeIndex, null if no match */ getNodeByIndex: function(nodeIndex) { var n = this._nodes[nodeIndex]; return (n) ? n : null; }, /** * Returns a node that has a matching property and value in the data * object that was passed into its constructor. * @method getNodeByProperty * @param {object} property the property to search (usually a string) * @param {object} value the value we want to find (usuall an int or string) * @return {Node} the matching node, null if no match */ getNodeByProperty: function(property, value) { for (var i in this._nodes) { var n = this._nodes[i]; if (n.data && value == n.data[property]) { return n; } } return null; }, /** * Returns a collection of nodes that have a matching property * and value in the data object that was passed into its constructor. * @method getNodesByProperty * @param {object} property the property to search (usually a string) * @param {object} value the value we want to find (usuall an int or string) * @return {Array} the matching collection of nodes, null if no match */ getNodesByProperty: function(property, value) { var values = []; for (var i in this._nodes) { var n = this._nodes[i]; if (n.data && value == n.data[property]) { values.push(n); } } return (values.length) ? values : null; }, /** * Removes the node and its children, and optionally refreshes the * branch of the tree that was affected. * @method removeNode * @param {Node} The node to remove * @param {boolean} autoRefresh automatically refreshes branch if true * @return {boolean} False is there was a problem, true otherwise. */ removeNode: function(node, autoRefresh) { // Don't delete the root node if (node.isRoot()) { return false; } // Get the branch that we may need to refresh var p = node.parent; if (p.parent) { p = p.parent; } // Delete the node and its children this._deleteNode(node); // Refresh the parent of the parent if (autoRefresh && p && p.childrenRendered) { p.refresh(); } return true; }, /** * Deletes this nodes child collection, recursively. Also collapses * the node, and resets the dynamic load flag. The primary use for * this method is to purge a node and allow it to fetch its data * dynamically again. * @method removeChildren * @param {Node} node the node to purge */ removeChildren: function(node) { while (node.children.length) { this._deleteNode(node.children[0]); } node.childrenRendered = false; node.dynamicLoadComplete = false; if (node.expanded) { node.collapse(); } else { node.updateIcon(); } }, /** * Deletes the node and recurses children * @method _deleteNode * @private */ _deleteNode: function(node) { // Remove all the child nodes first this.removeChildren(node); // Remove the node from the tree this.popNode(node); }, /** * Removes the node from the tree, preserving the child collection * to make it possible to insert the branch into another part of the * tree, or another tree. * @method popNode * @param {Node} the node to remove */ popNode: function(node) { var p = node.parent; // Update the parent's collection of children var a = []; for (var i=0, len=p.children.length;i '; } var f = document.createElement("div"); var s = f.style; s.position = "absolute"; s.top = "-1000px"; s.left = "-1000px"; f.innerHTML = sb.join(""); document.body.appendChild(f); YAHOO.widget.TreeView.removeHandler(window, "load", YAHOO.widget.TreeView.preload); }; YAHOO.widget.TreeView.addHandler(window, "load", YAHOO.widget.TreeView.preload); /** * The base class for all tree nodes. The node's presentation and behavior in * response to mouse events is handled in Node subclasses. * @namespace YAHOO.widget * @class Node * @uses YAHOO.util.EventProvider * @param oData {object} a string or object containing the data that will * be used to render this node * @param oParent {Node} this node's parent node * @param expanded {boolean} the initial expanded/collapsed state * @constructor */ YAHOO.widget.Node = function(oData, oParent, expanded) { if (oData) { this.init(oData, oParent, expanded); } }; YAHOO.widget.Node.prototype = { /** * The index for this instance obtained from global counter in YAHOO.widget.TreeView. * @property index * @type int */ index: 0, /** * This node's child node collection. * @property children * @type Node[] */ children: null, /** * Tree instance this node is part of * @property tree * @type TreeView */ tree: null, /** * The data linked to this node. This can be any object or primitive * value, and the data can be used in getNodeHtml(). * @property data * @type object */ data: null, /** * Parent node * @property parent * @type Node */ parent: null, /** * The depth of this node. We start at -1 for the root node. * @property depth * @type int */ depth: -1, /** * The href for the node's label. If one is not specified, the href will * be set so that it toggles the node. * @property href * @type string */ href: null, /** * The label href target, defaults to current window * @property target * @type string */ target: "_self", /** * The node's expanded/collapsed state * @property expanded * @type boolean */ expanded: false, /** * Can multiple children be expanded at once? * @property multiExpand * @type boolean */ multiExpand: true, /** * Should we render children for a collapsed node? It is possible that the * implementer will want to render the hidden data... @todo verify that we * need this, and implement it if we do. * @property renderHidden * @type boolean */ renderHidden: false, /** * This flag is set to true when the html is generated for this node's * children, and set to false when new children are added. * @property childrenRendered * @type boolean */ childrenRendered: false, /** * Dynamically loaded nodes only fetch the data the first time they are * expanded. This flag is set to true once the data has been fetched. * @property dynamicLoadComplete * @type boolean */ dynamicLoadComplete: false, /** * This node's previous sibling * @property previousSibling * @type Node */ previousSibling: null, /** * This node's next sibling * @property nextSibling * @type Node */ nextSibling: null, /** * We can set the node up to call an external method to get the child * data dynamically. * @property _dynLoad * @type boolean * @private */ _dynLoad: false, /** * Function to execute when we need to get this node's child data. * @property dataLoader * @type function */ dataLoader: null, /** * This is true for dynamically loading nodes while waiting for the * callback to return. * @property isLoading * @type boolean */ isLoading: false, /** * The toggle/branch icon will not show if this is set to false. This * could be useful if the implementer wants to have the child contain * extra info about the parent, rather than an actual node. * @property hasIcon * @type boolean */ hasIcon: true, /** * Used to configure what happens when a dynamic load node is expanded * and we discover that it does not have children. By default, it is * treated as if it still could have children (plus/minus icon). Set * iconMode to have it display like a leaf node instead. * @property iconMode * @type int */ iconMode: 0, /** * Specifies whether or not the content area of the node should be allowed * to wrap. * @property nowrap * @type boolean * @default false */ nowrap: false, /** * The node type * @property _type * @private */ _type: "Node", /* spacerPath: "http://us.i1.yimg.com/us.yimg.com/i/space.gif", expandedText: "Expanded", collapsedText: "Collapsed", loadingText: "Loading", */ /** * Initializes this node, gets some of the properties from the parent * @method init * @param oData {object} a string or object containing the data that will * be used to render this node * @param oParent {Node} this node's parent node * @param expanded {boolean} the initial expanded/collapsed state */ init: function(oData, oParent, expanded) { this.data = oData; this.children = []; this.index = YAHOO.widget.TreeView.nodeCount; ++YAHOO.widget.TreeView.nodeCount; this.expanded = expanded; /** * The parentChange event is fired when a parent element is applied * to the node. This is useful if you need to apply tree-level * properties to a tree that need to happen if a node is moved from * one tree to another. * * @event parentChange * @type CustomEvent */ this.createEvent("parentChange", this); // oParent should never be null except when we create the root node. if (oParent) { oParent.appendChild(this); } }, /** * Certain properties for the node cannot be set until the parent * is known. This is called after the node is inserted into a tree. * the parent is also applied to this node's children in order to * make it possible to move a branch from one tree to another. * @method applyParent * @param {Node} parentNode this node's parent node * @return {boolean} true if the application was successful */ applyParent: function(parentNode) { if (!parentNode) { return false; } this.tree = parentNode.tree; this.parent = parentNode; this.depth = parentNode.depth + 1; if (!this.href) { this.href = "javascript:" + this.getToggleLink(); } // @todo why was this put here. This causes new nodes added at the // root level to lose the menu behavior. // if (! this.multiExpand) { // this.multiExpand = parentNode.multiExpand; // } this.tree.regNode(this); parentNode.childrenRendered = false; // cascade update existing children for (var i=0, len=this.children.length;i 0 || (checkForLazyLoad && this.isDynamic() && !this.dynamicLoadComplete) ); }, /** * Expands if node is collapsed, collapses otherwise. * @method toggle */ toggle: function() { if (!this.tree.locked && ( this.hasChildren(true) || this.isDynamic()) ) { if (this.expanded) { this.collapse(); } else { this.expand(); } } }, /** * Returns the markup for this node and its children. * @method getHtml * @return {string} the markup for this node and its expanded children. */ getHtml: function() { this.childrenRendered = false; var sb = []; sb[sb.length] = '
'; sb[sb.length] = this.getNodeHtml(); sb[sb.length] = this.getChildrenHtml(); sb[sb.length] = '
'; return sb.join(""); }, /** * Called when first rendering the tree. We always build the div that will * contain this nodes children, but we don't render the children themselves * unless this node is expanded. * @method getChildrenHtml * @return {string} the children container div html and any expanded children * @private */ getChildrenHtml: function() { var sb = []; sb[sb.length] = '
= this.depth || depth < 0) { return null; } var p = this.parent; while (p.depth > depth) { p = p.parent; } return p; }, /** * Returns the css class for the spacer at the specified depth for * this node. If this node's ancestor at the specified depth * has a next sibling the presentation is different than if it * does not have a next sibling * @method getDepthStyle * @param {int} depth the depth of the ancestor. * @return {string} the css class for the spacer */ getDepthStyle: function(depth) { return (this.getAncestor(depth).nextSibling) ? "ygtvdepthcell" : "ygtvblankdepthcell"; }, /** * Get the markup for the node. This is designed to be overrided so that we can * support different types of nodes. * @method getNodeHtml * @return {string} The HTML that will render this node. */ getNodeHtml: function() { return ""; }, /** * Regenerates the html for this node and its children. To be used when the * node is expanded and new children have been added. * @method refresh */ refresh: function() { // this.loadComplete(); this.getChildrenEl().innerHTML = this.completeRender(); if (this.hasIcon) { var el = this.getToggleEl(); if (el) { el.className = this.getStyle(); } } }, /** * Node toString * @method toString * @return {string} string representation of the node */ toString: function() { return "Node (" + this.index + ")"; } }; YAHOO.augment(YAHOO.widget.Node, YAHOO.util.EventProvider); /** * The default node presentation. The first parameter should be * either a string that will be used as the node's label, or an object * that has a string propery called label. By default, the clicking the * label will toggle the expanded/collapsed state of the node. By * changing the href property of the instance, this behavior can be * changed so that the label will go to the specified href. * @namespace YAHOO.widget * @class TextNode * @extends YAHOO.widget.Node * @constructor * @param oData {object} a string or object containing the data that will * be used to render this node * @param oParent {YAHOO.widget.Node} this node's parent node * @param expanded {boolean} the initial expanded/collapsed state */ YAHOO.widget.TextNode = function(oData, oParent, expanded) { if (oData) { this.init(oData, oParent, expanded); this.setUpLabel(oData); } }; YAHOO.extend(YAHOO.widget.TextNode, YAHOO.widget.Node, { /** * The CSS class for the label href. Defaults to ygtvlabel, but can be * overridden to provide a custom presentation for a specific node. * @property labelStyle * @type string */ labelStyle: "ygtvlabel", /** * The derived element id of the label for this node * @property labelElId * @type string */ labelElId: null, /** * The text for the label. It is assumed that the oData parameter will * either be a string that will be used as the label, or an object that * has a property called "label" that we will use. * @property label * @type string */ label: null, textNodeParentChange: function() { /** * Custom event that is fired when the text node label is clicked. The * custom event is defined on the tree instance, so there is a single * event that handles all nodes in the tree. The node clicked is * provided as an argument * * @event labelClick * @for YAHOO.widget.TreeView * @param {YAHOO.widget.Node} node the node clicked */ if (this.tree && !this.tree.hasEvent("labelClick")) { this.tree.createEvent("labelClick", this.tree); } }, /** * Sets up the node label * @method setUpLabel * @param oData string containing the label, or an object with a label property */ setUpLabel: function(oData) { // set up the custom event on the tree this.textNodeParentChange(); this.subscribe("parentChange", this.textNodeParentChange); if (typeof oData == "string") { oData = { label: oData }; } this.label = oData.label; this.data.label = oData.label; // update the link if (oData.href) { this.href = oData.href; } // set the target if (oData.target) { this.target = oData.target; } if (oData.style) { this.labelStyle = oData.style; } this.labelElId = "ygtvlabelel" + this.index; }, /** * Returns the label element * @for YAHOO.widget.TextNode * @method getLabelEl * @return {object} the element */ getLabelEl: function() { return document.getElementById(this.labelElId); }, // overrides YAHOO.widget.Node getNodeHtml: function() { var sb = []; sb[sb.length] = ''; sb[sb.length] = ''; for (var i=0;i '; //sb[sb.length] = ''; sb[sb.length] = ''; } var getNode = 'YAHOO.widget.TreeView.getNode(\'' + this.tree.id + '\',' + this.index + ')'; sb[sb.length] = ''; sb[sb.length] = '
'; /* sb[sb.length] = ' '; sb[sb.length] = '
'; } if (this.hasIcon) { sb[sb.length] = '