DHTML Calendar Javascript Source Code Documentation

tree.js

Go to the documentation of this file.

// if (_zapatec_tree_url)
//      _zapatec_tree_url = _zapatec_tree_url.replace(/\/*$/, '/');

Zapatec.Tree = function(el, config) {
        if (typeof config == "undefined"){
                config = {};
        }

        function param_default(name, value) {
                if (typeof config[name] == "undefined"){
                        config[name] = value;
                }
        };

        param_default('d_profile', false);
        param_default('hiliteSelectedNode', true);
        param_default('compact', false);
        param_default('dynamic', false);
        param_default('initLevel', false);

        //expand/collapse the tree when the text or image are clicked
        param_default('expandOnLabel', true); 

        //Keep track, using cookies, of the last location the user opened
        param_default('saveState', false); 
        
        if(config.dynamic){
                config.initLevel = 0;
        }

        if(
                config.dynamic ||
                config.saveState && 
                (
                        typeof(config.saveId) != "string" || 
                        (
                                typeof(config.saveId) == "string" &&
                                config.saveId.length == 0
                        )
                )
        ){
                config.saveState = false;
        }

        this.config = config;
        
        // <PROFILE>
        if (this.config.d_profile) {
                var T1 = new Date().getTime();
        
                profile = {
                        items : 0,
                        trees : 0,
                        icons : 0
                };
        }
        // </PROFILE>

        if (typeof el == "string"){
                el = document.getElementById(el);
        }

        this.list = el;
        this.items = {};
        this.trees = {};
        this.selectedItem = null;
        this.id = el.id || Zapatec.Utils.generateID("tree");
        var top = this.top_parent = Zapatec.Utils.createElement("div");
        top.className = "tree tree-top";
        this.createTree(el, top, 0);
        el.parentNode.insertBefore(top, el);
        el.parentNode.removeChild(el);
        Zapatec.Tree.all[this.id] = this;

        // check if we have an initially selected node and sync. the tree if so
        if (this.selectedItem){
                this.sync(this.selectedItem.__msh_item);
        }

        //if we're keeping track of state, and we have saved state information
        if(this.config.saveState) {
                //restore to previous node
                var txt = Zapatec.Utils.getCookie("Zapatec.Tree-" + config.saveId)

                if (txt) {
                        this.sync(txt);
                }
        }

        // <PROFILE>
        if (this.config.d_profile) {
                alert("Generated in " + (new Date().getTime() - T1) + " milliseconds\n" +
                      profile.items + " total tree items\n" +
                      profile.trees + " total (sub)trees\n" +
                      profile.icons + " total icons");
        }
        // </PROFILE>
};

Zapatec.Tree.all = {};

Zapatec.Tree.prototype.createTree = function(list, parent, level) {
        // PROFILE
        if (this.config.d_profile){
                ++profile.trees;
        }

        var id = list.id || Zapatec.Utils.generateID("tree.sub");
        var self = this;

        function _makeIt() {
                self.creating_now = true;
                var last_li = null;
                var next_li = null;
                var i = list.firstChild;
        var items = parent.__msh_items = [];

                self.trees[id] = parent;
                parent.__msh_level = level;
                parent.__msh_treeid = id;

                while (i) {
                        if (last_li){
                                last_li.className += " tree-lines-c";
                        }

                        if (i.nodeType != 1){
                                i = i.nextSibling;
                        } else {
                                next_li = Zapatec.Utils.getNextSibling(i, 'li');
                        
                                if (i.tagName.toLowerCase() == 'li') {
                                        last_li = self.createItem(i, parent, next_li, level);
                                
                                        if (last_li) { //false when webmaster creates malformed tree 
                                                items[items.length] = last_li.__msh_item;
                                        }
                                }

                                i = next_li;
                        }
                }

                i = parent.firstChild;
                
                if (i && !level) {
                        i.className = i.className.replace(/ tree-lines-./g, "");
                        i.className += (i === last_li) ? " tree-lines-s" : " tree-lines-t";
                }
                
                if (last_li && (level || last_li !== i)) {
                        last_li.className = last_li.className.replace(/ tree-lines-./g, "");
                        last_li.className += " tree-lines-b";
                }
                
                self.creating_now = false;
        };

        if (this.config.dynamic && level > 0){
                (this.trees[id] = _makeIt);
        } else {
                _makeIt();
        }

        return id;
};

