Diffstat (limited to 'frontend/beta/js/YUI/treeview.js') (more/less context) (ignore whitespace changes)
| -rw-r--r-- | frontend/beta/js/YUI/treeview.js | 2182 |
1 files changed, 2182 insertions, 0 deletions
diff --git a/frontend/beta/js/YUI/treeview.js b/frontend/beta/js/YUI/treeview.js new file mode 100644 index 0000000..ea6b6ef --- a/dev/null +++ b/frontend/beta/js/YUI/treeview.js @@ -0,0 +1,2182 @@ +/*
+Copyright (c) 2006, Yahoo! Inc. All rights reserved.
+Code licensed under the BSD License:
+http://developer.yahoo.net/yui/license.txt
+version: 0.12.0
+*/
+
+/**
+ * The treeview widget is a generic tree building tool.
+ * @module treeview
+ * @title TreeView Widget
+ * @requires yahoo
+ * @optional animation
+ * @namespace YAHOO.widget
+ */
+
+/**
+ * Contains the tree view state data and the root node.
+ *
+ * @class TreeView
+ * @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
+ * @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 expanded. Return false to stop
+ * the expand.
+ * @event collapse
+ * @type CustomEvent
+ * @param {YAHOO.widget.Node} node the node that is expanding/collapsing
+ */
+ this.createEvent("collapse", this);
+
+ /**
+ * Fires when a node is going to be collapsed. Return false to stop
+ * the collapse.
+ * @event expand
+ * @type CustomEvent
+ * @param {YAHOO.widget.Node} node the node that is expanding/collapsing
+ */
+ this.createEvent("expand", 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);
+
+
+ },
+
+ /**
+ * 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<len;++i) {
+ if (p.children[i] != node) {
+ a[a.length] = p.children[i];
+ }
+ }
+
+ p.children = a;
+
+ // reset the childrenRendered flag for the parent
+ p.childrenRendered = false;
+
+ // Update the sibling relationship
+ if (node.previousSibling) {
+ node.previousSibling.nextSibling = node.nextSibling;
+ }
+
+ if (node.nextSibling) {
+ node.nextSibling.previousSibling = node.previousSibling;
+ }
+
+ node.parent = null;
+ node.previousSibling = null;
+ node.nextSibling = null;
+ node.tree = null;
+
+ // Update the tree's node collection
+ delete this._nodes[node.index];
+ },
+
+ /**
+ * TreeView instance toString
+ * @method toString
+ * @return {string} string representation of the tree
+ */
+ toString: function() {
+ return "TreeView " + this.id;
+ },
+
+ /**
+ * Generates an unique id for an element if it doesn't yet have one
+ * @method generateId
+ * @private
+ */
+ generateId: function(el) {
+ var id = el.id;
+
+ if (!id) {
+ id = "yui-tv-auto-id-" + YAHOO.widget.TreeView.counter;
+ ++YAHOO.widget.TreeView.counter;
+ }
+
+ return id;
+ },
+
+ /**
+ * Abstract method that is executed when a node is expanded
+ * @method onExpand
+ * @param node {Node} the node that was expanded
+ * @deprecated use treeobj.subscribe("expand") instead
+ */
+ onExpand: function(node) { },
+
+ /**
+ * Abstract method that is executed when a node is collapsed.
+ * @method onCollapse
+ * @param node {Node} the node that was collapsed.
+ * @deprecated use treeobj.subscribe("collapse") instead
+ */
+ onCollapse: function(node) { }
+
+};
+
+YAHOO.augment(YAHOO.widget.TreeView, YAHOO.util.EventProvider);
+
+/**
+ * Count of all nodes in all trees
+ * @property YAHOO.widget.TreeView.nodeCount
+ * @type int
+ * @static
+ */
+YAHOO.widget.TreeView.nodeCount = 0;
+
+/**
+ * Global cache of tree instances
+ * @property YAHOO.widget.TreeView.trees
+ * @type Array
+ * @static
+ * @private
+ */
+YAHOO.widget.TreeView.trees = [];
+
+/**
+ * Counter for generating a new unique element id
+ * @property YAHOO.widget.TreeView.counter
+ * @static
+ * @private
+ */
+YAHOO.widget.TreeView.counter = 0;
+
+/**
+ * Global method for getting a tree by its id. Used in the generated
+ * tree html.
+ * @method YAHOO.widget.TreeView.getTree
+ * @param treeId {String} the id of the tree instance
+ * @return {TreeView} the tree instance requested, null if not found.
+ * @static
+ */
+YAHOO.widget.TreeView.getTree = function(treeId) {
+ var t = YAHOO.widget.TreeView.trees[treeId];
+ return (t) ? t : null;
+};
+
+/**
+ * Global method for getting a node by its id. Used in the generated
+ * tree html.
+ * @method YAHOO.widget.TreeView.getNode
+ * @param treeId {String} the id of the tree instance
+ * @param nodeIndex {String} the index of the node to return
+ * @return {Node} the node instance requested, null if not found
+ * @static
+ */
+YAHOO.widget.TreeView.getNode = function(treeId, nodeIndex) {
+ var t = YAHOO.widget.TreeView.getTree(treeId);
+ return (t) ? t.getNodeByIndex(nodeIndex) : null;
+};
+
+/**
+ * Add a DOM event
+ * @method YAHOO.widget.TreeView.addHandler
+ * @param el the elment to bind the handler to
+ * @param {string} sType the type of event handler
+ * @param {function} fn the callback to invoke
+ * @static
+ */
+YAHOO.widget.TreeView.addHandler = function (el, sType, fn) {
+ if (el.addEventListener) {
+ el.addEventListener(sType, fn, false);
+ } else if (el.attachEvent) {
+ el.attachEvent("on" + sType, fn);
+ }
+};
+
+/**
+ * Remove a DOM event
+ * @method YAHOO.widget.TreeView.removeHandler
+ * @param el the elment to bind the handler to
+ * @param {string} sType the type of event handler
+ * @param {function} fn the callback to invoke
+ * @static
+ */
+
+YAHOO.widget.TreeView.removeHandler = function (el, sType, fn) {
+ if (el.removeEventListener) {
+ el.removeEventListener(sType, fn, false);
+ } else if (el.detachEvent) {
+ el.detachEvent("on" + sType, fn);
+ }
+};
+
+/**
+ * Attempts to preload the images defined in the styles used to draw the tree by
+ * rendering off-screen elements that use the styles.
+ * @method YAHOO.widget.TreeView.preload
+ * @param {string} prefix the prefix to use to generate the names of the
+ * images to preload, default is ygtv
+ * @static
+ */
+YAHOO.widget.TreeView.preload = function(prefix) {
+ prefix = prefix || "ygtv";
+ var styles = ["tn","tm","tmh","tp","tph","ln","lm","lmh","lp","lph","loading"];
+
+ var sb = [];
+
+ for (var i = 0; i < styles.length; ++i) {
+ sb[sb.length] = '<span class="' + prefix + styles[i] + '"> </span>';
+ }
+
+ 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
+ * @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,
+
+ /**
+ * 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 tre 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();
+ }
+
+ 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<len;++i) {
+ this.children[i].applyParent(this);
+ }
+
+ this.fireEvent("parentChange");
+
+ return true;
+ },
+
+ /**
+ * Appends a node to the child collection.
+ * @method appendChild
+ * @param childNode {Node} the new node
+ * @return {Node} the child node
+ * @private
+ */
+ appendChild: function(childNode) {
+ if (this.hasChildren()) {
+ var sib = this.children[this.children.length - 1];
+ sib.nextSibling = childNode;
+ childNode.previousSibling = sib;
+ }
+ this.children[this.children.length] = childNode;
+ childNode.applyParent(this);
+
+ return childNode;
+ },
+
+ /**
+ * Appends this node to the supplied node's child collection
+ * @method appendTo
+ * @param parentNode {Node} the node to append to.
+ * @return {Node} The appended node
+ */
+ appendTo: function(parentNode) {
+ return parentNode.appendChild(this);
+ },
+
+ /**
+ * Inserts this node before this supplied node
+ * @method insertBefore
+ * @param node {Node} the node to insert this node before
+ * @return {Node} the inserted node
+ */
+ insertBefore: function(node) {
+ var p = node.parent;
+ if (p) {
+
+ if (this.tree) {
+ this.tree.popNode(this);
+ }
+
+ var refIndex = node.isChildOf(p);
+ p.children.splice(refIndex, 0, this);
+ if (node.previousSibling) {
+ node.previousSibling.nextSibling = this;
+ }
+ this.previousSibling = node.previousSibling;
+ this.nextSibling = node;
+ node.previousSibling = this;
+
+ this.applyParent(p);
+ }
+
+ return this;
+ },
+
+ /**
+ * Inserts this node after the supplied node
+ * @method insertAfter
+ * @param node {Node} the node to insert after
+ * @return {Node} the inserted node
+ */
+ insertAfter: function(node) {
+ var p = node.parent;
+ if (p) {
+
+ if (this.tree) {
+ this.tree.popNode(this);
+ }
+
+ var refIndex = node.isChildOf(p);
+
+ if (!node.nextSibling) {
+ return this.appendTo(p);
+ }
+
+ p.children.splice(refIndex + 1, 0, this);
+
+ node.nextSibling.previousSibling = this;
+ this.previousSibling = node;
+ this.nextSibling = node.nextSibling;
+ node.nextSibling = this;
+
+ this.applyParent(p);
+ }
+
+ return this;
+ },
+
+ /**
+ * Returns true if the Node is a child of supplied Node
+ * @method isChildOf
+ * @param parentNode {Node} the Node to check
+ * @return {boolean} The node index if this Node is a child of
+ * supplied Node, else -1.
+ * @private
+ */
+ isChildOf: function(parentNode) {
+ if (parentNode && parentNode.children) {
+ for (var i=0, len=parentNode.children.length; i<len ; ++i) {
+ if (parentNode.children[i] === this) {
+ return i;
+ }
+ }
+ }
+
+ return -1;
+ },
+
+ /**
+ * Returns a node array of this node's siblings, null if none.
+ * @method getSiblings
+ * @return Node[]
+ */
+ getSiblings: function() {
+ return this.parent.children;
+ },
+
+ /**
+ * Shows this node's children
+ * @method showChildren
+ */
+ showChildren: function() {
+ if (!this.tree.animateExpand(this.getChildrenEl(), this)) {
+ if (this.hasChildren()) {
+ this.getChildrenEl().style.display = "";
+ }
+ }
+ },
+
+ /**
+ * Hides this node's children
+ * @method hideChildren
+ */
+ hideChildren: function() {
+
+ if (!this.tree.animateCollapse(this.getChildrenEl(), this)) {
+ this.getChildrenEl().style.display = "none";
+ }
+ },
+
+ /**
+ * Returns the id for this node's container div
+ * @method getElId
+ * @return {string} the element id
+ */
+ getElId: function() {
+ return "ygtv" + this.index;
+ },
+
+ /**
+ * Returns the id for this node's children div
+ * @method getChildrenElId
+ * @return {string} the element id for this node's children div
+ */
+ getChildrenElId: function() {
+ return "ygtvc" + this.index;
+ },
+
+ /**
+ * Returns the id for this node's toggle element
+ * @method getToggleElId
+ * @return {string} the toggel element id
+ */
+ getToggleElId: function() {
+ return "ygtvt" + this.index;
+ },
+
+ /*
+ * Returns the id for this node's spacer image. The spacer is positioned
+ * over the toggle and provides feedback for screen readers.
+ * @method getSpacerId
+ * @return {string} the id for the spacer image
+ */
+ /*
+ getSpacerId: function() {
+ return "ygtvspacer" + this.index;
+ },
+ */
+
+ /**
+ * Returns this node's container html element
+ * @method getEl
+ * @return {HTMLElement} the container html element
+ */
+ getEl: function() {
+ return document.getElementById(this.getElId());
+ },
+
+ /**
+ * Returns the div that was generated for this node's children
+ * @method getChildrenEl
+ * @return {HTMLElement} this node's children div
+ */
+ getChildrenEl: function() {
+ return document.getElementById(this.getChildrenElId());
+ },
+
+ /**
+ * Returns the element that is being used for this node's toggle.
+ * @method getToggleEl
+ * @return {HTMLElement} this node's toggle html element
+ */
+ getToggleEl: function() {
+ return document.getElementById(this.getToggleElId());
+ },
+
+ /*
+ * Returns the element that is being used for this node's spacer.
+ * @method getSpacer
+ * @return {HTMLElement} this node's spacer html element
+ */
+ /*
+ getSpacer: function() {
+ return document.getElementById( this.getSpacerId() ) || {};
+ },
+ */
+
+ /*
+ getStateText: function() {
+ if (this.isLoading) {
+ return this.loadingText;
+ } else if (this.hasChildren(true)) {
+ if (this.expanded) {
+ return this.expandedText;
+ } else {
+ return this.collapsedText;
+ }
+ } else {
+ return "";
+ }
+ },
+ */
+
+ /**
+ * Generates the link that will invoke this node's toggle method
+ * @method getToggleLink
+ * @return {string} the javascript url for toggling this node
+ */
+ getToggleLink: function() {
+ return "YAHOO.widget.TreeView.getNode(\'" + this.tree.id + "\'," +
+ this.index + ").toggle()";
+ },
+
+ /**
+ * Hides this nodes children (creating them if necessary), changes the
+ * @method collapse
+ * toggle style.
+ */
+ collapse: function() {
+ // Only collapse if currently expanded
+ if (!this.expanded) { return; }
+
+ // fire the collapse event handler
+ var ret = this.tree.onCollapse(this);
+
+ if (false === ret) {
+ return;
+ }
+
+ ret = this.tree.fireEvent("collapse", this);
+
+ if (false === ret) {
+ return;
+ }
+
+ if (!this.getEl()) {
+ this.expanded = false;
+ return;
+ }
+
+ // hide the child div
+ this.hideChildren();
+ this.expanded = false;
+
+ this.updateIcon();
+
+ // this.getSpacer().title = this.getStateText();
+
+ },
+
+ /**
+ * Shows this nodes children (creating them if necessary), changes the
+ * toggle style, and collapses its siblings if multiExpand is not set.
+ * @method expand
+ */
+ expand: function() {
+ // Only expand if currently collapsed.
+ if (this.expanded) { return; }
+
+ // fire the expand event handler
+ var ret = this.tree.onExpand(this);
+
+ if (false === ret) {
+ return;
+ }
+
+ ret = this.tree.fireEvent("expand", this);
+
+ if (false === ret) {
+ return;
+ }
+
+ if (!this.getEl()) {
+ this.expanded = true;
+ return;
+ }
+
+ if (! this.childrenRendered) {
+ this.getChildrenEl().innerHTML = this.renderChildren();
+ } else {
+ }
+
+ this.expanded = true;
+
+ this.updateIcon();
+
+ // this.getSpacer().title = this.getStateText();
+
+ // We do an extra check for children here because the lazy
+ // load feature can expose nodes that have no children.
+
+ // if (!this.hasChildren()) {
+ if (this.isLoading) {
+ this.expanded = false;
+ return;
+ }
+
+ if (! this.multiExpand) {
+ var sibs = this.getSiblings();
+ for (var i=0; i<sibs.length; ++i) {
+ if (sibs[i] != this && sibs[i].expanded) {
+ sibs[i].collapse();
+ }
+ }
+ }
+
+ this.showChildren();
+ },
+
+ updateIcon: function() {
+ if (this.hasIcon) {
+ var el = this.getToggleEl();
+ if (el) {
+ el.className = this.getStyle();
+ }
+ }
+ },
+
+ /**
+ * Returns the css style name for the toggle
+ * @method getStyle
+ * @return {string} the css class for this node's toggle
+ */
+ getStyle: function() {
+ if (this.isLoading) {
+ return "ygtvloading";
+ } else {
+ // location top or bottom, middle nodes also get the top style
+ var loc = (this.nextSibling) ? "t" : "l";
+
+ // type p=plus(expand), m=minus(collapase), n=none(no children)
+ var type = "n";
+ if (this.hasChildren(true) || (this.isDynamic() && !this.getIconMode())) {
+ // if (this.hasChildren(true)) {
+ type = (this.expanded) ? "m" : "p";
+ }
+
+ return "ygtv" + loc + type;
+ }
+ },
+
+ /**
+ * Returns the hover style for the icon
+ * @return {string} the css class hover state
+ * @method getHoverStyle
+ */
+ getHoverStyle: function() {
+ var s = this.getStyle();
+ if (this.hasChildren(true) && !this.isLoading) {
+ s += "h";
+ }
+ return s;
+ },
+
+ /**
+ * Recursively expands all of this node's children.
+ * @method expandAll
+ */
+ expandAll: function() {
+ for (var i=0;i<this.children.length;++i) {
+ var c = this.children[i];
+ if (c.isDynamic()) {
+ alert("Not supported (lazy load + expand all)");
+ break;
+ } else if (! c.multiExpand) {
+ alert("Not supported (no multi-expand + expand all)");
+ break;
+ } else {
+ c.expand();
+ c.expandAll();
+ }
+ }
+ },
+
+ /**
+ * Recursively collapses all of this node's children.
+ * @method collapseAll
+ */
+ collapseAll: function() {
+ for (var i=0;i<this.children.length;++i) {
+ this.children[i].collapse();
+ this.children[i].collapseAll();
+ }
+ },
+
+ /**
+ * Configures this node for dynamically obtaining the child data
+ * when the node is first expanded. Calling it without the callback
+ * will turn off dynamic load for the node.
+ * @method setDynamicLoad
+ * @param fmDataLoader {function} the function that will be used 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) {
+ if (fnDataLoader) {
+ this.dataLoader = fnDataLoader;
+ this._dynLoad = true;
+ } else {
+ this.dataLoader = null;
+ this._dynLoad = false;
+ }
+
+ if (iconMode) {
+ this.iconMode = iconMode;
+ }
+ },
+
+ /**
+ * Evaluates if this node is the root node of the tree
+ * @method isRoot
+ * @return {boolean} true if this is the root node
+ */
+ isRoot: function() {
+ return (this == this.tree.root);
+ },
+
+ /**
+ * Evaluates if this node's children should be loaded dynamically. Looks for
+ * the property both in this instance and the root node. If the tree is
+ * defined to load all children dynamically, the data callback function is
+ * defined in the root node
+ * @method isDynamic
+ * @return {boolean} true if this node's children are to be loaded dynamically
+ */
+ isDynamic: function() {
+ var lazy = (!this.isRoot() && (this._dynLoad || this.tree.root._dynLoad));
+ return lazy;
+ },
+
+ /**
+ * Returns the current icon mode. This refers to the way childless dynamic
+ * load nodes appear.
+ * @method getIconMode
+ * @return {int} 0 for collapse style, 1 for leaf node style
+ */
+ getIconMode: function() {
+ return (this.iconMode || this.tree.root.iconMode);
+ },
+
+ /**
+ * Checks if this node has children. If this node is lazy-loading and the
+ * children have not been rendered, we do not know whether or not there
+ * are actual children. In most cases, we need to assume that there are
+ * children (for instance, the toggle needs to show the expandable
+ * presentation state). In other times we want to know if there are rendered
+ * children. For the latter, "checkForLazyLoad" should be false.
+ * @method hasChildren
+ * @param checkForLazyLoad {boolean} should we check for unloaded children?
+ * @return {boolean} true if this has children or if it might and we are
+ * checking for this condition.
+ */
+ hasChildren: function(checkForLazyLoad) {
+ return ( this.children.length > 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] = '<div class="ygtvitem" id="' + this.getElId() + '">';
+ sb[sb.length] = this.getNodeHtml();
+ sb[sb.length] = this.getChildrenHtml();
+ sb[sb.length] = '</div>';
+ 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] = '<div class="ygtvchildren"';
+ sb[sb.length] = ' id="' + this.getChildrenElId() + '"';
+ if (!this.expanded) {
+ sb[sb.length] = ' style="display:none;"';
+ }
+ sb[sb.length] = '>';
+
+ // Don't render the actual child node HTML unless this node is expanded.
+ if ( (this.hasChildren(true) && this.expanded) ||
+ (this.renderHidden && !this.isDynamic()) ) {
+ sb[sb.length] = this.renderChildren();
+ }
+
+ sb[sb.length] = '</div>';
+
+ return sb.join("");
+ },
+
+ /**
+ * Generates the markup for the child nodes. This is not done until the node
+ * is expanded.
+ * @method renderChildren
+ * @return {string} the html for this node's children
+ * @private
+ */
+ renderChildren: function() {
+
+
+ var node = this;
+
+ if (this.isDynamic() && !this.dynamicLoadComplete) {
+ this.isLoading = true;
+ this.tree.locked = true;
+
+ if (this.dataLoader) {
+
+ setTimeout(
+ function() {
+ node.dataLoader(node,
+ function() {
+ node.loadComplete();
+ });
+ }, 10);
+
+ } else if (this.tree.root.dataLoader) {
+
+ setTimeout(
+ function() {
+ node.tree.root.dataLoader(node,
+ function() {
+ node.loadComplete();
+ });
+ }, 10);
+
+ } else {
+ return "Error: data loader not found or not specified.";
+ }
+
+ return "";
+
+ } else {
+ return this.completeRender();
+ }
+ },
+
+ /**
+ * Called when we know we have all the child data.
+ * @method completeRender
+ * @return {string} children html
+ */
+ completeRender: function() {
+ var sb = [];
+
+ for (var i=0; i < this.children.length; ++i) {
+ // this.children[i].childrenRendered = false;
+ sb[sb.length] = this.children[i].getHtml();
+ }
+
+ this.childrenRendered = true;
+
+ return sb.join("");
+ },
+
+ /**
+ * Load complete is the callback function we pass to the data provider
+ * in dynamic load situations.
+ * @method loadComplete
+ */
+ loadComplete: function() {
+ this.getChildrenEl().innerHTML = this.completeRender();
+ this.dynamicLoadComplete = true;
+ this.isLoading = false;
+ this.expand();
+ this.tree.locked = false;
+ },
+
+ /**
+ * Returns this node's ancestor at the specified depth.
+ * @method getAncestor
+ * @param {int} depth the depth of the ancestor.
+ * @return {Node} the ancestor
+ */
+ getAncestor: function(depth) {
+ if (depth >= 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);
+
+/**
+ * A custom YAHOO.widget.Node that handles the unique nature of
+ * the virtual, presentationless root node.
+ * @namespace YAHOO.widget
+ * @class RootNode
+ * @extends YAHOO.widget.Node
+ * @param oTree {YAHOO.widget.TreeView} The tree instance this node belongs to
+ * @constructor
+ */
+YAHOO.widget.RootNode = function(oTree) {
+ // Initialize the node with null params. The root node is a
+ // special case where the node has no presentation. So we have
+ // to alter the standard properties a bit.
+ this.init(null, null, true);
+
+ /*
+ * For the root node, we get the tree reference from as a param
+ * to the constructor instead of from the parent element.
+ */
+ this.tree = oTree;
+};
+
+YAHOO.extend(YAHOO.widget.RootNode, YAHOO.widget.Node, {
+
+ // overrides YAHOO.widget.Node
+ getNodeHtml: function() {
+ return "";
+ },
+
+ toString: function() {
+ return "RootNode";
+ },
+
+ loadComplete: function() {
+ this.tree.draw();
+ }
+
+});
+/**
+ * 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;
+
+ // 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] = '<table border="0" cellpadding="0" cellspacing="0">';
+ sb[sb.length] = '<tr>';
+
+ for (var i=0;i<this.depth;++i) {
+ // sb[sb.length] = '<td class="ygtvdepthcell"> </td>';
+ sb[sb.length] = '<td class="' + this.getDepthStyle(i) + '"> </td>';
+ }
+
+ var getNode = 'YAHOO.widget.TreeView.getNode(\'' +
+ this.tree.id + '\',' + this.index + ')';
+
+ sb[sb.length] = '<td';
+ // sb[sb.length] = ' onselectstart="return false"';
+ sb[sb.length] = ' id="' + this.getToggleElId() + '"';
+ sb[sb.length] = ' class="' + this.getStyle() + '"';
+ if (this.hasChildren(true)) {
+ sb[sb.length] = ' onmouseover="this.className=';
+ sb[sb.length] = getNode + '.getHoverStyle()"';
+ sb[sb.length] = ' onmouseout="this.className=';
+ sb[sb.length] = getNode + '.getStyle()"';
+ }
+ sb[sb.length] = ' onclick="javascript:' + this.getToggleLink() + '">';
+
+ /*
+ sb[sb.length] = '<img id="' + this.getSpacerId() + '"';
+ sb[sb.length] = ' alt=""';
+ sb[sb.length] = ' tabindex=0';
+ sb[sb.length] = ' src="' + this.spacerPath + '"';
+ sb[sb.length] = ' title="' + this.getStateText() + '"';
+ sb[sb.length] = ' class="ygtvspacer"';
+ // sb[sb.length] = ' onkeypress="return ' + getNode + '".onKeyPress()"';
+ sb[sb.length] = ' />';
+ */
+
+ sb[sb.length] = ' ';
+
+ sb[sb.length] = '</td>';
+ sb[sb.length] = '<td>';
+ sb[sb.length] = '<a';
+ sb[sb.length] = ' id="' + this.labelElId + '"';
+ sb[sb.length] = ' class="' + this.labelStyle + '"';
+ sb[sb.length] = ' href="' + this.href + '"';
+ sb[sb.length] = ' target="' + this.target + '"';
+ sb[sb.length] = ' onclick="return ' + getNode + '.onLabelClick(' + getNode +')"';
+ if (this.hasChildren(true)) {
+ sb[sb.length] = ' onmouseover="document.getElementById(\'';
+ sb[sb.length] = this.getToggleElId() + '\').className=';
+ sb[sb.length] = getNode + '.getHoverStyle()"';
+ sb[sb.length] = ' onmouseout="document.getElementById(\'';
+ sb[sb.length] = this.getToggleElId() + '\').className=';
+ sb[sb.length] = getNode + '.getStyle()"';
+ }
+ sb[sb.length] = ' >';
+ sb[sb.length] = this.label;
+ sb[sb.length] = '</a>';
+ sb[sb.length] = '</td>';
+ sb[sb.length] = '</tr>';
+ sb[sb.length] = '</table>';
+
+ return sb.join("");
+ },
+
+ /**
+ * Executed when the label is clicked. Fires the labelClick custom event.
+ * @method onLabelClick
+ * @param me {Node} this node
+ * @scope the anchor tag clicked
+ * @return false to cancel the anchor click
+ */
+ onLabelClick: function(me) {
+ return me.tree.fireEvent("labelClick", me);
+ //return true;
+ },
+
+ toString: function() {
+ return "TextNode (" + this.index + ") " + this.label;
+ }
+
+});
+/**
+ * A menu-specific implementation that differs from TextNode in that only
+ * one sibling can be expanded at a time.
+ * @namespace YAHOO.widget
+ * @class MenuNode
+ * @extends YAHOO.widget.TextNode
+ * @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
+ * @constructor
+ */
+YAHOO.widget.MenuNode = function(oData, oParent, expanded) {
+ if (oData) {
+ this.init(oData, oParent, expanded);
+ this.setUpLabel(oData);
+ }
+
+ /*
+ * Menus usually allow only one branch to be open at a time.
+ */
+ this.multiExpand = false;
+
+
+};
+
+YAHOO.extend(YAHOO.widget.MenuNode, YAHOO.widget.TextNode, {
+
+ toString: function() {
+ return "MenuNode (" + this.index + ") " + this.label;
+ }
+
+});
+/**
+ * This implementation takes either a string or object for the
+ * oData argument. If is it a string, we will use it for the display
+ * of this node (and it can contain any html code). If the parameter
+ * is an object, we look for a parameter called "html" that will be
+ * used for this node's display.
+ * @namespace YAHOO.widget
+ * @class HTMLNode
+ * @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
+ * @param hasIcon {boolean} specifies whether or not leaf nodes should
+ * have an icon
+ */
+YAHOO.widget.HTMLNode = function(oData, oParent, expanded, hasIcon) {
+ if (oData) {
+ this.init(oData, oParent, expanded);
+ this.initContent(oData, hasIcon);
+ }
+};
+
+YAHOO.extend(YAHOO.widget.HTMLNode, YAHOO.widget.Node, {
+
+ /**
+ * The CSS class for the html content container. Defaults to ygtvhtml, but
+ * can be overridden to provide a custom presentation for a specific node.
+ * @property contentStyle
+ * @type string
+ */
+ contentStyle: "ygtvhtml",
+
+ /**
+ * The generated id that will contain the data passed in by the implementer.
+ * @property contentElId
+ * @type string
+ */
+ contentElId: null,
+
+ /**
+ * The HTML content to use for this node's display
+ * @property content
+ * @type string
+ */
+ content: null,
+
+ /**
+ * Sets up the node label
+ * @property initContent
+ * @param {object} An html string or object containing an html property
+ * @param {boolean} hasIcon determines if the node will be rendered with an
+ * icon or not
+ */
+ initContent: function(oData, hasIcon) {
+ if (typeof oData == "string") {
+ oData = { html: oData };
+ }
+
+ this.html = oData.html;
+ this.contentElId = "ygtvcontentel" + this.index;
+ this.hasIcon = hasIcon;
+
+ },
+
+ /**
+ * Returns the outer html element for this node's content
+ * @method getContentEl
+ * @return {HTMLElement} the element
+ */
+ getContentEl: function() {
+ return document.getElementById(this.contentElId);
+ },
+
+ // overrides YAHOO.widget.Node
+ getNodeHtml: function() {
+ var sb = [];
+
+ sb[sb.length] = '<table border="0" cellpadding="0" cellspacing="0">';
+ sb[sb.length] = '<tr>';
+
+ for (var i=0;i<this.depth;++i) {
+ sb[sb.length] = '<td class="' + this.getDepthStyle(i) + '"> </td>';
+ }
+
+ if (this.hasIcon) {
+ sb[sb.length] = '<td';
+ sb[sb.length] = ' id="' + this.getToggleElId() + '"';
+ sb[sb.length] = ' class="' + this.getStyle() + '"';
+ sb[sb.length] = ' onclick="javascript:' + this.getToggleLink() + '"';
+ if (this.hasChildren(true)) {
+ sb[sb.length] = ' onmouseover="this.className=';
+ sb[sb.length] = 'YAHOO.widget.TreeView.getNode(\'';
+ sb[sb.length] = this.tree.id + '\',' + this.index + ').getHoverStyle()"';
+ sb[sb.length] = ' onmouseout="this.className=';
+ sb[sb.length] = 'YAHOO.widget.TreeView.getNode(\'';
+ sb[sb.length] = this.tree.id + '\',' + this.index + ').getStyle()"';
+ }
+ sb[sb.length] = '> </td>';
+ }
+
+ sb[sb.length] = '<td';
+ sb[sb.length] = ' id="' + this.contentElId + '"';
+ sb[sb.length] = ' class="' + this.contentStyle + '"';
+ sb[sb.length] = ' >';
+ sb[sb.length] = this.html;
+ sb[sb.length] = '</td>';
+ sb[sb.length] = '</tr>';
+ sb[sb.length] = '</table>';
+
+ return sb.join("");
+ },
+
+ toString: function() {
+ return "HTMLNode (" + this.index + ")";
+ }
+
+});
+/**
+ * A static factory class for tree view expand/collapse animations
+ * @class TVAnim
+ * @static
+ */
+YAHOO.widget.TVAnim = function() {
+ return {
+ /**
+ * Constant for the fade in animation
+ * @property FADE_IN
+ * @type string
+ * @static
+ */
+ FADE_IN: "TVFadeIn",
+
+ /**
+ * Constant for the fade out animation
+ * @property FADE_OUT
+ * @type string
+ * @static
+ */
+ FADE_OUT: "TVFadeOut",
+
+ /**
+ * Returns a ygAnim instance of the given type
+ * @method getAnim
+ * @param type {string} the type of animation
+ * @param el {HTMLElement} the element to element (probably the children div)
+ * @param callback {function} function to invoke when the animation is done.
+ * @return {YAHOO.util.Animation} the animation instance
+ * @static
+ */
+ getAnim: function(type, el, callback) {
+ if (YAHOO.widget[type]) {
+ return new YAHOO.widget[type](el, callback);
+ } else {
+ return null;
+ }
+ },
+
+ /**
+ * Returns true if the specified animation class is available
+ * @method isValid
+ * @param type {string} the type of animation
+ * @return {boolean} true if valid, false if not
+ * @static
+ */
+ isValid: function(type) {
+ return (YAHOO.widget[type]);
+ }
+ };
+} ();
+
+/**
+ * A 1/2 second fade-in animation.
+ * @class TVFadeIn
+ * @constructor
+ * @param el {HTMLElement} the element to animate
+ * @param callback {function} function to invoke when the animation is finished
+ */
+YAHOO.widget.TVFadeIn = function(el, callback) {
+ /**
+ * The element to animate
+ * @property el
+ * @type HTMLElement
+ */
+ this.el = el;
+
+ /**
+ * the callback to invoke when the animation is complete
+ * @property callback
+ * @type function
+ */
+ this.callback = callback;
+
+};
+
+YAHOO.widget.TVFadeIn.prototype = {
+ /**
+ * Performs the animation
+ * @method animate
+ */
+ animate: function() {
+ var tvanim = this;
+
+ var s = this.el.style;
+ s.opacity = 0.1;
+ s.filter = "alpha(opacity=10)";
+ s.display = "";
+
+ var dur = 0.4;
+ var a = new YAHOO.util.Anim(this.el, {opacity: {from: 0.1, to: 1, unit:""}}, dur);
+ a.onComplete.subscribe( function() { tvanim.onComplete(); } );
+ a.animate();
+ },
+
+ /**
+ * Clean up and invoke callback
+ * @method onComplete
+ */
+ onComplete: function() {
+ this.callback();
+ },
+
+ /**
+ * toString
+ * @method toString
+ * @return {string} the string representation of the instance
+ */
+ toString: function() {
+ return "TVFadeIn";
+ }
+};
+
+/**
+ * A 1/2 second fade out animation.
+ * @class TVFadeOut
+ * @constructor
+ * @param el {HTMLElement} the element to animate
+ * @param callback {Function} function to invoke when the animation is finished
+ */
+YAHOO.widget.TVFadeOut = function(el, callback) {
+ /**
+ * The element to animate
+ * @property el
+ * @type HTMLElement
+ */
+ this.el = el;
+
+ /**
+ * the callback to invoke when the animation is complete
+ * @property callback
+ * @type function
+ */
+ this.callback = callback;
+
+};
+
+YAHOO.widget.TVFadeOut.prototype = {
+ /**
+ * Performs the animation
+ * @method animate
+ */
+ animate: function() {
+ var tvanim = this;
+ var dur = 0.4;
+ var a = new YAHOO.util.Anim(this.el, {opacity: {from: 1, to: 0.1, unit:""}}, dur);
+ a.onComplete.subscribe( function() { tvanim.onComplete(); } );
+ a.animate();
+ },
+
+ /**
+ * Clean up and invoke callback
+ * @method onComplete
+ */
+ onComplete: function() {
+ var s = this.el.style;
+ s.display = "none";
+ // s.opacity = 1;
+ s.filter = "alpha(opacity=100)";
+ this.callback();
+ },
+
+ /**
+ * toString
+ * @method toString
+ * @return {string} the string representation of the instance
+ */
+ toString: function() {
+ return "TVFadeOut";
+ }
+};
+
|