From 541bb378ddece2eab135a8066a16994e94436dea Mon Sep 17 00:00:00 2001
From: Giulio Cesare Solaroli <giulio.cesare@solaroli.it>
Date: Mon, 03 Oct 2011 16:04:12 +0000
Subject: Merge pull request #1 from gcsolaroli/master

First version of the restructured repository
---
(limited to 'frontend/beta/js/YUI/treeview.js')

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] + '">&#160;</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">&#160;</td>';
+            sb[sb.length] = '<td class="' + this.getDepthStyle(i) + '">&#160;</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] = '&#160;';
+
+        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) + '">&#160;</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] = '>&#160;</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";
+    }
+};
+
--
cgit v0.9.0.2