Zapatec.Tree.prototype.createItem = function(li, parent, next_li, level, atStart) {
    // PROFILE
        if (this.config.d_profile){
                ++profile.items;
        }

        if (!li.firstChild){
                return;
        }

        var afterNode = null; 
        if (atStart) { //Optional parameter after the fourth parameter to allow the new created node to be inserted before it, instead of appending to the parent 
                afterNode = atStart; 
        } 

        var
                id = li.id || Zapatec.Utils.generateID("tree.item"),
                item = this.items[id] = ((afterNode == null) ? Zapatec.Utils.createElement("div", parent) : Zapatec.Utils.createElement("div")), //Do not append the new div element to the parent, the new node in the div will be inserted before the 'afterNode'.
                t = Zapatec.Utils.createElement("table", item),
                tb = Zapatec.Utils.createElement("tbody", t),
                tr = Zapatec.Utils.createElement("tr", tb),
                td = Zapatec.Utils.createElement("td", tr),
                is_list,
                tmp,
                i = li.firstChild,
                has_icon = false;

        t.className = "tree-table";
        t.cellSpacing = 0;
        t.cellPadding = 0;
        td.className = "label";
        item.className = li.className + " tree-item";
        item.__msh_item = id;
        item.__msh_tree = this.id;
        item.__msh_parent = parent.__msh_treeid;

        if (afterNode) { //A child node from the same parent is sent in to let the new child node inserted before it. 
                parent.insertBefore(item, afterNode); //New item inserted before the 'afterNode'
        }

        while (i) {
                is_list = i.nodeType == 1 && /^[ou]l$/i.test(i.tagName);

                if (i.nodeType != 1 || !is_list) {
                        if (i.nodeType == 3) {
                                // remove whitespace, it seems to cause layout trouble
                                tmp = i.data.replace(/^\s+/, '');
                                tmp = tmp.replace(/\s+$/, '');
                                li.removeChild(i);

                                if (tmp) {
                                        i = Zapatec.Utils.createElement("span");
                                        i.className = "label";
                                        i.innerHTML = tmp;
                                        i.onclick = Zapatec.Tree.onItemToggle;
                                        td.appendChild(i);
                                }
                        } else if (i.tagName.toLowerCase() == 'img') {
                                this.item_addIcon(item, i);
                                has_icon = true;
                        } else {
                                i.onclick = Zapatec.Tree.onItemToggle;
                                td.appendChild(i);
                        }

                        i = li.firstChild;
                        
                        continue;
                }

                if (is_list) {
                        this.item_addIcon(item, null);

                        var np; 
                        if (afterNode != null) { 
                                np = Zapatec.Utils.createElement("div"); 
                                parent.insertBefore(np, afterNode); //New item inserted before the 'afterNode' 
                        } else { 
                                np = Zapatec.Utils.createElement("div", item.parentNode); 
                        }

                        np.__msh_item = id;
                        np.className = "tree";

                        if (next_li){
                                np.className += " tree-lined";
                        }

                        item.__msh_subtree = this.createTree(i, np, level + 1);

                        if ((this.config.initLevel !== false && this.config.initLevel <= level) ||
                                (this.config.compact && !/(^|\s)expanded(\s|$)/i.test(li.className))
                                || /(^|\s)collapsed(\s|$)/i.test(li.className)
                        ){
                                item.className += " tree-item-collapsed";
                                this.toggleItem(id, false);
                        } else {
                                item.className += " tree-item-expanded";
                        }
                        
                        if (/(^|\s)selected(\s|$)/i.test(li.className)){
                                this.selectedItem = item;
                        }

                        break;
                }
        }

        if (!has_icon){
                this.item_addDefaultIcon(item, this.config.defaultIcons);
        }

        return item;
};

