trunk/src/modules/sitetree/resources/javascript/tree.js - lenya - Git at Google

 /*****************************************************************************
  *
  * Copyright (c) 2004 Guido Wesdorp. All rights reserved.
  *
  * This software is distributed under the terms of the tree.js
  * License. See LICENSE.txt for license text.
  *
  *  E-mail: johnny@debris.demon.nl
  *
  *****************************************************************************/

 /*
 Copyright (c) 2004, Guido Wesdorp
 All rights reserved.

 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
 met:


     * Redistributions of source code must retain the above copyright
       notice, this list of conditions and the following disclaimer.

     * Redistributions in binary form must reproduce the above
       copyright notice, this list of conditions and the following
       disclaimer in the documentation and/or other materials provided
       with the distribution.

     * Neither the name of tree.js nor the names of its contributors may
       be used to endorse or promote products derived from this
       software without specific prior written permission.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

 function Node(id, parent) {
     this.id = id;
     this.parent = parent;
     // this is just here for show, will be overwritten in init()
     this.items = {};
 };

 Node.prototype.init = function() {
     this.depth = this.parent.depth + 1;
     this.tree = this.parent.tree;
     this.reopen = false;
     this.items = {};
 };

 Node.prototype.open = function(reload, endhandler) {
     if (!this.isCollection()) {
         if (reload) {
             this.reloadSingle();
         };
         return;
     };
     if (!reload && this.opened) {
         return;
     };
     this.opened = true;
     var newopensign = this.tree.getOpenSign(this);
     this.opensign.parentNode.replaceChild(newopensign, this.opensign);
     this.opensign = newopensign;
     addEventHandler(this.opensign, 'click', this.tree.handleItemSignClick,
                     this.tree, this);
     if (!this.itemids || this.itemids.length==0) {
         // get the items, getItems() should be defined on the subclass
         this.tree.doc.getElementsByTagName('body')[0].style.cursor = 'wait';
         this.element.className = this.element.className;
         this.tree.getItems(this, this._continueOpen, !reload, endhandler);
     } else {

         for (var itemid in this.items) {
             var item = this.items[itemid];
             item.render();
             if (item.reopen) {
                 item.open();
             };
         };
         if (endhandler) {
             endhandler();
         };
     };
 };

 Node.prototype._continueOpen = function(items, endhandler) {
     this.items = {};
     this.itemids = [];
     for (var i = items.length - 1; i >= 0; i--) {
         var item = items[i];
         this.items[item.id] = item;
         this.itemids.unshift(item.id);
         item.render();
         if (item.reopen) {
             item.open();
         };
     };

     this.tree.doc.getElementsByTagName('body')[0].style.cursor = 'default';
     if (endhandler) {
         endhandler();
     };
 };

 Node.prototype.reloadSingle = function() {
     /* called on opening a non-collection item with a reload arg

         can be overridden in subclasses
     */
 };

 Node.prototype.close = function(reopen_when_opening_parent) {
     if (!this.opened || !this.isCollection()) {
         return;
     };
     this.reopen = reopen_when_opening_parent;
     var newopensign = this.tree.getCloseSign(this);
     this.opensign.parentNode.replaceChild(newopensign, this.opensign);
     this.opensign = newopensign;
     this.opened = false;
     addEventHandler(this.opensign, 'click', this.tree.handleItemSignClick,
                     this.tree, this);
     for (var itemid in this.items) {
         var item = this.items[itemid];
         item.close(true);
         this.tree.unrenderItem(item);
     };
 };

 Node.prototype.reload = function() {
     this.itemids = null;
     var currel = this.element;
     this.element = this.tree.createItemHtml(this);
     currel.parentNode.replaceChild(this.element, currel);
     if (this.opened) {
         this.close();
         this.open(true);
     };
 };

 Node.prototype.render = function() {
     this.tree.renderItem(this);
 };

 Node.prototype.isCollection = function() {
     return true;
 };

 Node.prototype.getPath = function() {
     var parentpath;
     if (this.parent) {
         parentpath = this.parent.getPath();
     } else {
         parentpath =  '';
     }
     return parentpath + '/' + this.id;
 };

 Node.prototype.setSelectClass = function() {
     if (this.element) {
         this.element.className = 'selected_node';
     };
 };

 Node.prototype.unsetSelectClass = function() {
     if (this.element) {
         this.element.className = 'unselected_node';
     };
 };

 Node.prototype.getItemByPath = function(path) {
     /* return an item by its path

         path should be relative from the current item, excluding
         the current item's id
     */
     var item = null;
     for (var itemid in this.items) {
         // see if the path starts with the next item id
         if (path.indexOf(itemid + '/') == 0 || path == itemid) {
             item = this.items[itemid];
             break;
         };
     };
     if (!item) {
         return false;
     };
     if (path == item.id) {
         return item;
     } else {
         return item.getItemByPath(path.substr(item.id.length+1));
     };
     return false;
 };

 function Tree(doc, treeElement) {
     this.doc = doc;
     this.treeElement = treeElement;
     this.selected = null;
 };

 Tree.prototype.init = function(id) {
     this.root = new Node(id);
     this.root.tree = this;
     this.root.depth = 0;
     this.root.reopen = false;
     this._currentId = 0;
     // addEventHandler(this.doc, 'contextmenu',
     //        this.createContextMenu, this);
     //addEventHandler(this.doc, 'mouseup', this.removeContextMenu, this);
 };

 Tree.prototype.getItems = function(item, handler, reload, endhandler) {
     /* this should be overridden in subclasses */
     var items = [];
     var ids = ['foo', 'bar', 'baz'];
     for (var i=0; i < ids.length; i++) {
         var child = new Node(ids[i], item);
         child.init();
         items.push(child);
     };
     handler.call(item, items, endhandler);
 };

 Tree.prototype.render = function() {
     var element = this.createItemHtml(this.root);
     this.root.element = element;
     element.tree_item = this.root;
     this.doc.getElementsByTagName('body')[0].style.cursor = 'default';
     this.treeElement.appendChild(element);
 };

 Tree.prototype.renderItem = function(item) {
     var element = this.createItemHtml(item);
     this.doc.getElementsByTagName('body')[0].style.cursor = 'default';
     item.element = element;
     element.tree_item = item;
     if (item.parent.element.nextSibling) {
         item.parent.element.parentNode.insertBefore(item.element,
                                     item.parent.element.nextSibling);
     } else {
         item.parent.element.parentNode.appendChild(item.element);
     };
 };

 Tree.prototype.createItemHtml = function(item) {
     /* you may want to override this */
     var div = this.doc.createElement('div');
     div.style.whiteSpace = 'nowrap';
     div.className = 'treenode';

     // place a reference to the item on the div
     div.treeitem = item;

     var space = '';
     for (var i=0; i < item.depth; i++) {
         space += '\xa0\xa0\xa0';
     };
     var text = this.doc.createTextNode(space);
     div.appendChild(text);

     item.opensign = this.getCloseSign(item);
     item.opensign.className = 'treenode_opensign';
     div.appendChild(item.opensign);

     // the actual icon and name are generated from another method
     // to improve extending
     var line = this.createItemLine(item);
     div.appendChild(line);

     addEventHandler(line, 'click', this.handleItemClick, this, item);
     addEventHandler(item.opensign, 'click', this.handleItemSignClick,
                     this, item);

     if (this.selected == item.getPath()) {
         this.unselect();
         this.select(item);
         div.className = 'selected_node';
     };

     return div;
 };

 Tree.prototype.createItemLine = function(item) {
     var div = this.doc.createElement('div');
     /* creates the item name and any icons and such */
     var span = this.doc.createElement('span');
     var icon = this.getIcon(item);
     if (icon.nodeType == 1) {
         icon.className = 'treenode_icon';
     };
     div.appendChild(icon);

     var text = this.doc.createTextNode(item.name ? item.name : item.id);
     span.className = 'treenode_label';
     span.appendChild(text);
     div.appendChild(span);

     return div;
 };

 Tree.prototype.unrenderItem = function(item) {
     if (item.element) {
         item.element.parentNode.removeChild(item.element);
         delete item.element;
     };
 };

 Tree.prototype.handleItemClick = function(item, event) {
     if (item.skip_next_click) {
         item.skip_next_click = false;
         return;
     };
     this.select(item);
     if (!item.opened) {
         item.open();
     } else {
         item.close();
     };
     if (item.element && item.element.scrollIntoView) {
         item.element.scrollIntoView();
     };
 };

 Tree.prototype.select = function(item) {
     this.unselect();
     this.selected = item.getPath();
     item.setSelectClass();
 };

 Tree.prototype.unselect = function() {
     if (typeof(this.selected) == 'string') {
         var item = this.getItemByPath(this.selected);
         item.unsetSelectClass();
     };
 };

 Tree.prototype.handleItemSignClick = function(item, event) {
     if (!item.opened) {
         item.open();
     } else {
         item.close();
     };
     if (event.preventDefault) {
         event.preventDefault();
     } else {
         event.returnValue = false;
     };
 };

 Tree.prototype.createUniqueId = function() {
     this._currentId++;
     return this._currentId.toString();
 };

 Tree.prototype.createContextMenu = function(event) {
     var clickel = event.target;
     var item = clickel.tree_item;
     if (!item) {
         return;
     };
     if (!this.contextmenu) {
         var contextels = this.getContextMenuElements();
         this.renderContextMenu(item, contextels, event);
     };
     if (event.preventDefault) {
         event.preventDefault();
     } else {
         event.returnValue = false;
     };
     return false;
 };

 Tree.prototype.getContextMenuElements = function() {
     /* you will probably want to override this

         this should return a mapping (object) from context menu
         entry (string) to the name of a method on the Node object
         (also a string), the method will be called when the element
         is clicked
     */
     return {'open': 'open',
             'close': 'close'};
 };

 Tree.prototype.renderContextMenu = function(item, elements, event) {
     /* you may want to override this

         item is the item clicked on
         elements should be a mapping from menu element (string) to
         the name of a method located on the clicked Node

     */
     var menu = this.doc.createElement('div');
     menu.style.position = 'absolute';
     menu.className = 'contextmenu';
     addEventHandler(menu, 'click', this.removeContextMenu, this);
     for (var el in elements) {
         var div = this.doc.createElement('div');
         var text = this.doc.createTextNode(el);
         div.appendChild(text);
         addEventHandler(div, 'click', item[elements[el]], item);
         menu.appendChild(div);
     };
     this._positionMenu(event, menu);
     this.doc.getElementsByTagName('body')[0].appendChild(menu);
     this.contextmenu = menu;
 };

 Tree.prototype.removeContextMenu = function() {
     if (!this.contextmenu) {
         return;
     };
     this.contextmenu.parentNode.removeChild(this.contextmenu);
     delete this.contextmenu;
 };

 Tree.prototype.getCloseSign = function(item) {
     /* get the open sign for a collection or resource */
     var opensign = this.doc.createElement('img');
     if (item.isCollection()) {
         opensign.setAttribute('src', 'images/closed-collection.png');
     } else {
         opensign.setAttribute('src', 'images/non-collection.png');
     };
     return opensign;
 };

 Tree.prototype.getOpenSign = function(item) {
     /* get the close sign for a collection */
     var opensign = this.doc.createElement('img');
     opensign.setAttribute('src', 'images/opened-collection.png');
     return opensign;
 };

 Tree.prototype.getIcon = function(item) {
     /* return an img object that represents the file type */
     return this.doc.createTextNode('\xa0');
 };

 //Root.prototype.getPath = function() {
 //    return '/' + this.id;  // FIXME
 //};

 Tree.prototype._positionMenu = function(event, menu) {
     var left = event.layerX;
     var top = event.layerY;
     menu.style.left = left + 'px';
     menu.style.top = top + 'px';
 };

 Tree.prototype.getItemByPath = function(path) {
     /* return an item by its path

         path should be relative from the current item, excluding
         the current item's id
     */
     // if the path starts with a slash, remove it
     if (path.charAt(0) == '/') {
         path = path.substr(1);
     };
     if (path == this.root.id) {
         return this.root;
     }
     if (path.indexOf(this.root.id) == 0) {
         path = path.substr(this.root.id.length+1);
         return this.root.getItemByPath(path);
     } else {
         return false;
     }
 };

 // Copied from helpers.js to not have a dependency
 function ContextFixer(func, context) {
     /* Make sure 'this' inside a method points to its class */
     this.func = func;
     this.context = context;
     this.args = arguments;
     var self = this;

     this.execute = function() {
         /* execute the method */
         var args = new Array();
         // the first arguments will be the extra ones of the class
         for (var i=0; i < self.args.length - 2; i++) {
             args.push(self.args[i + 2]);
         };
         // the last are the ones passed on to the execute method
         for (var i=0; i < arguments.length; i++) {
             args.push(arguments[i]);
         };
         return self.func.apply(self.context, args);
     };
 };

 // this is used to make sure that all registered event handlers get a unique
 // id, this id will be returned by addEventHandler and can be used to remove
 // the event handler later on
 // of course you *must never* change this id!
 LAST_HANDLER_ID = 0;

 // a mapping from id to handler (required because the handlers are wrapped
 // before they're registered, and the mapped version is not available to the
 // client, while it is required for de-registering the event later on
 // needless to say this should never be touched...
 ID_TO_HANDLER = {};

 function addEventHandler(element, event, method, context) {
     /* method to add an event handler for both IE and Mozilla */
     var wrappedmethod = new ContextFixer(method, context);

     // store it, return the id, that can be used to de-register the
     // handler later on
     var id = LAST_HANDLER_ID++;
     ID_TO_HANDLER[id] = wrappedmethod;

     var args = new Array(null, null);
     for (var i=4; i < arguments.length; i++) {
         args.push(arguments[i]);
     };
     wrappedmethod.args = args;
     try {
         if (element.addEventListener) {
             element.addEventListener(event, wrappedmethod.execute, false);
         } else if (element.attachEvent) {
             element.attachEvent("on" + event, wrappedmethod.execute);
         } else {
             throw "Unsupported browser!";
         };
     } catch(e) {
         alert('exception ' + e.message + ' while registering an event handler for element ' + element + ', event ' + event + ', method ' + method);
     };

     return id;
 };

 function removeEventHandler(element, event, id) {
     /* method to remove an event handler for both IE and Mozilla */
     var method = ID_TO_HANDLER[id].execute;
     if (element.removeEventListener) {
         element.removeEventListener(event, method, false);
     } else if (element.detachEvent) {
         element.detachEvent("on" + event, method);
     } else {
         throw "Unsupported browser!";
     };
 };

 String.prototype.strip = function() {
     var stripspace = /^\s*([\s\S]*?)\s*$/;
     return stripspace.exec(this)[1];
 };
	/*****************************************************************************
	*
	* Copyright (c) 2004 Guido Wesdorp. All rights reserved.
	*
	* This software is distributed under the terms of the tree.js
	* License. See LICENSE.txt for license text.
	*
	* E-mail: johnny@debris.demon.nl
	*
	*****************************************************************************/

	/*
	Copyright (c) 2004, Guido Wesdorp
	All rights reserved.

	Redistribution and use in source and binary forms, with or without
	modification, are permitted provided that the following conditions are
	met:


	* Redistributions of source code must retain the above copyright
	notice, this list of conditions and the following disclaimer.

	* Redistributions in binary form must reproduce the above
	copyright notice, this list of conditions and the following
	disclaimer in the documentation and/or other materials provided
	with the distribution.

	* Neither the name of tree.js nor the names of its contributors may
	be used to endorse or promote products derived from this
	software without specific prior written permission.

	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	function Node(id, parent) {
	this.id = id;
	this.parent = parent;
	// this is just here for show, will be overwritten in init()
	this.items = {};
	};

	Node.prototype.init = function() {
	this.depth = this.parent.depth + 1;
	this.tree = this.parent.tree;
	this.reopen = false;
	this.items = {};
	};

	Node.prototype.open = function(reload, endhandler) {
	if (!this.isCollection()) {
	if (reload) {
	this.reloadSingle();
	};
	return;
	};
	if (!reload && this.opened) {
	return;
	};
	this.opened = true;
	var newopensign = this.tree.getOpenSign(this);
	this.opensign.parentNode.replaceChild(newopensign, this.opensign);
	this.opensign = newopensign;
	addEventHandler(this.opensign, 'click', this.tree.handleItemSignClick,
	this.tree, this);
	if (!this.itemids \|\| this.itemids.length==0) {
	// get the items, getItems() should be defined on the subclass
	this.tree.doc.getElementsByTagName('body')[0].style.cursor = 'wait';
	this.element.className = this.element.className;
	this.tree.getItems(this, this._continueOpen, !reload, endhandler);
	} else {

	for (var itemid in this.items) {
	var item = this.items[itemid];
	item.render();
	if (item.reopen) {
	item.open();
	};
	};
	if (endhandler) {
	endhandler();
	};
	};
	};

	Node.prototype._continueOpen = function(items, endhandler) {
	this.items = {};
	this.itemids = [];
	for (var i = items.length - 1; i >= 0; i--) {
	var item = items[i];
	this.items[item.id] = item;
	this.itemids.unshift(item.id);
	item.render();
	if (item.reopen) {
	item.open();
	};
	};

	this.tree.doc.getElementsByTagName('body')[0].style.cursor = 'default';
	if (endhandler) {
	endhandler();
	};
	};

	Node.prototype.reloadSingle = function() {
	/* called on opening a non-collection item with a reload arg

	can be overridden in subclasses
	*/
	};

	Node.prototype.close = function(reopen_when_opening_parent) {
	if (!this.opened \|\| !this.isCollection()) {
	return;
	};
	this.reopen = reopen_when_opening_parent;
	var newopensign = this.tree.getCloseSign(this);
	this.opensign.parentNode.replaceChild(newopensign, this.opensign);
	this.opensign = newopensign;
	this.opened = false;
	addEventHandler(this.opensign, 'click', this.tree.handleItemSignClick,
	this.tree, this);
	for (var itemid in this.items) {
	var item = this.items[itemid];
	item.close(true);
	this.tree.unrenderItem(item);
	};
	};

	Node.prototype.reload = function() {
	this.itemids = null;
	var currel = this.element;
	this.element = this.tree.createItemHtml(this);
	currel.parentNode.replaceChild(this.element, currel);
	if (this.opened) {
	this.close();
	this.open(true);
	};
	};

	Node.prototype.render = function() {
	this.tree.renderItem(this);
	};

	Node.prototype.isCollection = function() {
	return true;
	};

	Node.prototype.getPath = function() {
	var parentpath;
	if (this.parent) {
	parentpath = this.parent.getPath();
	} else {
	parentpath = '';
	}
	return parentpath + '/' + this.id;
	};

	Node.prototype.setSelectClass = function() {
	if (this.element) {
	this.element.className = 'selected_node';
	};
	};

	Node.prototype.unsetSelectClass = function() {
	if (this.element) {
	this.element.className = 'unselected_node';
	};
	};

	Node.prototype.getItemByPath = function(path) {
	/* return an item by its path

	path should be relative from the current item, excluding
	the current item's id
	*/
	var item = null;
	for (var itemid in this.items) {
	// see if the path starts with the next item id
	if (path.indexOf(itemid + '/') == 0 \|\| path == itemid) {
	item = this.items[itemid];
	break;
	};
	};
	if (!item) {
	return false;
	};
	if (path == item.id) {
	return item;
	} else {
	return item.getItemByPath(path.substr(item.id.length+1));
	};
	return false;
	};

	function Tree(doc, treeElement) {
	this.doc = doc;
	this.treeElement = treeElement;
	this.selected = null;
	};

	Tree.prototype.init = function(id) {
	this.root = new Node(id);
	this.root.tree = this;
	this.root.depth = 0;
	this.root.reopen = false;
	this._currentId = 0;
	// addEventHandler(this.doc, 'contextmenu',
	// this.createContextMenu, this);
	//addEventHandler(this.doc, 'mouseup', this.removeContextMenu, this);
	};

	Tree.prototype.getItems = function(item, handler, reload, endhandler) {
	/* this should be overridden in subclasses */
	var items = [];
	var ids = ['foo', 'bar', 'baz'];
	for (var i=0; i < ids.length; i++) {
	var child = new Node(ids[i], item);
	child.init();
	items.push(child);
	};
	handler.call(item, items, endhandler);
	};

	Tree.prototype.render = function() {
	var element = this.createItemHtml(this.root);
	this.root.element = element;
	element.tree_item = this.root;
	this.doc.getElementsByTagName('body')[0].style.cursor = 'default';
	this.treeElement.appendChild(element);
	};

	Tree.prototype.renderItem = function(item) {
	var element = this.createItemHtml(item);
	this.doc.getElementsByTagName('body')[0].style.cursor = 'default';
	item.element = element;
	element.tree_item = item;
	if (item.parent.element.nextSibling) {
	item.parent.element.parentNode.insertBefore(item.element,
	item.parent.element.nextSibling);
	} else {
	item.parent.element.parentNode.appendChild(item.element);
	};
	};

	Tree.prototype.createItemHtml = function(item) {
	/* you may want to override this */
	var div = this.doc.createElement('div');
	div.style.whiteSpace = 'nowrap';
	div.className = 'treenode';

	// place a reference to the item on the div
	div.treeitem = item;

	var space = '';
	for (var i=0; i < item.depth; i++) {
	space += '\xa0\xa0\xa0';
	};
	var text = this.doc.createTextNode(space);
	div.appendChild(text);

	item.opensign = this.getCloseSign(item);
	item.opensign.className = 'treenode_opensign';
	div.appendChild(item.opensign);

	// the actual icon and name are generated from another method
	// to improve extending
	var line = this.createItemLine(item);
	div.appendChild(line);

	addEventHandler(line, 'click', this.handleItemClick, this, item);
	addEventHandler(item.opensign, 'click', this.handleItemSignClick,
	this, item);

	if (this.selected == item.getPath()) {
	this.unselect();
	this.select(item);
	div.className = 'selected_node';
	};

	return div;
	};

	Tree.prototype.createItemLine = function(item) {
	var div = this.doc.createElement('div');
	/* creates the item name and any icons and such */
	var span = this.doc.createElement('span');
	var icon = this.getIcon(item);
	if (icon.nodeType == 1) {
	icon.className = 'treenode_icon';
	};
	div.appendChild(icon);

	var text = this.doc.createTextNode(item.name ? item.name : item.id);
	span.className = 'treenode_label';
	span.appendChild(text);
	div.appendChild(span);

	return div;
	};

	Tree.prototype.unrenderItem = function(item) {
	if (item.element) {
	item.element.parentNode.removeChild(item.element);
	delete item.element;
	};
	};

	Tree.prototype.handleItemClick = function(item, event) {
	if (item.skip_next_click) {
	item.skip_next_click = false;
	return;
	};
	this.select(item);
	if (!item.opened) {
	item.open();
	} else {
	item.close();
	};
	if (item.element && item.element.scrollIntoView) {
	item.element.scrollIntoView();
	};
	};

	Tree.prototype.select = function(item) {
	this.unselect();
	this.selected = item.getPath();
	item.setSelectClass();
	};

	Tree.prototype.unselect = function() {
	if (typeof(this.selected) == 'string') {
	var item = this.getItemByPath(this.selected);
	item.unsetSelectClass();
	};
	};

	Tree.prototype.handleItemSignClick = function(item, event) {
	if (!item.opened) {
	item.open();
	} else {
	item.close();
	};
	if (event.preventDefault) {
	event.preventDefault();
	} else {
	event.returnValue = false;
	};
	};

	Tree.prototype.createUniqueId = function() {
	this._currentId++;
	return this._currentId.toString();
	};

	Tree.prototype.createContextMenu = function(event) {
	var clickel = event.target;
	var item = clickel.tree_item;
	if (!item) {
	return;
	};
	if (!this.contextmenu) {
	var contextels = this.getContextMenuElements();
	this.renderContextMenu(item, contextels, event);
	};
	if (event.preventDefault) {
	event.preventDefault();
	} else {
	event.returnValue = false;
	};
	return false;
	};

	Tree.prototype.getContextMenuElements = function() {
	/* you will probably want to override this

	this should return a mapping (object) from context menu
	entry (string) to the name of a method on the Node object
	(also a string), the method will be called when the element
	is clicked
	*/
	return {'open': 'open',
	'close': 'close'};
	};

	Tree.prototype.renderContextMenu = function(item, elements, event) {
	/* you may want to override this

	item is the item clicked on
	elements should be a mapping from menu element (string) to
	the name of a method located on the clicked Node

	*/
	var menu = this.doc.createElement('div');
	menu.style.position = 'absolute';
	menu.className = 'contextmenu';
	addEventHandler(menu, 'click', this.removeContextMenu, this);
	for (var el in elements) {
	var div = this.doc.createElement('div');
	var text = this.doc.createTextNode(el);
	div.appendChild(text);
	addEventHandler(div, 'click', item[elements[el]], item);
	menu.appendChild(div);
	};
	this._positionMenu(event, menu);
	this.doc.getElementsByTagName('body')[0].appendChild(menu);
	this.contextmenu = menu;
	};

	Tree.prototype.removeContextMenu = function() {
	if (!this.contextmenu) {
	return;
	};
	this.contextmenu.parentNode.removeChild(this.contextmenu);
	delete this.contextmenu;
	};

	Tree.prototype.getCloseSign = function(item) {
	/* get the open sign for a collection or resource */
	var opensign = this.doc.createElement('img');
	if (item.isCollection()) {
	opensign.setAttribute('src', 'images/closed-collection.png');
	} else {
	opensign.setAttribute('src', 'images/non-collection.png');
	};
	return opensign;
	};

	Tree.prototype.getOpenSign = function(item) {
	/* get the close sign for a collection */
	var opensign = this.doc.createElement('img');
	opensign.setAttribute('src', 'images/opened-collection.png');
	return opensign;
	};

	Tree.prototype.getIcon = function(item) {
	/* return an img object that represents the file type */
	return this.doc.createTextNode('\xa0');
	};

	//Root.prototype.getPath = function() {
	// return '/' + this.id; // FIXME
	//};

	Tree.prototype._positionMenu = function(event, menu) {
	var left = event.layerX;
	var top = event.layerY;
	menu.style.left = left + 'px';
	menu.style.top = top + 'px';
	};

	Tree.prototype.getItemByPath = function(path) {
	/* return an item by its path

	path should be relative from the current item, excluding
	the current item's id
	*/
	// if the path starts with a slash, remove it
	if (path.charAt(0) == '/') {
	path = path.substr(1);
	};
	if (path == this.root.id) {
	return this.root;
	}
	if (path.indexOf(this.root.id) == 0) {
	path = path.substr(this.root.id.length+1);
	return this.root.getItemByPath(path);
	} else {
	return false;
	}
	};

	// Copied from helpers.js to not have a dependency
	function ContextFixer(func, context) {
	/* Make sure 'this' inside a method points to its class */
	this.func = func;
	this.context = context;
	this.args = arguments;
	var self = this;

	this.execute = function() {
	/* execute the method */
	var args = new Array();
	// the first arguments will be the extra ones of the class
	for (var i=0; i < self.args.length - 2; i++) {
	args.push(self.args[i + 2]);
	};
	// the last are the ones passed on to the execute method
	for (var i=0; i < arguments.length; i++) {
	args.push(arguments[i]);
	};
	return self.func.apply(self.context, args);
	};
	};

	// this is used to make sure that all registered event handlers get a unique
	// id, this id will be returned by addEventHandler and can be used to remove
	// the event handler later on
	// of course you must never change this id!
	LAST_HANDLER_ID = 0;

	// a mapping from id to handler (required because the handlers are wrapped
	// before they're registered, and the mapped version is not available to the
	// client, while it is required for de-registering the event later on
	// needless to say this should never be touched...
	ID_TO_HANDLER = {};

	function addEventHandler(element, event, method, context) {
	/* method to add an event handler for both IE and Mozilla */
	var wrappedmethod = new ContextFixer(method, context);

	// store it, return the id, that can be used to de-register the
	// handler later on
	var id = LAST_HANDLER_ID++;
	ID_TO_HANDLER[id] = wrappedmethod;

	var args = new Array(null, null);
	for (var i=4; i < arguments.length; i++) {
	args.push(arguments[i]);
	};
	wrappedmethod.args = args;
	try {
	if (element.addEventListener) {
	element.addEventListener(event, wrappedmethod.execute, false);
	} else if (element.attachEvent) {
	element.attachEvent("on" + event, wrappedmethod.execute);
	} else {
	throw "Unsupported browser!";
	};
	} catch(e) {
	alert('exception ' + e.message + ' while registering an event handler for element ' + element + ', event ' + event + ', method ' + method);
	};

	return id;
	};

	function removeEventHandler(element, event, id) {
	/* method to remove an event handler for both IE and Mozilla */
	var method = ID_TO_HANDLER[id].execute;
	if (element.removeEventListener) {
	element.removeEventListener(event, method, false);
	} else if (element.detachEvent) {
	element.detachEvent("on" + event, method);
	} else {
	throw "Unsupported browser!";
	};
	};

	String.prototype.strip = function() {
	var stripspace = /^\s([\s\S]?)\s*$/;
	return stripspace.exec(this)[1];
	};