Zapatec.Tree.prototype.makeNode = function(html, type) { 
        if (!type) { 
           type = "li"; //Make it a <LI> node if the type is not specified.      
        } 
        var node = Zapatec.Utils.createElement(type); 
        if (html) {  
                node.innerHTML = html; //Assign the inner html of the node if it is specified. 
        } 
        return node; 
} 
 
Zapatec.Tree.prototype.getParent = function(id, mode) { 
        var parent = null; 
        for (var i in this.trees) { 
            //id sent in may be name of the top tree or one of the tree item's or subtree parent's name  
            if ( (this.trees[i].__msh_treeid == id) || (this.trees[i].__msh_item == id) ) { 
               parent = this.trees[i]; //Get the body of a subtree 
               break; 
            } 
        } 
        //For inserting a new child before the referece child, the reference child should be the tree item,  
        //not the subtree under it (in case it has tree nodes under it). This is because inserting a new child  
        //should be 'before' the subtree (if the tree item has tree nodes under it), not inside or become part of the subtree. 
        if ( (mode != null) && ((mode.toUpperCase() == "I") || (mode.toUpperCase() == "R")) ) {  //At this point, if p not null, then it must be body of the subtree. So, get the tree item (root node of the subtree) instead.  
           //Otherwise id doesn't refer to a subtree. In this case, get the tree item instead. 
           if (parent != null) { //A subtree (not include its root) has been retrieved. That means the insertion or removal operation got to be performed before or at the root of the subtree. This warrants the retrival of the root of the subtree. 
              if (parent.className != this.top_parent.className) //As long as p is not the top parent, get the previous sibling or node of p. The previous sibling will be the root of the subtree. 
                 parent = parent.previousSibling; 
           } else parent = this.items[id.toLowerCase()]; //If no subtree is retrieved, then it must an item node, then get it from array this.items. 
        } 
        if (!parent) { //If the node matching the id still cannot be found, then look into each item under a subtree  
           parent = this.items[id.toLowerCase()]; 
        } 
        return parent;   
} 
 
Zapatec.Tree.prototype.appendChild = function(parent, newChild, atStart) { 
        atStart = (atStart == true); 

    // Abort operation when either parent/child is empty or the child node is 
    //   already added to the tree. 
        if (
                parent == null || 
                newChild == null || 
                typeof(parent) == "undefined" ||
                typeof(newChild) == "undefined" ||
                this.items[newChild.id]
        ){
                return; 
        }     

        var item = null; 

        if(parent.firstChild == null){
                atStart = false;
        }
        
        if (atStart) { //Append new child before first child of the parent 
                item = this.createItem(newChild, parent, parent.firstChild.nextSibling, parent.__msh_level, parent.firstChild); 
        } else { //Append new child after last child of the parent 
                item = this.createItem(newChild, parent, null, parent.__msh_level); 
        } 
         
        // After adding a child, re-draw tree lines that connect the new child to 
        //   the tree. This is necessary because the tree structure has been 
        //   changed due to addition or insertion of a new child node. 
        if (item) { //Child added has no subtree 
                var this_node = null; 
                var next_node = null; 
                var prev_node = null; 
                var subtree   = false; 
                 
                if (atStart) { //Child appended at start of the tree 
                        this_node = parent.childNodes[0]; //Always the first node regardless of whether has a subtree under it 
                        
                        if (item.__msh_subtree==null) { //New child appended has no subtree 
                                next_node = parent.childNodes[1]; //Next node will be the second node - the one after the new child node. 
                        } else { //New child appended has a subtree 
                                next_node = parent.childNodes[2]; //Next node will be the third node - two nodes after the new child node 
                        } 
                } else { //Child appended at end of the tree 
                        //Get the appropriate tree node the new node going to attach to 
                        if (!item.__msh_subtree) { //Child appended has no subtree 
                                this_node = parent.childNodes[parent.childNodes.length-1]; //Last node 

                                if(parent.childNodes.length > 1){
                                        prev_node = parent.childNodes[parent.childNodes.length-2]; 
                                        subtree = (prev_node.className != null && prev_node.className == "tree"); 
                                        
                                        if (subtree) { //prev_node is a not a tree item, it has a subtree 
                                                prev_node.className += " tree-lined"; //Add vertical tree line to the tree 
                                                prev_node = parent.childNodes[parent.childNodes.length-3]; //Get its parent instead  
                                        } 
                                }
                        } else { 
                                this_node = parent.childNodes[parent.childNodes.length-2]; //Second last node 
                                          
                                prev_node = parent.childNodes[parent.childNodes.length-3]; 
                                subtree = (prev_node.className != null && prev_node.className == "tree"); 
                                
                                if (subtree) { //prev_node is a not a tree item, it has a subtree 
                                        prev_node.className += " tree-lined"; //Add vertical tree line to the tree 
                                        prev_node = parent.childNodes[parent.childNodes.length-4]; //Get its parent instead 
                                } 
                        } 
                } 
                 
                //Draw tree lines between the child and the parent 
                if (this_node) { //Make sure the child is in the parent (sub-)tree 
                        this_node.className = this_node.className.replace(/ tree-lines-./g, ""); 
                        
                        if (atStart) { 
                                this_node.className += " tree-lines-t"; 
                                
                                if (next_node) { 
                                        next_node.className = next_node.className.replace(/ tree-lines-./g, ""); 
                                        next_node.className += " tree-lines-c"; 
                                } 
                        } else { 
                                this_node.className += " tree-lines-b"; 

                                if (prev_node) { 
                                        prev_node.className = prev_node.className.replace(/ tree-lines-./g, ""); 
                                          
                                        prev_node.className += " tree-lines-c"; 
                                        
                                        if (subtree) { 
                                                prev_node.className += " tree-lines-c"; 
                                        } 
                                } 
                        } 
                } 

                return item;
        } 
};  
 
Zapatec.Tree.prototype.insertBefore = function(newChild, refChild) { 
        //Abort operation when either newChild/refChild is empty or the child node is already added to the tree..   
        if(
                newChild == null || 
                refChild == null || 
                typeof(newChild) == "undefined" ||
                typeof(refChild) == "undefined" || 
                this.items[newChild.id]
        ){
                return; 
        } 

        var parent = refChild.parentNode; 
        var item = this.createItem(newChild, parent, parent.firstChild.nextSibling, parent.__msh_level, refChild); 
        var nodeBefore = false, nodeAfter = false; 
        var next_node  = null; 
 
        if(item.previousSibling){
                nodeBefore = true; 
        }

        if(item.nextSibling){
                nodeAfter = true;
        }
 
        item.className = item.className.replace(/ tree-lines-./g, ""); 

        if (nodeBefore && nodeAfter){
                item.className += " tree-lines-c";
        } else if (nodeBefore){
                item.className += " tree-lines-b"; 
        } else if (nodeAfter) {
                //Insert new child at the start of the tree. 
                item.className += " tree-lines-t"; 

                //Since the node now after the new child was the first node before, the tree line from it is not connected to the new child. 
                //So it needs to redraw the tree line for the second node (formerly the first node in the tree). 
                if (item.className.indexOf("tree-item-more tree-item")>-1) { //New child has a subtree under it. 
                        next_node = item.nextSibling.nextSibling; //Get the next node at the 'same' level as the new child, skip the new child's subtree. 
                } else { 
                        next_node = item.nextSibling; //Get the next node at the 'same' level. 
                } 

                next_node.className = next_node.className.replace(/ tree-lines-./g, ""); 

                //To find out whether next node has next node after it. 
                if (next_node.className.indexOf("tree-item-more tree-item")>-1) { //Next node has a subtree 
                        if (next_node.nextSibling.nextSibling != null){
                                next_node.className += " tree-lines-c";  
                        } else {
                                next_node.className += " tree-lines-b"; 
                        }
                } else { //Next node is an tree item. 
                        if (next_node.nextSibling != null){
                                next_node.className += " tree-lines-c";  
                        } else {
                                next_node.className += " tree-lines-b"; 
                        }
                } 
        } 
}; 
 
Zapatec.Tree.prototype.removeChild = function(oldChild) { 
        if (
                oldChild == null || 
                typeof(oldChild) == "undefined"
        ){
                //No child to remove 
                return;
        } else if (oldChild.className == this.top_parent.className) {
                //Top root node is not allowed 
                alert("Removing root node not allowed.") 
                return;  
        } 
         
        //Get the child node's parent node 
        var p = oldChild.parentNode; 
         
        //Remove node(s) - check if the old child represents a root node of a subtree. If it does, remove the child nodes in the subtree as well as the root node. 
        //If it does not represents a root node of a subtree, just remove it from the parent it attached to. 
        //Clean up - remove the subtree's id from this.trees or the item node's id from this.items. 
        if (oldChild.__msh_item && oldChild.__msh_tree && oldChild.__msh_parent) { //Make sure all common attributes of root node (of a subtree) or item node are there. 
                var prev_node = oldChild.previousSibling; 
                var next_node = oldChild.nextSibling; 
                var hasPrevNode = false; 
                var hasNextNode = false; 
            
                //Find out if there is a node before the old node at the same tree level. 
                if (prev_node) { 
                        //If the node before the old child is the entire subtree at next level, get the root node of that subtree. 
                        //The root node will be at the same level as the old child. Otherwise, the node before the old child is an item node. 

                        if (prev_node.__msh_treeid) { //The node before the old child is a tree consists of all tree nodes in a subtree. 
                            //Get the root node of that subtree. It should have the same level as the old child. 
                                prev_node = prev_node.previousSibling; 
                        } 

                        hasPrevNode = true; 
                } else { //No child before the old child at the same level. 
                        //Check if the old child has a parent node such as root of a subtree and the parent node is not the top of the tree 
                        if (oldChild.parentNode && oldChild.parentNode.className != this.top_parent.className) {                 
                            //This is needed in order to 'not' change any tree line for the child node(s) under a subtree.  
                                hasPrevNode = true; 
                        } 
                } 
      
                //Find out if there is a node after the old node at the same tree level. 
                if (next_node) { 
                        if (oldChild.__msh_subtree) { //Old child is a subtree. So old node is the root of a subtree. Get the node after the subtree then. 
                            //Get the node after the old node at the same level. 
                                next_node = next_node.nextSibling; 
                                
                                if (next_node) {
                                        //There is a next node at same level as the old node. 
                                        hasNextNode = true; 
                                }
                } else {
                        //Old child is an item node. So old node is an item node, not a subtree. Old node and next node are at the same level. 
                        hasNextNode = true; //There is a next node at same level as the old node. 
                } 
        } //else no next node 
       
        if (oldChild.__msh_subtree) { //Root node of a subtree; has child node(s) under it. 
            //Try to get the whole subtree of the old child node 
                var subtreeNode = oldChild.nextSibling; 
          
                if (subtreeNode && oldChild.__msh_subtree == subtreeNode.__msh_treeid) { //Subtree node exists 
                        for (var i = 0; i < subtreeNode.childNodes.length; i++) { //Loop through each children of the subtree  
                                if (subtreeNode.childNodes[i]){
                                        //and delete the corresponding object in this.items 
                                        delete this.items[subtreeNode.childNodes[i].__msh_item];
                                }
            } 

                        //Remove the corresponding item in this.items for the root of the subtree 
                        delete this.items[subtreeNode.__msh_item]; 

                        //Remove the whole subtree 
                        p.removeChild(subtreeNode); 
                } 
                
                //Remove the corresponding subtree in this.trees 
                delete(this.trees[oldChild.__msh_subtree]); 

                //Remove the child node from its parent
                p.removeChild(oldChild); 
        } else {
                //An item node, not a subtree 
                delete this.items[oldChild.__msh_item]; //Remove the corresponding item in this.items for the item node 
                p.removeChild(oldChild); //Remove the child node from its parent 
        } 

        //Re-draw tree lines nodes/subtrees between removed node if necessary 
        //If there is a previous node and next node between the old node, there is no need to redraw thr tree lines 
        //as the previous and next node will become joined together after the old node is removed. 
        //If 'before' removal of the old node, there is a next node after the old node but no previous node before  
        //the old node, then it needs to redraw the tree line of the next node. The next node thus become the first node of the tree. 
        if (!hasPrevNode && hasNextNode) { 
                if (next_node) { 
                        next_node.className = next_node.className.replace(/ tree-lines-./g, ""); 
                        next_node.className += " tree-lines-t"; 
                } 
        } else if (hasPrevNode && !hasNextNode) { 
                if (prev_node) { 
                        if (prev_node.__msh_subtree) { 
                                prev_node.nextSibling.className = prev_node.nextSibling.className.replace(/ tree-lined/g, ""); 
                        } //else not a subtree  

                        prev_node.className = prev_node.className.replace(/ tree-lines-./g, ""); 
                        prev_node.className += " tree-lines-b"; 
                } 
        }
} 
}; 

Zapatec.Tree.prototype.item_addDefaultIcon = function(item, className) {
        if (!className){
                return;
        }

        var last_td = item.firstChild.firstChild.firstChild.lastChild, td;
        var td = Zapatec.Utils.createElement("td");
        
        td.className = "tgb icon " + className;
        td.onclick = Zapatec.Tree.onItemToggle;
        last_td.parentNode.insertBefore(td, last_td);
};

Zapatec.Tree.prototype.item_addIcon = function(item, img) {
        // PROFILE
        if (this.config.d_profile){
                ++profile.icons;
        }
        
        var last_td = item.firstChild.firstChild.firstChild, td;
        last_td = img ? last_td.lastChild : last_td.firstChild;
        
        if (!img || !item.__msh_icon) {
                td = Zapatec.Utils.createElement("td");
                td.className = "tgb " + (img ? "icon" : "minus");
                last_td.parentNode.insertBefore(td, last_td);
                td.onclick = Zapatec.Tree.onItemToggle;
        } else {
                td = item.__msh_icon;
                img.style.display = "none";
        }
        
        if (!img) {
                td.innerHTML = "&nbsp;";
                item.className += " tree-item-more";
                item.__msh_state = false; // collapsed
                item.__msh_expand = td;
        } else {
                td.appendChild(img);
                item.__msh_icon = td;
        }
};

Zapatec.Tree.prototype.itemClicked = function(item_id, expand) {
        this.selectedItem = this.toggleItem(item_id, null, expand);
        Zapatec.Utils.writeCookie("Zapatec.Tree-" + this.config.saveId, this.selectedItem.__msh_item, null, '/', 7);

        if (this.config.hiliteSelectedNode && this.selectedItem){
                Zapatec.Utils.addClass(this.selectedItem, "tree-item-selected");
        }

        this.onItemSelect(item_id);
};

Zapatec.Tree.prototype.toggleItem = function(item_id, state, expand) {
        if (item_id) {
                var stateDefined = false;

                if(this.config.saveState) {
                        stateDefined = true;
                }

                if (this.config.hiliteSelectedNode && this.selectedItem){
                        Zapatec.Utils.removeClass(this.selectedItem, "tree-item-selected");
                }
                var item = this.items[item_id];

                if (typeof(state) == "undefined" || state == null) {
                        state = !item.__msh_state;
                        stateDefined = false;
                }
                
                // Expand is true when the '+' or '-' are clicked. 
                // If expandOnLabel is true we will expand even when the label is clicked
                // We will also expand when the state is explictally passed 

                if (
                        (expand || this.config.expandOnLabel || stateDefined)
                ){
                        var subtree = this._getTree(item.__msh_subtree, this.creating_now);

                        if (subtree) {
                                subtree.style.display = state ? "block" : "none";
                                Zapatec.Utils.removeClass(item, "tree-item-expanded");
                                Zapatec.Utils.removeClass(item, "tree-item-collapsed");
                                Zapatec.Utils.addClass(item, state ?
                                        "tree-item-expanded" : "tree-item-collapsed");
                        }

                        var img = item.__msh_expand;

                        if (img){
                                img.className = "tgb " + (state ? "minus" : "plus");
                        }

                        item.__msh_state = state;
                        img = item.__msh_icon;

                        if (img) {
                                img.firstChild.style.display = "none";
                                img.appendChild(img.firstChild);
                                img.firstChild.style.display = "block";
                        }

                        if (this.config.compact && state) {
                                var a = this._getTree(item.__msh_parent).__msh_items;
                                for (var i = a.length; --i >= 0;)
                                        if (a[i] != item_id)
                                                this.toggleItem(a[i], false);
                        }

                        if(/zpLoad(JSON|HTML)=([^ $]*)/.test(item.className) && state){
                                var dataType = RegExp.$1;
                                var url = RegExp.$2;

                                item.className = item.className.replace(/zpLoad(JSON|HTML)=([^ $]*)/g, "");
                                var loadingLabel = this.appendChild(this.getParent(item.__msh_item), this.makeNode("...loading..."), true);
                                var errorFunc = function (objError){
                                        alert(objError.errorDescription);
                                        item.className += "zpLoad" + dataType + "=" + url;

                                        self.removeChild(self.getParent(loadingLabel.__msh_item, "R"));
                                }

                                var self = this;

                                if(dataType == "JSON"){
                                        Zapatec.Transport.fetchJsonObj({
                                                url: url,
                                                method: "GET",
                                                onLoad: function(objResponse){
                                                        function json2html(json){
                                                                if(json == null || json.length == 0){
                                                                        return "";
                                                                }

                                                                var res = "<ul>";

                                                                for(var ii = 0; ii < json.length; ii++){
                                                                        var currVal = json[ii];

                                                                        if(typeof(currVal) == "string"){
                                                                                currVal = [currVal];
                                                                        }

                                                                        res += "<li>" + currVal[0] + json2html(currVal[1]) + "</li>"
                                                                }

                                                                res += "</ul>";

                                                                return res
                                                        }

                                                        var arr = objResponse;

                                                        for(var ii =0; ii < arr.length; ii++){
                                                                var currVal = arr[ii];

                                                                if(typeof(currVal) == "object" && currVal.length == 1){
                                                                        currVal = currVal[0];
                                                                } else if (typeof(currVal) == "object" && currVal.length == 2){
                                                                        currVal = currVal[0] + json2html(currVal[1]);
                                                                }
                                                                self.appendChild(self.getParent(item.__msh_item), self.makeNode(currVal));
                                                        }

                                                        self.removeChild(self.getParent(loadingLabel.__msh_item, "R"));
                                                },
                                                onError : errorFunc
                                        });
                                } else if(dataType == "HTML"){
                                        Zapatec.Transport.fetchXmlDoc({
                                                url: url,
                                                method: "GET",
                                                onLoad: function(xmlDoc){
                                                        var cNodes = xmlDoc.documentElement.childNodes;

                                                        for(var jj = 0; jj < cNodes.length; jj++){
                                                                var currentNode = cNodes[jj];

                                                                if(currentNode.nodeType != 1){
                                                                        continue;
                                                                }

                                                                var li = self.makeNode(Zapatec.Tree.serializeNode(currentNode, true));

                                                                for (var ii = 0; ii < currentNode.attributes.length; ii++){
                                                                        var attr = currentNode.attributes[ii];
                                                                        if(attr.name == 'class'){
                                                                                li.className = currentNode.getAttribute(attr.name);
                                                                        } else {
                                                                                li.setAttribute(attr.name, currentNode.getAttribute(attr.name));
                                                                        }
                                                                }

                                                                self.appendChild(self.getParent(item.__msh_item), li);
                                                        }

                                                        self.removeChild(self.getParent(loadingLabel.__msh_item, "R"));
                                                },
                                                onError : errorFunc
                                        });
                                }
                        }
                }

                return item;
        }

        return null;
};

Zapatec.Tree.prototype.collapseAll = function() {
        for (var i in this.trees){
                this.toggleItem(this._getTree(i).__msh_item, false, true);
        }
};

Zapatec.Tree.prototype.expandAll = function() {
        for (var i in this.trees) {
                this.toggleItem(this._getTree(i).__msh_item, true, true);
        }
};

Zapatec.Tree.prototype.toggleAll = function() {
        for (var i in this.trees) {
                this.toggleItem(this._getTree(i).__msh_item);
        }
};

Zapatec.Tree.prototype.sync = function(item_id) {
        var item = this.items[item_id];
        
        if (item) {
                this.collapseAll();
                this.selectedItem = item;
                var a = [];
        
                while (item.__msh_parent) {
                        a[a.length] = item;
                        var pt = this._getTree(item.__msh_parent);
                
                        if (pt.__msh_item){
                                item = this.items[pt.__msh_item];
                        } else {
                                break;
                        }
                }

                for (var i = a.length; --i >= 0;){
                        this.toggleItem(a[i].__msh_item, true);
                }

                Zapatec.Utils.addClass(this.selectedItem, "tree-item-selected");
        }
};

Zapatec.Tree.prototype.destroy = function() {
        var p = this.top_parent;
        p.parentNode.removeChild(p);
};

Zapatec.Tree.prototype._getTree = function(tree_id, dont_call) {
        var tree = this.trees[tree_id];

        if (typeof(tree) == "function") {
                if (dont_call){
                        tree = null;
                } else {
                        tree();
                        tree = this.trees[tree_id];
                        tree.__msh_state = false;
                }
        }

        return tree;
};

// CUSTOMIZABLE EVENT HANDLERS; default action is "do nothing"

Zapatec.Tree.prototype.onItemSelect = function() {};

// GLOBAL EVENT HANDLERS (to workaround the stupid Microsoft memory leak)

Zapatec.Tree.onItemToggle = function() {
        var item = this;
        var body = document.body;
        var expand = false;

        if(/tgb (minus|plus)/.test(this.className)) {
                expand = true;
        }
        
        while (item && item !== body && !/tree-item/.test(item.className)){
                item = item.parentNode;
        }

        Zapatec.Tree.all[item.__msh_tree].itemClicked(item.__msh_item, expand);
};

Zapatec.Tree.serializeNode = function(currentNode, omitTopLevel){
        if(currentNode == null){
                return;
        }

        if(currentNode.nodeType == 3){ // text node
                return currentNode.nodeValue;
        }

        if(omitTopLevel){
                var res = "";

                if(currentNode.hasChildNodes()){
                        for(var ii = 0; ii < currentNode.childNodes.length; ii++){
                                res += Zapatec.Tree.serializeNode(currentNode.childNodes[ii]);
                        }
                }
        } else {
                var res = "<" + currentNode.tagName;
                
                for (var ii = 0; ii < currentNode.attributes.length; ii++){
                        var attr = currentNode.attributes[ii];
                        res += " " + attr.name + "=\"" + currentNode.getAttribute(attr.name).replace(/"/g, '\\"') +  "\"";
                }
            
                if(currentNode.hasChildNodes()){
                        res += ">";
            
                        for(var ii = 0; ii < currentNode.childNodes.length; ii++){
                                res += Zapatec.Tree.serializeNode(currentNode.childNodes[ii]);
                        }
            
                        res += "</" + currentNode.tagName + ">"
                } else {
                        res += "/>"
                }
        }
            
        return res;
}

Contact Us | Employment

© 2004 Zapatec, Inc.