incubator-xap-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mtu...@apache.org
Subject svn commit: r518313 [37/43] - in /incubator/xap/trunk/codebase/src/dojo: ./ src/ src/animation/ src/cal/ src/charting/ src/charting/svg/ src/charting/vml/ src/collections/ src/crypto/ src/data/ src/data/core/ src/data/old/ src/data/old/format/ src/data...
Date Wed, 14 Mar 2007 20:37:27 GMT
Added: incubator/xap/trunk/codebase/src/dojo/src/widget/TreeBasicControllerV3.js
URL: http://svn.apache.org/viewvc/incubator/xap/trunk/codebase/src/dojo/src/widget/TreeBasicControllerV3.js?view=auto&rev=518313
==============================================================================
--- incubator/xap/trunk/codebase/src/dojo/src/widget/TreeBasicControllerV3.js (added)
+++ incubator/xap/trunk/codebase/src/dojo/src/widget/TreeBasicControllerV3.js Wed Mar 14 13:36:44 2007
@@ -0,0 +1,831 @@
+/*
+	Copyright (c) 2004-2006, The Dojo Foundation
+	All Rights Reserved.
+
+	Licensed under the Academic Free License version 2.1 or above OR the
+	modified BSD license. For more information on Dojo licensing, see:
+
+		http://dojotoolkit.org/community/licensing.shtml
+*/
+
+
+dojo.provide("dojo.widget.TreeBasicControllerV3");
+
+dojo.require("dojo.event.*");
+dojo.require("dojo.json")
+dojo.require("dojo.io.*");
+dojo.require("dojo.widget.TreeCommon");
+dojo.require("dojo.widget.TreeNodeV3");
+dojo.require("dojo.widget.TreeV3");
+
+dojo.widget.defineWidget(
+	"dojo.widget.TreeBasicControllerV3",
+	[dojo.widget.HtmlWidget, dojo.widget.TreeCommon],
+	function(){
+		this.listenedTrees = {};
+	},
+{
+	// TODO: do something with addChild / setChild, so that RpcController become able
+	// to hook on this and report to server
+	
+	// TODO: make sure keyboard control stuff works when node is moved between trees
+	// node should be unfocus()'ed when it its ancestor is moved and tree,lastFocus - cleared
+
+	/**
+	 * TreeCommon.listenTree will attach listeners to these events
+	 *
+	 * The logic behind the naming:
+	 * 1. (after|before)
+	 * 2. if an event refers to tree, then add "Tree"
+	 * 3. add action
+	 */
+	listenTreeEvents: ["afterSetFolder", "afterTreeCreate", "beforeTreeDestroy"],
+	listenNodeFilter: function(elem) { return elem instanceof dojo.widget.Widget},	
+		
+		
+	editor: null,
+
+	
+	initialize: function(args) {
+		if (args.editor) {
+			this.editor = dojo.widget.byId(args.editor);
+			this.editor.controller = this;
+		}
+		
+	},
+		
+	
+	getInfo: function(elem) {
+		return elem.getInfo();
+	},
+
+	onBeforeTreeDestroy: function(message) {
+                this.unlistenTree(message.source);
+	},
+
+	onAfterSetFolder: function(message) {
+		
+		//dojo.profile.start("onTreeChange");
+        
+		if (message.source.expandLevel > 0) {
+			this.expandToLevel(message.source, message.source.expandLevel);				
+		}
+		if (message.source.loadLevel > 0) {
+			this.loadToLevel(message.source, message.source.loadLevel);				
+		}
+			
+		
+		//dojo.profile.end("onTreeChange");
+	},
+	
+
+	// down arrow
+	_focusNextVisible: function(nodeWidget) {
+		
+		// if this is an expanded folder, get the first child
+		if (nodeWidget.isFolder && nodeWidget.isExpanded && nodeWidget.children.length > 0) {
+			returnWidget = nodeWidget.children[0];			
+		} else {
+			// find a parent node with a sibling
+			while (nodeWidget.isTreeNode && nodeWidget.isLastChild()) {
+				nodeWidget = nodeWidget.parent;
+			}
+			
+			if (nodeWidget.isTreeNode) {
+				var returnWidget = nodeWidget.parent.children[nodeWidget.getParentIndex()+1];				
+			}
+			
+		}
+				
+		if (returnWidget && returnWidget.isTreeNode) {
+			this._focusLabel(returnWidget);
+			return returnWidget;
+		}
+		
+	},
+	
+	// up arrow
+	_focusPreviousVisible: function(nodeWidget) {
+		var returnWidget = nodeWidget;
+		
+		// if younger siblings		
+		if (!nodeWidget.isFirstChild()) {
+			var previousSibling = nodeWidget.parent.children[nodeWidget.getParentIndex()-1]
+
+			nodeWidget = previousSibling;
+			// if the previous nodeWidget is expanded, dive in deep
+			while (nodeWidget.isFolder && nodeWidget.isExpanded && nodeWidget.children.length > 0) {
+				returnWidget = nodeWidget;
+				// move to the last child
+				nodeWidget = nodeWidget.children[nodeWidget.children.length-1];
+			}
+		} else {
+			// if this is the first child, return the parent
+			nodeWidget = nodeWidget.parent;
+		}
+		
+		if (nodeWidget && nodeWidget.isTreeNode) {
+			returnWidget = nodeWidget;
+		}
+		
+		if (returnWidget && returnWidget.isTreeNode) {
+			this._focusLabel(returnWidget);
+			return returnWidget;
+		}
+		
+	},
+	
+	// right arrow
+	_focusZoomIn: function(nodeWidget) {
+		var returnWidget = nodeWidget;
+		
+		// if not expanded, expand, else move to 1st child
+		if (nodeWidget.isFolder && !nodeWidget.isExpanded) {
+			this.expand(nodeWidget);
+		}else if (nodeWidget.children.length > 0) {
+			nodeWidget = nodeWidget.children[0];
+		}
+		
+		if (nodeWidget && nodeWidget.isTreeNode) {
+			returnWidget = nodeWidget;
+		}
+		
+		if (returnWidget && returnWidget.isTreeNode) {
+			this._focusLabel(returnWidget);
+			return returnWidget;
+		}
+		
+	},
+	
+	// left arrow
+	_focusZoomOut: function(node) {
+		
+		var returnWidget = node;
+		
+		// if not expanded, expand, else move to 1st child
+		if (node.isFolder && node.isExpanded) {
+			this.collapse(node);
+		} else {
+			node = node.parent;
+		}
+		if (node && node.isTreeNode) {
+			returnWidget = node;
+		}
+		
+		if (returnWidget && returnWidget.isTreeNode) {
+			this._focusLabel(returnWidget);
+			return returnWidget;
+		}
+		
+	},
+	
+	onFocusNode: function(e) {
+		var node = this.domElement2TreeNode(e.target);
+		
+		if (node) {
+			node.viewFocus();			
+			dojo.event.browser.stopEvent(e);
+		}
+	},
+	
+	onBlurNode: function(e) {
+		var node = this.domElement2TreeNode(e.target);
+		
+		if (!node) {
+			return;
+		}
+		
+		var labelNode = node.labelNode;
+		
+		labelNode.setAttribute("tabIndex", "-1");
+		node.viewUnfocus();		
+		dojo.event.browser.stopEvent(e);
+		
+		// this could have been set to -1 by the shift+TAB processing
+		node.tree.domNode.setAttribute("tabIndex", "0");
+		
+	},
+	
+	
+	_focusLabel: function(node) {
+		//dojo.debug((new Error()).stack)		
+		var lastFocused = node.tree.lastFocused;
+		var labelNode;
+		
+		if (lastFocused && lastFocused.labelNode) {
+			labelNode = lastFocused.labelNode;
+			// help Opera out with blur events
+			dojo.event.disconnect(labelNode, "onblur", this, "onBlurNode");
+			labelNode.setAttribute("tabIndex", "-1");
+			dojo.html.removeClass(labelNode, "TreeLabelFocused");
+		}
+		
+		// set tabIndex so that the tab key can find this node
+		labelNode = node.labelNode;
+		labelNode.setAttribute("tabIndex", "0");
+		node.tree.lastFocused = node;
+		
+		// add an outline - this helps opera a lot
+		dojo.html.addClass(labelNode, "TreeLabelFocused");
+		dojo.event.connectOnce(labelNode, "onblur", this, "onBlurNode");
+		// prevent the domNode from seeing the focus event
+		dojo.event.connectOnce(labelNode, "onfocus", this, "onFocusNode");
+		// set focus so that the label wil be voiced using screen readers
+		labelNode.focus();
+			
+	},
+	
+	onKey: function(e) {
+		if (!e.key || e.ctrkKey || e.altKey) { return; }
+		// pretend the key was directed toward the current focused node (helps opera out)
+		
+		var nodeWidget = this.domElement2TreeNode(e.target);
+		if (!nodeWidget) {
+			return;
+		}
+		
+		var treeWidget = nodeWidget.tree;
+		
+		if (treeWidget.lastFocused && treeWidget.lastFocused.labelNode) {
+			nodeWidget = treeWidget.lastFocused;
+		}
+		
+		switch(e.key) {
+			case e.KEY_TAB:
+				if (e.shiftKey) {
+					// we're moving backwards so don't tab to the domNode
+					// it'll be added back in onBlurNode
+					treeWidget.domNode.setAttribute("tabIndex", "-1");
+				}
+				break;
+			case e.KEY_RIGHT_ARROW:
+				this._focusZoomIn(nodeWidget);
+				dojo.event.browser.stopEvent(e);
+				break;
+			case e.KEY_LEFT_ARROW:
+				this._focusZoomOut(nodeWidget);
+				dojo.event.browser.stopEvent(e);
+				break;
+			case e.KEY_UP_ARROW:
+				this._focusPreviousVisible(nodeWidget);
+				dojo.event.browser.stopEvent(e);
+				break;
+			case e.KEY_DOWN_ARROW:
+				this._focusNextVisible(nodeWidget);
+				dojo.event.browser.stopEvent(e);
+				break;
+		}
+	},
+	
+	
+	onFocusTree: function(e) {
+		if (!e.currentTarget) { return; }
+		try {
+			var treeWidget = this.getWidgetByNode(e.currentTarget);
+			if (!treeWidget || !treeWidget.isTree) { return; }
+			// on first focus, choose the root node
+			var nodeWidget = this.getWidgetByNode(treeWidget.domNode.firstChild);
+			if (nodeWidget && nodeWidget.isTreeNode) {
+				if (treeWidget.lastFocused && treeWidget.lastFocused.isTreeNode) { // onClick could have chosen a non-root node
+					nodeWidget = treeWidget.lastFocused;
+				}
+				this._focusLabel(nodeWidget);
+			}
+		}
+		catch(e) {}
+	},
+
+	// perform actions-initializers for tree
+	onAfterTreeCreate: function(message) {
+		var tree = message.source;
+		dojo.event.browser.addListener(tree.domNode, "onKey", dojo.lang.hitch(this, this.onKey));
+		dojo.event.browser.addListener(tree.domNode, "onmousedown", dojo.lang.hitch(this, this.onTreeMouseDown));
+		dojo.event.browser.addListener(tree.domNode, "onclick", dojo.lang.hitch(this, this.onTreeClick));
+		dojo.event.browser.addListener(tree.domNode, "onfocus", dojo.lang.hitch(this, this.onFocusTree));
+		tree.domNode.setAttribute("tabIndex", "0");
+		
+		if (tree.expandLevel) {								
+			this.expandToLevel(tree, tree.expandLevel)
+		}
+		if (tree.loadLevel) {
+			this.loadToLevel(tree, tree.loadLevel);
+		}
+	},
+
+    onTreeMouseDown: function(e) {
+    },
+
+	onTreeClick: function(e){
+		//dojo.profile.start("onTreeClick");
+		
+		var domElement = e.target;
+		//dojo.debug('click')
+		// find node
+        var node = this.domElement2TreeNode(domElement);		
+		if (!node || !node.isTreeNode) {
+			return;
+		}
+		
+		
+		var checkExpandClick = function(el) {
+			return el === node.expandNode;
+		}
+		
+		if (this.checkPathCondition(domElement, checkExpandClick)) {
+			this.processExpandClick(node);			
+		}
+		
+		this._focusLabel(node);
+		
+		//dojo.profile.end("onTreeClick");
+		
+	},
+	
+	processExpandClick: function(node){
+		
+		//dojo.profile.start("processExpandClick");
+		
+		if (node.isExpanded){
+			this.collapse(node);
+		} else {
+			this.expand(node);
+		}
+		
+		//dojo.profile.end("processExpandClick");
+	},
+		
+	
+	
+	/**
+	 * time between expand calls for batch operations
+	 * @see expandToLevel
+	 */
+	batchExpandTimeout: 20,
+	
+	
+	expandAll: function(nodeOrTree) {		
+		return this.expandToLevel(nodeOrTree, Number.POSITIVE_INFINITY);
+		
+	},
+	
+	
+	collapseAll: function(nodeOrTree) {
+		var _this = this;
+		
+		var filter = function(elem) {
+			return (elem instanceof dojo.widget.Widget) && elem.isFolder && elem.isExpanded;
+		}
+		
+		if (nodeOrTree.isTreeNode) {		
+			this.processDescendants(nodeOrTree, filter, this.collapse);
+		} else if (nodeOrTree.isTree) {
+			dojo.lang.forEach(nodeOrTree.children,function(c) { _this.processDescendants(c, filter, _this.collapse) });
+		}
+	},
+	
+	/**
+	 * expand tree to specific node
+	 */
+	expandToNode: function(node, withSelected) {
+		n = withSelected ? node : node.parent
+		s = []
+		while (!n.isExpanded) {
+			s.push(n)
+			n = n.parent
+		}
+				
+		dojo.lang.forEach(s, function(n) { n.expand() })
+	},
+		
+	/**
+	 * walk a node in time, forward order, with pauses between expansions
+	 */
+	expandToLevel: function(nodeOrTree, level) {
+		dojo.require("dojo.widget.TreeTimeoutIterator");
+		
+		var _this = this;
+		var filterFunc = function(elem) {
+			var res = elem.isFolder || elem.children && elem.children.length;
+			//dojo.debug("Filter "+elem+ " result:"+res);
+			return res;
+		};
+		var callFunc = function(node, iterator) {			
+			 _this.expand(node, true);
+			 iterator.forward();
+		}
+			
+		var iterator = new dojo.widget.TreeTimeoutIterator(nodeOrTree, callFunc, this);
+		iterator.setFilter(filterFunc);
+		
+		
+		iterator.timeout = this.batchExpandTimeout;
+		
+		//dojo.debug("here "+nodeOrTree+" level "+level);
+		
+		iterator.setMaxLevel(nodeOrTree.isTreeNode ? level-1 : level);
+		
+		
+		return iterator.start(nodeOrTree.isTreeNode);
+	},
+	
+
+	getWidgetByNode: function(node) {
+		var widgetId;
+		var newNode = node;
+		while (! (widgetId = newNode.widgetId) ) {
+			newNode = newNode.parentNode;
+			if (newNode == null) { break; }
+		}
+		if (widgetId) { return dojo.widget.byId(widgetId); }
+		else if (node == null) { return null; }
+		else{ return dojo.widget.manager.byNode(node); }
+	},
+
+
+
+	/**
+	 * callout activated even if node is expanded already
+	 */
+	expand: function(node) {
+		
+		//dojo.profile.start("expand");
+		
+		//dojo.debug("Expand "+node.isFolder);
+		
+		if (node.isFolder) {			
+			node.expand(); // skip trees or non-folders
+		}		
+		
+		//dojo.profile.end("expand");
+				
+	},
+
+	/**
+	 * safe to call on tree and non-folder
+	 */
+	collapse: function(node) {
+		if (node.isFolder) {
+			node.collapse();
+		}
+	},
+	
+	
+	// -------------------------- TODO: Inline edit node ---------------------
+	canEditLabel: function(node) {
+		if (node.actionIsDisabledNow(node.actions.EDIT)) return false;
+
+		return true;
+	},
+	
+		
+	editLabelStart: function(node) {		
+		if (!this.canEditLabel(node)) {
+			return false;
+		}
+		
+		if (!this.editor.isClosed()) {
+			//dojo.debug("editLabelStart editor open");
+			this.editLabelFinish(this.editor.saveOnBlur);			
+		}
+				
+		this.doEditLabelStart(node);
+		
+	
+	},
+	
+	
+	editLabelFinish: function(save) {
+		this.doEditLabelFinish(save);		
+	},
+	
+	
+	doEditLabelStart: function(node) {
+		if (!this.editor) {
+			dojo.raise(this.widgetType+": no editor specified");
+		}
+		
+		//dojo.debug("editLabelStart editor open "+node);
+		
+		this.editor.open(node);
+	},
+	
+	doEditLabelFinish: function(save, server_data) {
+		//dojo.debug("Finish "+save);
+		//dojo.debug((new Error()).stack)
+		if (!this.editor) {
+			dojo.raise(this.widgetType+": no editor specified");
+		}
+
+		var node = this.editor.node;	
+		var editorTitle = this.editor.getContents();
+		
+		this.editor.close(save);
+
+		if (save) {
+			var data = {title:editorTitle};
+			
+			if (server_data) { // may be undefined
+				dojo.lang.mixin(data, server_data);
+			}
+			
+			
+			if (node.isPhantom) {			
+				// I can't just set node phantom's title, because widgetId/objectId/widgetName...
+				// may be provided by server
+				var parent = node.parent;
+				var index = node.getParentIndex();				
+				node.destroy();
+				// new node was added!
+				dojo.widget.TreeBasicControllerV3.prototype.doCreateChild.call(this, parent, index, data);
+			} else {
+				var title = server_data && server_data.title ? server_data.title : editorTitle;
+				// use special method to make sure everything updated and event sent
+				node.setTitle(title); 
+			}
+		} else {
+			//dojo.debug("Kill phantom on cancel");
+			if (node.isPhantom) {
+				node.destroy();
+			}
+		}
+	},
+	
+	
+		
+	makeDefaultNode: function(parent, index) {
+		var data = {title:parent.tree.defaultChildTitle};
+		return dojo.widget.TreeBasicControllerV3.prototype.doCreateChild.call(this,parent,index,data);
+	},
+	
+	/**
+	 * check that something is possible
+	 * run maker to do it
+	 * run exposer to expose result to visitor immediatelly
+	 *   exposer does not affect result
+	 */
+	runStages: function(check, prepare, make, finalize, expose, args) {
+		
+		if (check && !check.apply(this, args)) {
+			return false;
+		}
+		
+		if (prepare && !prepare.apply(this, args)) {
+			return false;
+		}
+		
+		var result = make.apply(this, args);
+		
+		
+		if (finalize) {
+			finalize.apply(this,args);			
+		}
+			
+		if (!result) {
+			return result;
+		}
+		
+			
+		if (expose) {
+			expose.apply(this, args);
+		}
+		
+		return result;
+	}
+});
+
+
+// create and edit
+dojo.lang.extend(dojo.widget.TreeBasicControllerV3, {
+		
+	createAndEdit: function(parent, index) {
+		var data = {title:parent.tree.defaultChildTitle};
+		
+		if (!this.canCreateChild(parent, index, data)) {
+			return false;
+		}
+		
+		var child = this.doCreateChild(parent, index, data);
+		if (!child) return false;
+		this.exposeCreateChild(parent, index, data);
+		
+		child.isPhantom = true;
+		
+		if (!this.editor.isClosed()) {
+			//dojo.debug("editLabelStart editor open");
+			this.editLabelFinish(this.editor.saveOnBlur);			
+		}
+		
+		
+				
+		this.doEditLabelStart(child);		
+	
+	}
+	
+});
+
+
+// =============================== clone ============================
+dojo.lang.extend(dojo.widget.TreeBasicControllerV3, {
+	
+	canClone: function(child, newParent, index, deep){
+		return true;
+	},
+	
+	
+	clone: function(child, newParent, index, deep) {
+		return this.runStages(
+			this.canClone, this.prepareClone, this.doClone, this.finalizeClone, this.exposeClone, arguments
+		);			
+	},
+
+	exposeClone: function(child, newParent) {
+		if (newParent.isTreeNode) {
+			this.expand(newParent);
+		}
+	},
+
+	doClone: function(child, newParent, index, deep) {
+		//dojo.debug("Clone "+child);
+		var cloned = child.clone(deep);
+		newParent.addChild(cloned, index);
+				
+		return cloned;
+	}
+	
+
+});
+
+// =============================== detach ============================
+
+dojo.lang.extend(dojo.widget.TreeBasicControllerV3, {
+	canDetach: function(child) {
+		if (child.actionIsDisabledNow(child.actions.DETACH)) {
+			return false;
+		}
+
+		return true;
+	},
+
+
+	detach: function(node) {
+		return this.runStages(
+			this.canDetach, this.prepareDetach, this.doDetach, this.finalizeDetach, this.exposeDetach, arguments
+		);			
+	},
+
+
+	doDetach: function(node, callObj, callFunc) {
+		node.detach();
+	}
+	
+});
+
+
+// =============================== destroy ============================
+dojo.lang.extend(dojo.widget.TreeBasicControllerV3, {
+
+	canDestroyChild: function(child) {
+		
+		if (child.parent && !this.canDetach(child)) {
+			return false;
+		}
+		return true;
+	},
+
+
+	destroyChild: function(node) {
+		return this.runStages(
+			this.canDestroyChild, this.prepareDestroyChild, this.doDestroyChild, this.finalizeDestroyChild, this.exposeDestroyChild, arguments
+		);			
+	},
+
+
+	doDestroyChild: function(node) {
+		node.destroy();
+	}
+	
+});
+
+
+
+// =============================== move ============================
+
+dojo.lang.extend(dojo.widget.TreeBasicControllerV3, {
+
+	/**
+	 * check for non-treenodes
+	 */
+	canMoveNotANode: function(child, parent) {
+		if (child.treeCanMove) {
+			return child.treeCanMove(parent);
+		}
+		
+		return true;
+	},
+
+	/**
+	 * Checks whether it is ok to change parent of child to newParent
+	 * May incur type checks etc
+	 *
+	 * It should check only hierarchical possibility w/o index, etc
+	 * because in onDragOver event for Between Dnd mode we can't calculate index at once on onDragOVer.
+	 * index changes as client moves mouse up-down over the node
+	 */
+	canMove: function(child, newParent){
+		if (!child.isTreeNode) {
+			return this.canMoveNotANode(child, newParent);
+		}
+						
+		if (child.actionIsDisabledNow(child.actions.MOVE)) {
+			return false;
+		}
+
+		// if we move under same parent then no matter if ADDCHILD disabled for him
+		// but if we move to NEW parent then check if action is disabled for him
+		// also covers case for newParent being a non-folder in strict mode etc
+		if (child.parent !== newParent && newParent.actionIsDisabledNow(newParent.actions.ADDCHILD)) {
+			return false;
+		}
+
+		// Can't move parent under child. check whether new parent is child of "child".
+		var node = newParent;
+		while(node.isTreeNode) {
+			//dojo.debugShallow(node.title)
+			if (node === child) {
+				// parent of newParent is child
+				return false;
+			}
+			node = node.parent;
+		}
+
+		return true;
+	},
+
+
+	move: function(child, newParent, index/*,...*/) {
+		return this.runStages(this.canMove, this.prepareMove, this.doMove, this.finalizeMove, this.exposeMove, arguments);			
+	},
+
+	doMove: function(child, newParent, index) {
+		//dojo.debug("MOVE "+child);
+		child.tree.move(child, newParent, index);
+
+		return true;
+	},
+	
+	exposeMove: function(child, newParent) {		
+		if (newParent.isTreeNode) {
+			this.expand(newParent);
+		}
+	}
+		
+
+});
+
+dojo.lang.extend(dojo.widget.TreeBasicControllerV3, {
+
+	// -----------------------------------------------------------------------------
+	//                             Create node stuff
+	// -----------------------------------------------------------------------------
+
+
+	canCreateChild: function(parent, index, data) {
+		if (parent.actionIsDisabledNow(parent.actions.ADDCHILD)) {
+			return false;
+		}
+
+		return true;
+	},
+
+
+	/* send data to server and add child from server */
+	/* data may contain an almost ready child, or anything else, suggested to server */
+	/*in Rpc controllers server responds with child data to be inserted */
+	createChild: function(parent, index, data) {
+		if(!data) {
+			data = {title:parent.tree.defaultChildTitle};
+		}
+		return this.runStages(this.canCreateChild, this.prepareCreateChild, this.doCreateChild, this.finalizeCreateChild, this.exposeCreateChild,
+			[parent, index, data]);		
+	},
+
+	prepareCreateChild: function() { return true; },
+	finalizeCreateChild: function() {},
+
+	doCreateChild: function(parent, index, data) {
+		//dojo.debug("doCreateChild parent "+parent+" index "+index+" data "+data);
+		
+		var newChild = parent.tree.createNode(data); 
+		//var newChild = dojo.widget.createWidget(widgetType, data);
+
+		parent.addChild(newChild, index);
+
+		return newChild;
+	},
+	
+	exposeCreateChild: function(parent) {
+		return this.expand(parent);
+	}
+
+
+});

Added: incubator/xap/trunk/codebase/src/dojo/src/widget/TreeCommon.js
URL: http://svn.apache.org/viewvc/incubator/xap/trunk/codebase/src/dojo/src/widget/TreeCommon.js?view=auto&rev=518313
==============================================================================
--- incubator/xap/trunk/codebase/src/dojo/src/widget/TreeCommon.js (added)
+++ incubator/xap/trunk/codebase/src/dojo/src/widget/TreeCommon.js Wed Mar 14 13:36:44 2007
@@ -0,0 +1,150 @@
+/*
+	Copyright (c) 2004-2006, The Dojo Foundation
+	All Rights Reserved.
+
+	Licensed under the Academic Free License version 2.1 or above OR the
+	modified BSD license. For more information on Dojo licensing, see:
+
+		http://dojotoolkit.org/community/licensing.shtml
+*/
+
+
+dojo.provide("dojo.widget.TreeCommon");
+dojo.require("dojo.widget.*"); // for dojo.widget.manager
+
+dojo.declare(
+	"dojo.widget.TreeCommon",
+	null,
+{
+	listenTreeEvents: [],
+	listenedTrees: {},
+	
+	/**
+	 * evaluates to false => skip unlistening nodes
+	 * provided => use it
+	 */	
+	listenNodeFilter: null,
+	
+	listenTree: function(tree) {
+		
+		//dojo.debug("listenTree in "+this+" tree "+tree);
+		
+		var _this = this;
+		
+		if (this.listenedTrees[tree.widgetId]) {
+			return; // already listening
+		}
+		
+		dojo.lang.forEach(this.listenTreeEvents, function(event) {
+			var eventHandler =  "on" + event.charAt(0).toUpperCase() + event.substr(1);
+			//dojo.debug("subscribe: event "+tree.eventNames[event]+" widget "+_this+" handler "+eventHandler);
+			dojo.event.topic.subscribe(tree.eventNames[event], _this, eventHandler);
+		});
+		
+		
+		var filter;
+		
+		if (this.listenNodeFilter) {			
+			this.processDescendants(tree, this.listenNodeFilter, this.listenNode, true);
+		}
+		
+		/**
+		 * remember that I listen to this tree. No unbinding/binding/deselection
+		 * needed when transfer between listened trees
+		 */
+		this.listenedTrees[tree.widgetId] = true;
+		
+	},			
+	
+	// interface functions
+	listenNode: function() {},	
+	unlistenNode: function() {},
+			
+	unlistenTree: function(tree, nodeFilter) {
+		
+		var _this = this;
+	
+		if (!this.listenedTrees[tree.widgetId]) {
+			return; 
+		}
+		
+		dojo.lang.forEach(this.listenTreeEvents, function(event) {
+			var eventHandler =  "on" + event.charAt(0).toUpperCase() + event.substr(1);
+			dojo.event.topic.unsubscribe(tree.eventNames[event], _this, eventHandler);
+		});
+		
+		
+		if (this.listenNodeFilter) {
+			this.processDescendants(tree, this.listenNodeFilter, this.unlistenNode, true);
+		}
+		
+		delete this.listenedTrees[tree.widgetId];
+		
+	},
+	
+	
+	/**
+	 * check condition for node.domNode -> .. -> any node chain
+	 */
+	checkPathCondition: function(domElement, condition) {
+		
+		while (domElement && !domElement.widgetId) {
+			if (condition.call(null, domElement)) {
+				return true;
+			}
+			
+			domElement = domElement.parentNode;
+		}
+		
+		return false;
+	},
+		
+	
+	/**
+	 * get node widget id by its descendant dom node
+	 */
+	domElement2TreeNode: function(domElement) {
+		
+		while (domElement && !domElement.widgetId) {
+			domElement = domElement.parentNode;
+		}
+		
+		if (!domElement) {
+			return null;
+		}
+		
+		var widget = dojo.widget.byId(domElement.widgetId);
+		
+		if (!widget.isTreeNode) {
+			return null;
+		}
+		
+		return widget;
+	},
+	
+	/**
+	 * it is here, not in Widget, because mostly tree needs it
+	 */
+	processDescendants: function(elem, filter, func, skipFirst) {
+		
+		var _this = this;
+		
+		if (!skipFirst) {
+			if (!filter.call(_this,elem)) {
+				return;
+			}
+			func.call(_this,elem);	        
+		}
+		
+		
+		var stack = [elem];
+		while (elem = stack.pop()) {
+			dojo.lang.forEach(elem.children, function(elem) {
+				if (filter.call(_this, elem)) {		
+					func.call(_this, elem);
+					stack.push(elem);
+				}
+			});
+		}
+    }
+});

Added: incubator/xap/trunk/codebase/src/dojo/src/widget/TreeContextMenu.js
URL: http://svn.apache.org/viewvc/incubator/xap/trunk/codebase/src/dojo/src/widget/TreeContextMenu.js?view=auto&rev=518313
==============================================================================
--- incubator/xap/trunk/codebase/src/dojo/src/widget/TreeContextMenu.js (added)
+++ incubator/xap/trunk/codebase/src/dojo/src/widget/TreeContextMenu.js Wed Mar 14 13:36:44 2007
@@ -0,0 +1,181 @@
+/*
+	Copyright (c) 2004-2006, The Dojo Foundation
+	All Rights Reserved.
+
+	Licensed under the Academic Free License version 2.1 or above OR the
+	modified BSD license. For more information on Dojo licensing, see:
+
+		http://dojotoolkit.org/community/licensing.shtml
+*/
+
+
+
+dojo.provide("dojo.widget.TreeContextMenu");
+
+dojo.require("dojo.event.*");
+dojo.require("dojo.io.*");
+dojo.require("dojo.widget.Menu2");
+
+
+dojo.widget.defineWidget("dojo.widget.TreeContextMenu", dojo.widget.PopupMenu2, function() {
+	this.listenedTrees = [];
+},
+{
+	open: function(x, y, parentMenu, explodeSrc){
+
+		var result = dojo.widget.PopupMenu2.prototype.open.apply(this, arguments);
+
+		/* publish many events here about structural changes */
+		dojo.event.topic.publish(this.eventNames.open, { menu:this });
+
+		return result;
+	},
+
+	listenTree: function(tree) {
+		/* add context menu to all nodes that exist already */
+		var nodes = tree.getDescendants();
+
+		for(var i=0; i<nodes.length; i++) {
+			if (!nodes[i].isTreeNode) continue;
+			this.bindDomNode(nodes[i].labelNode);
+		}
+
+
+		/* bind context menu to all nodes that will be created in the future (e.g loaded from server)*/
+		var _this = this;
+		dojo.event.topic.subscribe(tree.eventNames.createDOMNode, this, "onCreateDOMNode");
+		dojo.event.topic.subscribe(tree.eventNames.moveFrom, this, "onMoveFrom");
+		dojo.event.topic.subscribe(tree.eventNames.moveTo, this, "onMoveTo");
+		dojo.event.topic.subscribe(tree.eventNames.removeNode, this, "onRemoveNode");
+		dojo.event.topic.subscribe(tree.eventNames.addChild, this, "onAddChild");
+		dojo.event.topic.subscribe(tree.eventNames.treeDestroy, this, "onTreeDestroy");
+
+		this.listenedTrees.push(tree);
+
+	},
+
+	unlistenTree: function(tree) {
+		/* clear event listeners */
+
+		dojo.event.topic.unsubscribe(tree.eventNames.createDOMNode, this, "onCreateDOMNode");
+		dojo.event.topic.unsubscribe(tree.eventNames.moveFrom, this, "onMoveFrom");
+		dojo.event.topic.unsubscribe(tree.eventNames.moveTo, this, "onMoveTo");
+		dojo.event.topic.unsubscribe(tree.eventNames.removeNode, this, "onRemoveNode");
+		dojo.event.topic.unsubscribe(tree.eventNames.addChild, this, "onAddChild");
+		dojo.event.topic.unsubscribe(tree.eventNames.treeDestroy, this, "onTreeDestroy");
+
+		for(var i=0; i<this.listenedTrees.length; i++){
+           if(this.listenedTrees[i] === tree){
+                   this.listenedTrees.splice(i, 1);
+                   break;
+           }
+		}
+	},
+
+	onTreeDestroy: function(message) {
+		this.unlistenTree(message.source);
+	},
+
+	bindTreeNode: function(node) {
+		var _this = this;
+		//dojo.debug("bind to "+node);
+		dojo.lang.forEach(node.getDescendants(),
+			function(e) {_this.bindDomNode(e.labelNode); }
+		);
+	},
+
+
+	unBindTreeNode: function(node) {
+		var _this = this;
+		//dojo.debug("Unbind from "+node);
+		dojo.lang.forEach(node.getDescendants(),
+			function(e) {_this.unBindDomNode(e.labelNode); }
+		);
+	},
+
+	onCreateDOMNode: function(message) {
+		this.bindTreeNode(message.source);
+	},
+
+
+	onMoveFrom: function(message) {
+		if (!dojo.lang.inArray(this.listenedTrees, message.newTree)) {
+			this.unBindTreeNode(message.child);
+		}
+	},
+
+	onMoveTo: function(message) {
+		if (dojo.lang.inArray(this.listenedTrees, message.newTree)) {
+			this.bindTreeNode(message.child);
+		}
+	},
+
+	onRemoveNode: function(message) {
+		this.unBindTreeNode(message.child);
+	},
+
+	onAddChild: function(message) {
+		if (message.domNodeInitialized) {
+			// dom node was there already => I did not process onNodeDomCreate
+			this.bindTreeNode(message.child);
+		}
+	}
+
+
+});
+
+dojo.widget.defineWidget("dojo.widget.TreeMenuItem", dojo.widget.MenuItem2, {
+	// treeActions menu item performs following actions (to be checked for permissions)
+	treeActions: "",
+
+	initialize: function(args, frag) {
+
+		this.treeActions = this.treeActions.split(",");
+		for(var i=0; i<this.treeActions.length; i++) {
+			this.treeActions[i] = this.treeActions[i].toUpperCase();
+		}
+
+	},
+
+	getTreeNode: function() {
+		var menu = this;
+
+		while (! (menu instanceof dojo.widget.TreeContextMenu) ) {
+			menu = menu.parent;
+		}
+
+		var source = menu.getTopOpenEvent().target;
+
+		while (!source.getAttribute('treeNode') && source.tagName != 'body') {
+			source = source.parentNode;
+		}
+		if (source.tagName == 'body') {
+			dojo.raise("treeNode not detected");
+		}
+		var treeNode = dojo.widget.manager.getWidgetById(source.getAttribute('treeNode'));
+
+		return treeNode;
+	},
+
+
+	menuOpen: function(message) {
+		var treeNode = this.getTreeNode();
+
+		this.setDisabled(false); // enable by default
+
+		var _this = this;
+		dojo.lang.forEach(_this.treeActions,
+			function(action) {
+				_this.setDisabled( treeNode.actionIsDisabled(action) );
+			}
+		);
+
+	},
+
+	toString: function() {
+		return "["+this.widgetType+" node "+this.getTreeNode()+"]";
+	}
+
+});
+
+

Added: incubator/xap/trunk/codebase/src/dojo/src/widget/TreeContextMenuV3.js
URL: http://svn.apache.org/viewvc/incubator/xap/trunk/codebase/src/dojo/src/widget/TreeContextMenuV3.js?view=auto&rev=518313
==============================================================================
--- incubator/xap/trunk/codebase/src/dojo/src/widget/TreeContextMenuV3.js (added)
+++ incubator/xap/trunk/codebase/src/dojo/src/widget/TreeContextMenuV3.js Wed Mar 14 13:36:44 2007
@@ -0,0 +1,132 @@
+/*
+	Copyright (c) 2004-2006, The Dojo Foundation
+	All Rights Reserved.
+
+	Licensed under the Academic Free License version 2.1 or above OR the
+	modified BSD license. For more information on Dojo licensing, see:
+
+		http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.widget.TreeContextMenuV3");
+
+dojo.require("dojo.event.*");
+dojo.require("dojo.io.*");
+dojo.require("dojo.widget.*");
+dojo.require("dojo.widget.Menu2");
+dojo.require("dojo.widget.TreeCommon");
+
+dojo.widget.defineWidget(
+	"dojo.widget.TreeContextMenuV3",
+	[dojo.widget.PopupMenu2, dojo.widget.TreeCommon],
+	function() {
+		this.listenedTrees = {};
+		
+	},
+{
+
+	listenTreeEvents: ["afterTreeCreate","beforeTreeDestroy"],
+	listenNodeFilter: function(elem) { return elem instanceof dojo.widget.Widget},
+	
+	onAfterTreeCreate: function(message) {
+		var tree = message.source;
+		this.bindDomNode(tree.domNode);
+	},
+	
+	onBeforeTreeDestroy: function(message) {
+		this.unBindDomNode(message.source.domNode);
+	},
+	
+	
+	getTreeNode: function() {
+		
+		var source = this.getTopOpenEvent().target;
+		var treeNode = this.domElement2TreeNode(source);
+		return treeNode;
+	
+	},
+		
+	open: function() {
+		var result = dojo.widget.PopupMenu2.prototype.open.apply(this, arguments);
+
+		for(var i=0; i< this.children.length; i++) {
+			/* notify children */
+			if (this.children[i].menuOpen) {
+				this.children[i].menuOpen(this.getTreeNode());
+			}
+		}
+		return result;
+	},
+	
+	close: function(){
+		
+		for(var i=0; i< this.children.length; i++) {
+			/* notify menu entries */
+			if (this.children[i].menuClose) {
+				this.children[i].menuClose(this.getTreeNode());
+			}
+		}
+		
+
+		var result = dojo.widget.PopupMenu2.prototype.close.apply(this, arguments);
+		
+		return result
+	}
+	
+});
+
+
+dojo.widget.defineWidget(
+	"dojo.widget.TreeMenuItemV3",
+	[dojo.widget.MenuItem2, dojo.widget.TreeCommon],
+	function() {
+		this.treeActions = [];
+	},
+{
+	// treeActions menu item performs following actions (to be checked for permissions)
+	treeActions: "",
+
+	initialize: function(args, frag) {
+		for(var i=0; i<this.treeActions.length; i++) {
+			this.treeActions[i] = this.treeActions[i].toUpperCase();
+		}
+	},
+
+		
+	getTreeNode: function() {
+		var menu = this;
+
+		// FIXME: change to dojo.widget[this.widgetType]
+		while (! (menu instanceof dojo.widget.TreeContextMenuV3) ) {
+				menu = menu.parent;
+		}
+
+		var treeNode = menu.getTreeNode()
+
+		return treeNode;
+	},
+
+
+	menuOpen: function(treeNode) {
+
+		treeNode.viewEmphasize()
+		this.setDisabled(false); // enable by default
+
+		var _this = this;
+		dojo.lang.forEach(_this.treeActions,
+			function(action) {
+				_this.setDisabled( treeNode.actionIsDisabledNow(action) );
+			}
+		);
+
+	},
+	
+	menuClose: function(treeNode) {
+
+		treeNode.viewUnemphasize()
+	},
+
+	toString: function() {
+		return "["+this.widgetType+" node "+this.getTreeNode()+"]";
+	}
+});

Added: incubator/xap/trunk/codebase/src/dojo/src/widget/TreeControllerExtension.js
URL: http://svn.apache.org/viewvc/incubator/xap/trunk/codebase/src/dojo/src/widget/TreeControllerExtension.js?view=auto&rev=518313
==============================================================================
--- incubator/xap/trunk/codebase/src/dojo/src/widget/TreeControllerExtension.js (added)
+++ incubator/xap/trunk/codebase/src/dojo/src/widget/TreeControllerExtension.js Wed Mar 14 13:36:44 2007
@@ -0,0 +1,94 @@
+/*
+	Copyright (c) 2004-2006, The Dojo Foundation
+	All Rights Reserved.
+
+	Licensed under the Academic Free License version 2.1 or above OR the
+	modified BSD license. For more information on Dojo licensing, see:
+
+		http://dojotoolkit.org/community/licensing.shtml
+*/
+
+/**
+ * Additional tree utils
+ *
+ */
+dojo.provide("dojo.widget.TreeControllerExtension");
+
+dojo.declare(
+	"dojo.widget.TreeControllerExtension",
+	null,
+{
+	saveExpandedIndices: function(node, field) {
+		var obj = {};
+
+		for(var i=0; i<node.children.length; i++) {
+			if (node.children[i].isExpanded) {
+				var key = dojo.lang.isUndefined(field) ? i : node.children[i][field];
+				obj[key] = this.saveExpandedIndices(node.children[i], field);
+			}
+		}
+
+		return obj;
+	},
+
+
+	restoreExpandedIndices: function(node, savedIndices, field) {
+		var _this = this;
+
+		var handler = function(node, savedIndices) {
+			this.node = node; //.children[i];
+			this.savedIndices = savedIndices; //[i];
+			// recursively read next savedIndices level and apply to opened node
+			this.process = function() {
+				//dojo.debug("Callback applied for "+this.node);
+				_this.restoreExpandedIndices(this.node, this.savedIndices, field);
+			};
+		}
+
+
+		for(var i=0; i<node.children.length; i++) {
+			var child = node.children[i];
+
+			var found = false;
+			var key = -1;
+
+			//dojo.debug("Check "+child)
+			// process field set case
+			if (dojo.lang.isUndefined(field) && savedIndices[i]) {
+				found = true;
+				key = i;
+			}
+
+			// process case when field is not set
+			if (field) {
+				for(var key in savedIndices) {
+					//dojo.debug("Compare "+key+" "+child[field])
+					if (key == child[field]) {
+						found = true;
+						break;
+					}
+				}
+			}
+
+			// if we found anything - expand it
+			if (found) {
+				//dojo.debug("Found at "+key)
+				var h = new handler(child, savedIndices[key]);
+				_this.expand(child, false, h, h.process);
+			} else if (child.isExpanded) { // not found, so collapse
+				//dojo.debug("Collapsing all descendants "+node.children[i])
+				dojo.lang.forEach(child.getDescendants(), function(elem) { _this.collapse(elem); });
+				//this.collapse(node.children[i]);
+			}
+
+		}
+
+
+	}
+
+});
+
+
+
+
+

Added: incubator/xap/trunk/codebase/src/dojo/src/widget/TreeDemo.js
URL: http://svn.apache.org/viewvc/incubator/xap/trunk/codebase/src/dojo/src/widget/TreeDemo.js?view=auto&rev=518313
==============================================================================
--- incubator/xap/trunk/codebase/src/dojo/src/widget/TreeDemo.js (added)
+++ incubator/xap/trunk/codebase/src/dojo/src/widget/TreeDemo.js Wed Mar 14 13:36:44 2007
@@ -0,0 +1,130 @@
+/*
+	Copyright (c) 2004-2006, The Dojo Foundation
+	All Rights Reserved.
+
+	Licensed under the Academic Free License version 2.1 or above OR the
+	modified BSD license. For more information on Dojo licensing, see:
+
+		http://dojotoolkit.org/community/licensing.shtml
+*/
+
+
+dojo.provide("dojo.widget.TreeDemo");
+dojo.require("dojo.Deferred");
+
+dojo.widget.TreeDemo = {
+	
+	reportIfDefered: function(res) {
+		if (res instanceof dojo.Deferred) {			
+			res.addCallbacks(
+				function(res) { /* dojo.debug("OK " + (res ? res: '')); */ return res },
+				function(err) { dojo.debug("Error"); dojo.debugShallow(err); }
+			);
+		}		
+	},
+	
+	resetRandomChildren: function(maxCount) {
+		this.randomChildrenMaxCount = maxCount;
+		this.randomChildrenCount = 0;
+		this.randomChildrenDepth = 0;
+	},
+	
+	
+	makeRandomChildren: function(title) {		
+
+		this.randomChildrenDepth++;
+			
+		var children = [];
+		for (var i=1; i<=5; i++) {				
+
+			var t = title+(this.randomChildrenDepth==1 ? '' : '.')+i;
+			var node = {title: t};
+				
+			children.push(node);		
+			this.randomChildrenCount++	
+			if (this.randomChildrenCount >= this.randomChildrenMaxCount) {
+				break;			
+			}
+		}
+
+		var i=1;
+		var _this = this;
+		dojo.lang.forEach(children, function(child) {
+			var t = title+(_this.randomChildrenDepth==1 ? '' : '.')+i;
+			i++;
+		
+			// first node is always folder for tests
+			if (_this.randomChildrenCount<_this.randomChildrenMaxCount && (
+				_this.randomChildrenDepth==1 && child === children[0] || _this.randomChildrenDepth<5 && Math.random()>0.3 )
+			  ) {
+				//dojo.debug("add child "+t);
+				child.children = _this.makeRandomChildren(t);	
+			}
+		});
+				
+
+			//dojo.debug("out "+nodeOrTree);
+			
+		this.randomChildrenDepth--;
+			
+		return children;			
+	},
+	
+	bindDemoMenu: function(controller) {
+		var _t = this;
+		
+		dojo.event.topic.subscribe('treeContextMenuDestroy/engage',
+			function (menuItem) { 
+				var node = menuItem.getTreeNode();
+				//if (confirm("Delete node with descendants: "+node.title.replace(/(<([^>]+)>)/ig," ") +" ?")) {
+				_t.reportIfDefered(controller.destroyChild(node)); 
+				
+			}
+		);
+
+		dojo.event.topic.subscribe('treeContextMenuRefresh/engage',
+			function (menuItem) {
+                var node = menuItem.getTreeNode();
+                _t.reportIfDefered(controller.refreshChildren(node));
+			}
+		);
+
+		dojo.event.topic.subscribe('treeContextMenuCreate/engage',
+			function (menuItem) {
+				var node = menuItem.getTreeNode();
+				var d = controller.createAndEdit(node, 0);
+				_t.reportIfDefered(d);
+            }
+		);
+
+
+		dojo.event.topic.subscribe('treeContextMenuUp/engage',
+			function (menuItem) {
+                var node = menuItem.getTreeNode();
+                if (node.isFirstChild()) return;
+                _t.reportIfDefered(controller.move(node, node.parent, node.getParentIndex()-1));
+            }
+		);
+
+
+		dojo.event.topic.subscribe('treeContextMenuDown/engage',
+			function (menuItem) {
+                var node = menuItem.getTreeNode();
+                if (node.isLastChild()) return;
+                _t.reportIfDefered(controller.move(node, node.parent, node.getParentIndex()+1));
+            }
+		);
+
+		dojo.event.topic.subscribe('treeContextMenuEdit/engage',
+			function (menuItem) {
+                var node = menuItem.getTreeNode();
+                _t.reportIfDefered(controller.editLabelStart(node));
+			}
+		);
+
+
+	}
+	
+	
+	
+}

Added: incubator/xap/trunk/codebase/src/dojo/src/widget/TreeDeselectOnDblselect.js
URL: http://svn.apache.org/viewvc/incubator/xap/trunk/codebase/src/dojo/src/widget/TreeDeselectOnDblselect.js?view=auto&rev=518313
==============================================================================
--- incubator/xap/trunk/codebase/src/dojo/src/widget/TreeDeselectOnDblselect.js (added)
+++ incubator/xap/trunk/codebase/src/dojo/src/widget/TreeDeselectOnDblselect.js Wed Mar 14 13:36:44 2007
@@ -0,0 +1,37 @@
+/*
+	Copyright (c) 2004-2006, The Dojo Foundation
+	All Rights Reserved.
+
+	Licensed under the Academic Free License version 2.1 or above OR the
+	modified BSD license. For more information on Dojo licensing, see:
+
+		http://dojotoolkit.org/community/licensing.shtml
+*/
+
+
+dojo.provide("dojo.widget.TreeDeselectOnDblselect");
+
+dojo.require("dojo.widget.HtmlWidget");
+dojo.require("dojo.widget.TreeSelectorV3");
+
+dojo.deprecated("Does anyone still need this extension? (TreeDeselectOnDblselect)");
+// selector extension to emphasize node
+
+dojo.widget.defineWidget(
+	"dojo.widget.TreeDeselectOnDblselect",
+	[dojo.widget.HtmlWidget],
+{
+	selector: "",
+	
+	initialize: function() {
+		this.selector = dojo.widget.byId(this.selector);
+		//dojo.debug("OK "+this.selector);
+		dojo.event.topic.subscribe(this.selector.eventNames.dblselect, this, "onDblselect");		
+	},
+
+	onDblselect: function(message) {
+		//dojo.debug("happen "+this.selector);
+		//dojo.debug(message.node);
+		this.selector.deselect(message.node);
+	}
+});

Added: incubator/xap/trunk/codebase/src/dojo/src/widget/TreeDisableWrapExtension.js
URL: http://svn.apache.org/viewvc/incubator/xap/trunk/codebase/src/dojo/src/widget/TreeDisableWrapExtension.js?view=auto&rev=518313
==============================================================================
--- incubator/xap/trunk/codebase/src/dojo/src/widget/TreeDisableWrapExtension.js (added)
+++ incubator/xap/trunk/codebase/src/dojo/src/widget/TreeDisableWrapExtension.js Wed Mar 14 13:36:44 2007
@@ -0,0 +1,55 @@
+/*
+	Copyright (c) 2004-2006, The Dojo Foundation
+	All Rights Reserved.
+
+	Licensed under the Academic Free License version 2.1 or above OR the
+	modified BSD license. For more information on Dojo licensing, see:
+
+		http://dojotoolkit.org/community/licensing.shtml
+*/
+
+
+dojo.provide( "dojo.widget.TreeDisableWrapExtension" );
+
+dojo.require( "dojo.widget.HtmlWidget" );
+dojo.require( "dojo.widget.TreeExtension" );
+
+// selector extension to emphasize node
+dojo.widget.defineWidget(
+	"dojo.widget.TreeDisableWrapExtension",
+	dojo.widget.TreeExtension,
+{
+	/**
+	 * can't unlisten
+	 */
+	templateCssPath: dojo.uri.dojoUri( "src/widget/templates/TreeDisableWrap.css" ),
+		
+	listenTree: function(tree) {
+		
+		var wrappingDiv = document.createElement( "div" );
+		var clazz = tree.classPrefix+"DisableWrap";
+		if (dojo.render.html.ie) {
+			clazz = clazz+' '+ tree.classPrefix+"IEDisableWrap";
+		}
+		dojo.html.setClass(wrappingDiv, clazz);
+		
+		var table = document.createElement( "table" );
+		wrappingDiv.appendChild( table );
+		
+		var tbody = document.createElement( "tbody" );
+		table.appendChild( tbody );
+		
+		var tr = document.createElement( "tr" );
+		tbody.appendChild( tr );
+		
+		var td = document.createElement( "td" );
+		tr.appendChild( td );
+		
+		if( tree.domNode.parentNode ) {
+			tree.domNode.parentNode.replaceChild( wrappingDiv, tree.domNode );
+		}
+		
+		td.appendChild( tree.domNode );
+		tree.domNode = wrappingDiv;
+	}
+});

Added: incubator/xap/trunk/codebase/src/dojo/src/widget/TreeDndControllerV3.js
URL: http://svn.apache.org/viewvc/incubator/xap/trunk/codebase/src/dojo/src/widget/TreeDndControllerV3.js?view=auto&rev=518313
==============================================================================
--- incubator/xap/trunk/codebase/src/dojo/src/widget/TreeDndControllerV3.js (added)
+++ incubator/xap/trunk/codebase/src/dojo/src/widget/TreeDndControllerV3.js Wed Mar 14 13:36:44 2007
@@ -0,0 +1,140 @@
+/*
+	Copyright (c) 2004-2006, The Dojo Foundation
+	All Rights Reserved.
+
+	Licensed under the Academic Free License version 2.1 or above OR the
+	modified BSD license. For more information on Dojo licensing, see:
+
+		http://dojotoolkit.org/community/licensing.shtml
+*/
+
+
+dojo.provide("dojo.widget.TreeDndControllerV3");
+
+dojo.require("dojo.dnd.TreeDragAndDropV3");
+dojo.require("dojo.experimental");
+
+dojo.experimental("Tree drag'n'drop' has lots of problems/bugs, it requires dojo drag'n'drop overhaul to work, probably in 0.5");
+	
+dojo.widget.defineWidget(
+	"dojo.widget.TreeDndControllerV3",
+	[dojo.widget.HtmlWidget, dojo.widget.TreeCommon],
+	function() {
+		this.dragSources = {};
+		this.dropTargets = {};
+		this.listenedTrees = {};
+	},
+{
+	listenTreeEvents: ["afterChangeTree","beforeTreeDestroy", "afterAddChild"],
+	listenNodeFilter: function(elem) { return elem instanceof dojo.widget.Widget}, 
+	
+	initialize: function(args) {
+		this.treeController = dojo.lang.isString(args.controller) ? dojo.widget.byId(args.controller) : args.controller;
+		
+		if (!this.treeController) {
+			dojo.raise("treeController must be declared");
+		}
+		
+	},
+
+	onBeforeTreeDestroy: function(message) {
+		this.unlistenTree(message.source);
+	},
+	
+	// first Dnd registration happens in addChild
+	// because I have information about parent on this stage and can use it
+	// to check locking or other things
+	onAfterAddChild: function(message) {
+		//dojo.debug("Dnd addChild "+message.child);
+		this.listenNode(message.child);		
+	},
+
+
+	onAfterChangeTree: function(message) {
+		/* catch new nodes on afterAddChild, because I need parent */		
+		if (!message.oldTree) return;
+		
+		//dojo.debug("HERE");
+		
+		if (!message.newTree || !this.listenedTrees[message.newTree.widgetId]) {			
+			this.processDescendants(message.node, this.listenNodeFilter, this.unlistenNode);
+		}		
+		
+		if (!this.listenedTrees[message.oldTree.widgetId]) {
+			// we have new node
+			this.processDescendants(message.node, this.listenNodeFilter, this.listenNode);	
+		}
+		//dojo.profile.end("onTreeChange");
+	},
+	
+	
+	/**
+	 * Controller(node model) creates DndNodes because it passes itself to node for synchroneous drops processing
+	 * I can't process DnD with events cause an event can't return result success/false
+	*/
+	listenNode: function(node) {
+
+		//dojo.debug("listen dnd "+node);
+		//dojo.debug((new Error()).stack)
+		//dojo.profile.start("Dnd listenNode "+node);		
+		if (!node.tree.DndMode) return;
+		if (this.dragSources[node.widgetId] || this.dropTargets[node.widgetId]) return;
+
+	
+		/* I drag label, not domNode, because large domNodes are very slow to copy and large to drag */
+
+		var source = null;
+		var target = null;
+
+	
+		if (!node.actionIsDisabled(node.actions.MOVE)) {
+			//dojo.debug("reg source")
+			
+			//dojo.profile.start("Dnd source "+node);		
+			var source = this.makeDragSource(node);
+			//dojo.profile.end("Dnd source "+node);		
+
+			this.dragSources[node.widgetId] = source;
+		}
+
+		//dojo.profile.start("Dnd target "+node);		
+		//dojo.debug("reg target");
+		var target = this.makeDropTarget(node);
+		//dojo.profile.end("Dnd target "+node);		
+
+		this.dropTargets[node.widgetId] = target;
+
+		//dojo.profile.end("Dnd listenNode "+node);		
+
+
+	},
+	
+	/**
+	 * Factory method, override it to create special source
+	 */
+	makeDragSource: function(node) {
+		return new dojo.dnd.TreeDragSourceV3(node.contentNode, this, node.tree.widgetId, node);
+	},
+
+
+	/**
+	 * Factory method, override it to create special target
+	 */
+	makeDropTarget: function(node) {
+		 return new dojo.dnd.TreeDropTargetV3(node.contentNode, this.treeController, node.tree.DndAcceptTypes, node);
+	},
+
+	unlistenNode: function(node) {
+
+		if (this.dragSources[node.widgetId]) {
+			dojo.dnd.dragManager.unregisterDragSource(this.dragSources[node.widgetId]);
+			delete this.dragSources[node.widgetId];
+		}
+
+		if (this.dropTargets[node.widgetId]) {
+			dojo.dnd.dragManager.unregisterDropTarget(this.dropTargets[node.widgetId]);
+			delete this.dropTargets[node.widgetId];
+		}
+	}
+
+});

Added: incubator/xap/trunk/codebase/src/dojo/src/widget/TreeDocIconExtension.js
URL: http://svn.apache.org/viewvc/incubator/xap/trunk/codebase/src/dojo/src/widget/TreeDocIconExtension.js?view=auto&rev=518313
==============================================================================
--- incubator/xap/trunk/codebase/src/dojo/src/widget/TreeDocIconExtension.js (added)
+++ incubator/xap/trunk/codebase/src/dojo/src/widget/TreeDocIconExtension.js Wed Mar 14 13:36:44 2007
@@ -0,0 +1,117 @@
+/*
+	Copyright (c) 2004-2006, The Dojo Foundation
+	All Rights Reserved.
+
+	Licensed under the Academic Free License version 2.1 or above OR the
+	modified BSD license. For more information on Dojo licensing, see:
+
+		http://dojotoolkit.org/community/licensing.shtml
+*/
+
+
+dojo.provide("dojo.widget.TreeDocIconExtension");
+
+dojo.require("dojo.widget.HtmlWidget");
+dojo.require("dojo.widget.TreeExtension");
+
+// selector extension to emphasize node
+
+dojo.widget.defineWidget(
+	"dojo.widget.TreeDocIconExtension",
+	[dojo.widget.TreeExtension],
+{
+	/**
+	 * can't unlisten
+	 */
+	
+	templateCssPath: dojo.uri.dojoUri("src/widget/templates/TreeDocIcon.css"),
+
+	
+	listenTreeEvents: ["afterChangeTree","afterSetFolder","afterUnsetFolder"],
+	
+	listenNodeFilter: function(elem) { return elem instanceof dojo.widget.Widget },
+	
+	getnodeDocType: function(node) {
+		var nodeDocType = node.getnodeDocType();
+		if (!nodeDocType) { // set default type
+			nodeDocType = node.isFolder ? "Folder" : "Document";
+		}
+		return nodeDocType;
+	},
+	
+	setnodeDocTypeClass: function(node) {
+		
+		var reg = new RegExp("(^|\\s)"+node.tree.classPrefix+"Icon\\w+",'g');			
+				
+		var clazz = dojo.html.getClass(node.iconNode).replace(reg,'') + ' ' + node.tree.classPrefix+'Icon'+this.getnodeDocType(node);
+		dojo.html.setClass(node.iconNode, clazz);		
+	},
+		
+		
+	onAfterSetFolder: function(message) {
+		//dojo.debug("FOLDER");
+		if (message.source.iconNode) {
+			// on node-initialize time when folder is set there is no iconNode
+			// this case will be processed in treeChange anyway			
+			this.setnodeDocTypeClass(message.source);
+		}
+	},
+	
+	
+	onAfterUnsetFolder: function(message) {
+		this.setnodeDocTypeClass(message.source);
+	},
+		
+	
+	listenNode: function(node) {
+		/**
+		 * add node with document type icon to node template and Tree.iconNodeTemplate
+		 * it will be set to TreeNode.iconNode on node creation
+		 * we do not assign document type yet, its node specific
+		 */
+		//dojo.debug("listenNode in "+node);
+			
+		node.contentIconNode = document.createElement("div");
+		var clazz = node.tree.classPrefix+"IconContent";
+		if (dojo.render.html.ie) {
+			clazz = clazz+' '+ node.tree.classPrefix+"IEIconContent";
+		}
+		dojo.html.setClass(node.contentIconNode, clazz);
+		
+		node.contentNode.parentNode.replaceChild(node.contentIconNode, node.expandNode);
+									  
+	  	node.iconNode = document.createElement("div");
+		dojo.html.setClass(node.iconNode, node.tree.classPrefix+"Icon"+' '+node.tree.classPrefix+'Icon'+this.getnodeDocType(node));
+		
+		node.contentIconNode.appendChild(node.expandNode);
+		node.contentIconNode.appendChild(node.iconNode);
+		
+		dojo.dom.removeNode(node.contentNode);
+		node.contentIconNode.appendChild(node.contentNode);
+		
+	
+		
+		//dojo.html.insertAfter(node.iconNode, node.expandNode);
+		
+		//dojo.debug("listenNode out "+node);
+		
+	},
+			
+	
+	onAfterChangeTree: function(message) {
+		var _this = this;
+		
+		//dojo.debug(message.node)
+		
+		if (!message.oldTree || !this.listenedTrees[message.oldTree.widgetId]) {			
+			// moving from old tree to our tree
+			this.processDescendants(message.node,
+				this.listenNodeFilter,
+				this.listenNode
+			);
+		}
+		
+	}
+	
+
+});

Added: incubator/xap/trunk/codebase/src/dojo/src/widget/TreeEditor.js
URL: http://svn.apache.org/viewvc/incubator/xap/trunk/codebase/src/dojo/src/widget/TreeEditor.js?view=auto&rev=518313
==============================================================================
--- incubator/xap/trunk/codebase/src/dojo/src/widget/TreeEditor.js (added)
+++ incubator/xap/trunk/codebase/src/dojo/src/widget/TreeEditor.js Wed Mar 14 13:36:44 2007
@@ -0,0 +1,111 @@
+/*
+	Copyright (c) 2004-2006, The Dojo Foundation
+	All Rights Reserved.
+
+	Licensed under the Academic Free License version 2.1 or above OR the
+	modified BSD license. For more information on Dojo licensing, see:
+
+		http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.require("dojo.widget.*");
+dojo.require("dojo.widget.HtmlWidget");
+dojo.require("dojo.widget.RichText");
+
+dojo.provide("dojo.widget.TreeEditor");
+
+dojo.widget.defineWidget(
+	"dojo.widget.TreeEditor",
+	dojo.widget.HtmlWidget,
+{
+	singleLineMode: false, // enter saves
+	saveOnBlur: true, // blur or new edit saves current
+	sync: false,  // finish editing in sync/async mode
+	selectOnOpen: true,
+	
+	controller: null,
+		
+	node: null,
+	
+	richTextParams: {styleSheets: 'src/widget/templates/TreeEditor.css'},
+
+	getContents: function() {
+		return this.richText.getEditorContent();
+	},
+	
+	open: function(node) {
+		
+		if (!this.richText) {
+			this.richText = dojo.widget.createWidget("RichText", this.richTextParams, node.labelNode);
+
+			dojo.event.connect("around", this.richText, "onKeyDown", this, "richText_onKeyDown" );
+			dojo.event.connect(this.richText, "onBlur", this, "richText_onBlur" );
+			
+			var self = this;
+			dojo.event.connect(this.richText, "onLoad", function(){
+				if (self.selectOnOpen) {
+					self.richText.execCommand("selectall");
+				}
+			});
+		} else {
+			this.richText.open(node.labelNode);
+		}
+		
+		this.node = node;		
+	},
+	
+	close: function(save) {
+		
+		this.richText.close(save);
+		
+		
+		this.node = null;	
+	},
+	
+	isClosed: function() {
+		return !this.richText || this.richText.isClosed;
+	},
+	
+	execCommand: function() {
+		this.richText.execCommand.apply(this.richText, arguments);
+	},
+	
+	richText_onKeyDown: function(invocation) {
+		var e = invocation.args[0];
+		if((!e)&&(this.object)) {
+			e = dojo.event.browser.fixEvent(this.editor.window.event);
+		}
+		
+		switch (e.keyCode) {
+			case e.KEY_ESCAPE:
+				this.finish(false);
+				dojo.event.browser.stopEvent(e);		
+				break;
+			case e.KEY_ENTER:
+				if( e.ctrlKey && !this.singleLineMode ) {
+					this.execCommand( "inserthtml", "<br/>" );
+							
+				}
+				else {
+					this.finish(true);					
+					//dojo.debug("finish");
+				}
+				dojo.event.browser.stopEvent(e);
+				break;
+			default:
+				return invocation.proceed();
+		}
+	},
+	
+	richText_onBlur: function() {
+		this.finish(this.saveOnBlur);
+	},
+	
+	
+	finish: function(save) {
+		return this.controller.editLabelFinish(save, this.sync);
+	}
+		
+		
+	
+});

Added: incubator/xap/trunk/codebase/src/dojo/src/widget/TreeEmphasizeOnSelect.js
URL: http://svn.apache.org/viewvc/incubator/xap/trunk/codebase/src/dojo/src/widget/TreeEmphasizeOnSelect.js?view=auto&rev=518313
==============================================================================
--- incubator/xap/trunk/codebase/src/dojo/src/widget/TreeEmphasizeOnSelect.js (added)
+++ incubator/xap/trunk/codebase/src/dojo/src/widget/TreeEmphasizeOnSelect.js Wed Mar 14 13:36:44 2007
@@ -0,0 +1,43 @@
+/*
+	Copyright (c) 2004-2006, The Dojo Foundation
+	All Rights Reserved.
+
+	Licensed under the Academic Free License version 2.1 or above OR the
+	modified BSD license. For more information on Dojo licensing, see:
+
+		http://dojotoolkit.org/community/licensing.shtml
+*/
+
+
+dojo.provide("dojo.widget.TreeEmphasizeOnSelect");
+
+dojo.require("dojo.widget.HtmlWidget");
+dojo.require("dojo.widget.TreeSelectorV3");
+dojo.require("dojo.html.selection");
+
+// selector extension to emphasize node
+
+dojo.widget.defineWidget(
+	"dojo.widget.TreeEmphasizeOnSelect",
+	dojo.widget.HtmlWidget,
+{
+	selector: "",
+	
+	initialize: function() {
+		this.selector = dojo.widget.byId(this.selector);
+		
+		dojo.event.topic.subscribe(this.selector.eventNames.select, this, "onSelect");
+		dojo.event.topic.subscribe(this.selector.eventNames.deselect, this, "onDeselect");	
+	},
+
+	
+	onSelect: function(message) {
+		message.node.viewEmphasize()		
+	},
+	
+	onDeselect: function(message) {
+		message.node.viewUnemphasize()
+	}
+	
+
+});

Added: incubator/xap/trunk/codebase/src/dojo/src/widget/TreeExpandToNodeOnSelect.js
URL: http://svn.apache.org/viewvc/incubator/xap/trunk/codebase/src/dojo/src/widget/TreeExpandToNodeOnSelect.js?view=auto&rev=518313
==============================================================================
--- incubator/xap/trunk/codebase/src/dojo/src/widget/TreeExpandToNodeOnSelect.js (added)
+++ incubator/xap/trunk/codebase/src/dojo/src/widget/TreeExpandToNodeOnSelect.js Wed Mar 14 13:36:44 2007
@@ -0,0 +1,47 @@
+/*
+	Copyright (c) 2004-2006, The Dojo Foundation
+	All Rights Reserved.
+
+	Licensed under the Academic Free License version 2.1 or above OR the
+	modified BSD license. For more information on Dojo licensing, see:
+
+		http://dojotoolkit.org/community/licensing.shtml
+*/
+
+
+dojo.provide("dojo.widget.TreeExpandToNodeOnSelect");
+
+dojo.require("dojo.widget.HtmlWidget");
+
+/**
+ * when a node is selected, expands tree to make it visible
+ * useful for program expansion
+ */
+dojo.widget.defineWidget(
+	"dojo.widget.TreeExpandToNodeOnSelect",
+	dojo.widget.HtmlWidget,
+{
+	selector: "",
+	controller: "",
+	
+	/**
+	* if true, then selected node will be expanded too
+	*/
+	withSelected: false,
+	
+	initialize: function() {
+		this.selector = dojo.widget.byId(this.selector);
+		this.controller = dojo.widget.byId(this.controller);
+		
+		dojo.event.topic.subscribe(this.selector.eventNames.select, this, "onSelect");	
+	},
+
+	
+	onSelectEvent: function(message) {
+		this.controller.expandToNode(message.node, this.withSelected)		
+	}
+	
+	
+	
+
+});

Added: incubator/xap/trunk/codebase/src/dojo/src/widget/TreeExtension.js
URL: http://svn.apache.org/viewvc/incubator/xap/trunk/codebase/src/dojo/src/widget/TreeExtension.js?view=auto&rev=518313
==============================================================================
--- incubator/xap/trunk/codebase/src/dojo/src/widget/TreeExtension.js (added)
+++ incubator/xap/trunk/codebase/src/dojo/src/widget/TreeExtension.js Wed Mar 14 13:36:44 2007
@@ -0,0 +1,24 @@
+/*
+	Copyright (c) 2004-2006, The Dojo Foundation
+	All Rights Reserved.
+
+	Licensed under the Academic Free License version 2.1 or above OR the
+	modified BSD license. For more information on Dojo licensing, see:
+
+		http://dojotoolkit.org/community/licensing.shtml
+*/
+
+
+dojo.provide("dojo.widget.TreeExtension");
+
+dojo.require("dojo.widget.HtmlWidget");
+dojo.require("dojo.widget.TreeCommon");
+
+dojo.widget.defineWidget(
+	"dojo.widget.TreeExtension",
+	[dojo.widget.HtmlWidget, dojo.widget.TreeCommon],
+	function() {
+		this.listenedTrees = {};
+	},
+	{}
+);

Added: incubator/xap/trunk/codebase/src/dojo/src/widget/TreeLinkExtension.js
URL: http://svn.apache.org/viewvc/incubator/xap/trunk/codebase/src/dojo/src/widget/TreeLinkExtension.js?view=auto&rev=518313
==============================================================================
--- incubator/xap/trunk/codebase/src/dojo/src/widget/TreeLinkExtension.js (added)
+++ incubator/xap/trunk/codebase/src/dojo/src/widget/TreeLinkExtension.js Wed Mar 14 13:36:44 2007
@@ -0,0 +1,73 @@
+/*
+	Copyright (c) 2004-2006, The Dojo Foundation
+	All Rights Reserved.
+
+	Licensed under the Academic Free License version 2.1 or above OR the
+	modified BSD license. For more information on Dojo licensing, see:
+
+		http://dojotoolkit.org/community/licensing.shtml
+*/
+
+
+dojo.provide("dojo.widget.TreeLinkExtension");
+
+dojo.require("dojo.widget.HtmlWidget");
+dojo.require("dojo.widget.TreeExtension");
+
+dojo.widget.defineWidget(
+	"dojo.widget.TreeLinkExtension",
+	dojo.widget.TreeExtension,
+	function() {
+		this.params = {};
+	},
+{
+	/**
+	 * can only listen, no unlisten
+	 */
+
+	listenTreeEvents: ["afterChangeTree"],	
+
+	listenTree: function(tree) {
+		
+		dojo.widget.TreeCommon.prototype.listenTree.call(this,tree);
+		
+		var labelNode = tree.labelNodeTemplate;
+		var newLabel = this.makeALabel();
+		dojo.html.setClass(newLabel, dojo.html.getClass(labelNode));
+		labelNode.parentNode.replaceChild(newLabel, labelNode);		
+	},
+	
+		
+	
+	makeALabel: function() {		
+		var newLabel = document.createElement("a");
+		
+		for(var key in this.params) {
+			if (key in {}) continue;
+			newLabel.setAttribute(key, this.params[key]);
+		}
+		
+		return newLabel;
+	},
+		
+	
+	onAfterChangeTree: function(message) {
+		var _this = this;
+		
+		
+		// only for new nodes
+		if (!message.oldTree) {
+			this.listenNode(message.node);
+		}
+		
+	},
+	
+	listenNode: function(node) {
+		for(var key in node.object) {
+			if (key in {}) continue;
+			node.labelNode.setAttribute(key, node.object[key]);
+		}
+	}
+
+
+});

Added: incubator/xap/trunk/codebase/src/dojo/src/widget/TreeLoadingController.js
URL: http://svn.apache.org/viewvc/incubator/xap/trunk/codebase/src/dojo/src/widget/TreeLoadingController.js?view=auto&rev=518313
==============================================================================
--- incubator/xap/trunk/codebase/src/dojo/src/widget/TreeLoadingController.js (added)
+++ incubator/xap/trunk/codebase/src/dojo/src/widget/TreeLoadingController.js Wed Mar 14 13:36:44 2007
@@ -0,0 +1,205 @@
+/*
+	Copyright (c) 2004-2006, The Dojo Foundation
+	All Rights Reserved.
+
+	Licensed under the Academic Free License version 2.1 or above OR the
+	modified BSD license. For more information on Dojo licensing, see:
+
+		http://dojotoolkit.org/community/licensing.shtml
+*/
+
+
+dojo.provide("dojo.widget.TreeLoadingController");
+
+dojo.require("dojo.widget.TreeBasicController");
+dojo.require("dojo.event.*");
+dojo.require("dojo.json")
+dojo.require("dojo.io.*");
+
+
+dojo.widget.defineWidget("dojo.widget.TreeLoadingController", dojo.widget.TreeBasicController, {
+	RPCUrl: "",
+
+	RPCActionParam: "action", // used for GET for RPCUrl
+
+
+	/**
+	 * Common RPC error handler (dies)
+	*/
+	RPCErrorHandler: function(type, obj, evt) {
+		alert( "RPC Error: " + (obj.message||"no message"));
+	},
+
+	preventCache: true,
+
+	getRPCUrl: function(action) {
+
+		// RPCUrl=local meant SOLELY for DEMO and LOCAL TESTS.
+		// May lead to widgetId collisions
+		if (this.RPCUrl == "local") {
+			var dir = document.location.href.substr(0, document.location.href.lastIndexOf('/'));
+			var localUrl = dir+"/"+action;
+			//dojo.debug(localUrl);
+			return localUrl;
+		}
+
+		if (!this.RPCUrl) {
+			dojo.raise("Empty RPCUrl: can't load");
+		}
+
+		return this.RPCUrl + ( this.RPCUrl.indexOf("?") > -1 ? "&" : "?") + this.RPCActionParam+"="+action;
+	},
+
+
+	/**
+	 * Add all loaded nodes from array obj as node children and expand it
+	*/
+	loadProcessResponse: function(node, result, callObj, callFunc) {
+
+		if (!dojo.lang.isUndefined(result.error)) {
+			this.RPCErrorHandler("server", result.error);
+			return false;
+		}
+
+		//dojo.debugShallow(result);
+
+		var newChildren = result;
+
+		if (!dojo.lang.isArray(newChildren)) {
+			dojo.raise('loadProcessResponse: Not array loaded: '+newChildren);
+		}
+
+		for(var i=0; i<newChildren.length; i++) {
+			// looks like dojo.widget.manager needs no special "add" command
+			newChildren[i] = dojo.widget.createWidget(node.widgetType, newChildren[i]);
+			node.addChild(newChildren[i]);
+		}
+
+
+		//node.addAllChildren(newChildren);
+
+		node.state = node.loadStates.LOADED;
+
+		//dojo.debug(callFunc);
+
+		if (dojo.lang.isFunction(callFunc)) {
+			callFunc.apply(dojo.lang.isUndefined(callObj) ? this : callObj, [node, newChildren]);
+		}
+		//this.expand(node);
+	},
+
+	getInfo: function(obj) {
+		return obj.getInfo();
+	},
+
+	runRPC: function(kw) {
+		var _this = this;
+
+		var handle = function(type, data, evt) {
+			// unlock BEFORE any processing is done
+			// so errorHandler may apply locking
+			if (kw.lock) {
+				dojo.lang.forEach(kw.lock,
+					function(t) { t.unlock() }
+				);
+			}
+
+			if(type == "load"){
+				kw.load.call(this, data);
+			}else{
+				this.RPCErrorHandler(type, data, evt);
+			}
+
+		}
+
+		if (kw.lock) {
+			dojo.lang.forEach(kw.lock,
+				function(t) { t.lock() }
+			);
+		}
+
+
+		dojo.io.bind({
+			url: kw.url,
+			/* I hitch to get this.loadOkHandler */
+			handle: dojo.lang.hitch(this, handle),
+			mimetype: "text/json",
+			preventCache: _this.preventCache,
+			sync: kw.sync,
+			content: { data: dojo.json.serialize(kw.params) }
+		});
+	},
+
+
+
+	/**
+	 * Load children of the node from server
+	 * Synchroneous loading doesn't break control flow
+	 * I need sync mode for DnD
+	*/
+	loadRemote: function(node, sync, callObj, callFunc){
+		var _this = this;
+
+		var params = {
+			node: this.getInfo(node),
+			tree: this.getInfo(node.tree)
+		};
+
+		//dojo.debug(callFunc)
+
+		this.runRPC({
+			url: this.getRPCUrl('getChildren'),
+			load: function(result) {
+				_this.loadProcessResponse(node, result, callObj, callFunc) ;
+			},
+			sync: sync,
+			lock: [node],
+			params: params
+		});
+
+	},
+
+
+	expand: function(node, sync, callObj, callFunc) {
+
+		if (node.state == node.loadStates.UNCHECKED && node.isFolder) {
+
+			this.loadRemote(node, sync,
+				this,
+				function(node, newChildren) {
+					this.expand(node, sync, callObj, callFunc);
+				}
+			);
+
+			return;
+		}
+
+		dojo.widget.TreeBasicController.prototype.expand.apply(this, arguments);
+
+	},
+
+
+
+	doMove: function(child, newParent, index) {
+		/* load nodes into newParent in sync mode, if needed, first */
+		if (newParent.isTreeNode && newParent.state == newParent.loadStates.UNCHECKED) {
+			this.loadRemote(newParent, true);
+		}
+
+		return dojo.widget.TreeBasicController.prototype.doMove.apply(this, arguments);
+	},
+
+
+	doCreateChild: function(parent, index, data, callObj, callFunc) {
+
+		/* load nodes into newParent in sync mode, if needed, first */
+		if (parent.state == parent.loadStates.UNCHECKED) {
+			this.loadRemote(parent, true);
+		}
+
+		return dojo.widget.TreeBasicController.prototype.doCreateChild.apply(this, arguments);
+	}
+
+
+
+});

Added: incubator/xap/trunk/codebase/src/dojo/src/widget/TreeLoadingControllerV3.js
URL: http://svn.apache.org/viewvc/incubator/xap/trunk/codebase/src/dojo/src/widget/TreeLoadingControllerV3.js?view=auto&rev=518313
==============================================================================
--- incubator/xap/trunk/codebase/src/dojo/src/widget/TreeLoadingControllerV3.js (added)
+++ incubator/xap/trunk/codebase/src/dojo/src/widget/TreeLoadingControllerV3.js Wed Mar 14 13:36:44 2007
@@ -0,0 +1,496 @@
+/*
+	Copyright (c) 2004-2006, The Dojo Foundation
+	All Rights Reserved.
+
+	Licensed under the Academic Free License version 2.1 or above OR the
+	modified BSD license. For more information on Dojo licensing, see:
+
+		http://dojotoolkit.org/community/licensing.shtml
+*/
+
+
+dojo.provide("dojo.widget.TreeLoadingControllerV3");
+
+dojo.require("dojo.widget.TreeBasicControllerV3");
+dojo.require("dojo.event.*");
+dojo.require("dojo.json")
+dojo.require("dojo.io.*");
+dojo.require("dojo.Deferred");
+dojo.require("dojo.DeferredList");
+
+dojo.declare(
+	"dojo.Error",
+	Error,
+	function(message, extra) {
+		this.message = message;
+		this.extra = extra;
+		this.stack = (new Error()).stack;	
+	}
+);
+
+dojo.declare(
+	"dojo.CommunicationError",
+	dojo.Error,
+	function() {
+		this.name="CommunicationError";
+	}
+);
+
+dojo.declare(
+	"dojo.LockedError",
+	dojo.Error,
+	function() {
+		this.name="LockedError";
+	}
+);
+
+dojo.declare(
+	"dojo.FormatError",
+	dojo.Error,
+	function() {
+		this.name="FormatError";
+	}
+);
+
+dojo.declare(
+	"dojo.RpcError",
+	dojo.Error,
+	function() {
+		this.name="RpcError";
+	}
+);
+
+dojo.widget.defineWidget(
+	"dojo.widget.TreeLoadingControllerV3",
+	dojo.widget.TreeBasicControllerV3,
+{	
+	RpcUrl: "",
+
+	RpcActionParam: "action", // used for GET for RpcUrl
+
+	preventCache: true,
+
+	checkValidRpcResponse: function(type, obj) {
+		if (type != "load") {
+			var extra = {}				
+			for(var i=1; i<arguments.length;i++) {
+				dojo.lang.mixin(extra, arguments[i]);					
+			}
+			return new dojo.CommunicationError(obj, extra);				
+		}
+		
+		if (typeof obj != 'object') {
+			return new dojo.FormatError("Wrong server answer format "+(obj && obj.toSource ? obj.toSource() : obj)+" type "+(typeof obj), obj);
+		}
+		
+		//dojo.debugShallow(obj);
+			
+		if (!dojo.lang.isUndefined(obj.error)) {
+			return new dojo.RpcError(obj.error, obj);
+		}
+		
+		return false;
+	},
+		
+
+	getDeferredBindHandler: function(/* dojo.rpc.Deferred */ deferred){
+		// summary
+		// create callback that calls the Deferred's callback method		
+		
+		return dojo.lang.hitch(this, 
+			function(type, obj){				
+				//dojo.debug("getDeferredBindHandler "+obj.toSource());
+								
+				var error = this.checkValidRpcResponse.apply(this, arguments);
+				
+				if (error) {
+					deferred.errback(error);
+					return;
+				}
+	
+				deferred.callback(obj);								
+			}
+		);
+		
+	},
+
+	getRpcUrl: function(action) {
+
+		// RpcUrl=local meant SOLELY for DEMO and LOCAL TESTS
+		if (this.RpcUrl == "local") {
+			var dir = document.location.href.substr(0, document.location.href.lastIndexOf('/'));
+			var localUrl = dir+"/local/"+action;
+			//dojo.debug(localUrl);
+			return localUrl;	
+		}
+
+		if (!this.RpcUrl) {
+			dojo.raise("Empty RpcUrl: can't load");
+		}
+		
+		var url = this.RpcUrl;
+		
+		if (url.indexOf("/") != 0) { // not absolute
+			var protocol = document.location.href.replace(/:\/\/.*/,'');
+			var prefix = document.location.href.substring(protocol.length+3);
+			
+			if (prefix.lastIndexOf("/") != prefix.length-1) {
+				prefix = prefix.replace(/\/[^\/]+$/,'/'); // strip file name
+			}
+			if (prefix.lastIndexOf("/") != prefix.length-1) {
+				prefix = prefix+'/'; // add / if not exists it all
+			}
+			//dojo.debug(url);
+			url = protocol + '://' + prefix + url;
+		}
+			
+
+		return url + (url.indexOf("?")>-1 ? "&" : "?") + this.RpcActionParam+"="+action;
+	},
+
+
+	/**
+	 * Add all loaded nodes from array obj as node children and expand it
+	*/
+	loadProcessResponse: function(node, result) {
+		//dojo.debug("Process response "+node);
+				
+		if (!dojo.lang.isArray(result)) {
+			throw new dojo.FormatError('loadProcessResponse: Not array loaded: '+result);
+		}
+
+		node.setChildren(result);
+		
+	},
+
+	/**
+	 * kw = { url, sync, params }
+	 */
+	runRpc: function(kw) {
+		var _this = this;
+		
+		var deferred = new dojo.Deferred();
+		
+		dojo.io.bind({
+			url: kw.url,			
+			handle: this.getDeferredBindHandler(deferred),
+			mimetype: "text/javascript",
+			preventCache: this.preventCache,
+			sync: kw.sync,
+			content: { data: dojo.json.serialize(kw.params) }
+		});
+		
+		return deferred;
+
+	},
+
+
+
+	/**
+	 * Load children of the node from server
+	 * Synchroneous loading doesn't break control flow
+	 * I need sync mode for DnD
+	*/
+	loadRemote: function(node, sync){
+		var _this = this;
+
+		var params = {
+			node: this.getInfo(node),
+			tree: this.getInfo(node.tree)
+		};
+
+		
+		var deferred = this.runRpc({
+			url: this.getRpcUrl('getChildren'),
+			sync: sync,
+			params: params
+		});
+		
+		deferred.addCallback(function(res) { return _this.loadProcessResponse(node,res) });
+		
+				
+		
+		return deferred;
+
+	},
+
+	batchExpandTimeout: 0,
+
+	recurseToLevel: function(widget, level, callFunc, callObj, skipFirst, sync) {
+		if (level == 0) return;
+
+
+		
+		if (!skipFirst) {
+			var deferred = callFunc.call(callObj, widget, sync);
+		} else {
+			var deferred = dojo.Deferred.prototype.makeCalled();
+		}
+		
+		//dojo.debug("expand deferred saved "+node+" sync "+sync);
+		
+		
+		var _this = this;
+		
+		var recurseOnExpand = function() {
+			var children = widget.children;
+			var deferreds = [];		
+			for(var i=0; i<children.length; i++) {
+				//dojo.debug("push recursive call for "+node.children[i]+" level "+level);
+				deferreds.push(_this.recurseToLevel(children[i], level-1, callFunc, callObj, sync));
+			}
+			return new dojo.DeferredList(deferreds);
+		}
+		
+		deferred.addCallback(recurseOnExpand);
+		
+		return deferred;
+	},
+	
+	
+	expandToLevel: function(nodeOrTree, level, sync) {
+		return this.recurseToLevel(nodeOrTree, nodeOrTree.isTree ? level+1 : level, this.expand, this, nodeOrTree.isTree, sync);
+	},
+	
+	loadToLevel: function(nodeOrTree, level, sync) {
+		return this.recurseToLevel(nodeOrTree, nodeOrTree.isTree ? level+1 : level, this.loadIfNeeded, this, nodeOrTree.isTree, sync);
+	},
+	
+	
+	loadAll: function(nodeOrTree, sync) {
+		return this.loadToLevel(nodeOrTree, Number.POSITIVE_INFINITY, sync);
+	},
+		
+	
+	
+	expand: function(node, sync) {		
+		// widget which children are data objects, is UNCHECKED, but has children and shouldn't be loaded
+		// so I put children check here too
+		
+		var _this = this;
+		
+		var deferred = this.startProcessing(node);
+		
+		deferred.addCallback(function() {
+			return _this.loadIfNeeded(node, sync);
+		});
+				
+		deferred.addCallback(function(res) {
+			//dojo.debug("Activated callback dojo.widget.TreeBasicControllerV3.prototype.expand(node); "+res);
+			dojo.widget.TreeBasicControllerV3.prototype.expand(node);
+			return res;
+		});
+		
+		deferred.addBoth(function(res) {
+			_this.finishProcessing(node);
+			return res;
+		});
+		
+		
+		
+		return deferred;
+	},
+
+	
+	loadIfNeeded: function(node, sync) {
+		var deferred
+		if (node.state == node.loadStates.UNCHECKED && node.isFolder && !node.children.length) {
+			// populate deferred with other things to pre-do
+			deferred = this.loadRemote(node, sync);			
+		} else {
+			/* "fake action" here */
+			deferred = new dojo.Deferred();
+			deferred.callback();
+		}
+		
+		return deferred;
+	},
+	
+	/**
+	 * 1) if specified, run check, return false if failed
+	 * 2) if specified, run prepare
+	 * 3) run make if prepare if no errors
+	 * 4) run finalize no matter what happened, pass through make result
+	 * 5) if specified, run expose if no errors
+	 */
+	runStages: function(check, prepare, make, finalize, expose, args) {
+		var _this = this;
+		
+		if (check && !check.apply(this, args)) {
+			return false;
+		}
+		
+		var deferred = dojo.Deferred.prototype.makeCalled();
+		
+		
+		if (prepare) {
+			deferred.addCallback(function() {
+				return prepare.apply(_this, args);
+			});
+		}
+		
+		
+		//deferred.addCallback(function(res) { dojo.debug("Prepare fired "+res); return res});
+		
+		if (make) {
+			deferred.addCallback(function() {			
+			var res = make.apply(_this, args);
+			//res.addBoth(function(r) {dojo.debugShallow(r); return r;});
+			return res;
+			});
+		}
+		
+		//deferred.addCallback(function(res) { dojo.debug("Main fired "+res); return res});
+		
+		if (finalize) {
+			deferred.addBoth(function(res) {
+				finalize.apply(_this, args);
+				return res;
+			});
+		}
+			
+				
+		// exposer does not affect result
+		if (expose) {
+			deferred.addCallback(function(res) {
+				expose.apply(_this, args);
+				return res;
+			});
+		}
+		
+		return deferred;
+	},
+		
+	startProcessing: function(nodesArray) {
+		var deferred = new dojo.Deferred();
+		
+		
+		var nodes = dojo.lang.isArray(nodesArray) ? nodesArray : arguments;
+		
+		/*
+		for(var i=0;i<nodes.length;i++) {
+			dojo.debug(nodes[i]);
+		}*/
+		
+		for(var i=0;i<nodes.length;i++) {
+			if (nodes[i].isLocked()) {
+				deferred.errback(new dojo.LockedError("item locked "+nodes[i], nodes[i]));
+				//dojo.debug("startProcessing errback "+arguments[i]);
+				return deferred;
+			}
+			if (nodes[i].isTreeNode) {
+				//dojo.debug("mark "+nodes[i]);
+				nodes[i].markProcessing();
+			}
+			nodes[i].lock();
+		}
+				
+		//dojo.debug("startProcessing callback");
+				
+		deferred.callback();
+		
+		return deferred;
+	},
+	
+	finishProcessing: function(nodesArray) {
+		
+		var nodes = dojo.lang.isArray(nodesArray) ? nodesArray : arguments;
+		
+		for(var i=0;i<nodes.length;i++) {
+			if (!nodes[i].hasLock()) {
+				// is not processed. probably we locked it and then met bad node in startProcessing
+				continue; 
+			}
+			//dojo.debug("has lock");	
+			nodes[i].unlock();
+			if (nodes[i].isTreeNode) {
+				//dojo.debug("unmark "+nodes[i]);
+				nodes[i].unmarkProcessing();
+			}
+		}
+	},
+	
+	// ----------------- refresh -----------------
+	
+	refreshChildren: function(nodeOrTree, sync) {		
+		return this.runStages(null, this.prepareRefreshChildren, this.doRefreshChildren, this.finalizeRefreshChildren, this.exposeRefreshChildren, arguments);
+	},
+
+
+	prepareRefreshChildren: function(nodeOrTree, sync) {
+		var deferred = this.startProcessing(nodeOrTree);
+		nodeOrTree.destroyChildren();
+						
+		nodeOrTree.state = nodeOrTree.loadStates.UNCHECKED;
+		
+		return deferred;
+	},
+	
+	doRefreshChildren: function(nodeOrTree, sync) {
+		return this.loadRemote(nodeOrTree, sync);
+	},
+	
+	finalizeRefreshChildren: function(nodeOrTree, sync) {
+		this.finishProcessing(nodeOrTree);
+	},
+	
+	exposeRefreshChildren: function(nodeOrTree, sync) {
+		nodeOrTree.expand();
+	},
+
+	// ----------------- move -----------------
+
+	move: function(child, newParent, index/*,...*/) {
+		return this.runStages(this.canMove, this.prepareMove, this.doMove, this.finalizeMove, this.exposeMove, arguments);			
+	},
+
+	doMove: function(child, newParent, index) {
+		//dojo.debug("MOVE "+child);
+		child.tree.move(child, newParent, index);
+
+		return true;
+	},
+	
+	
+	prepareMove: function(child, newParent, index, sync) {
+		var deferred = this.startProcessing(newParent);
+		deferred.addCallback(dojo.lang.hitch(this, function() {
+			return this.loadIfNeeded(newParent, sync);
+		}));
+		return deferred;
+	},
+	
+	finalizeMove: function(child, newParent) {
+		this.finishProcessing(newParent);
+	},
+
+	// -------------------- createChild ------------
+
+	prepareCreateChild: function(parent, index, data, sync) {
+		var deferred = this.startProcessing(parent);
+		
+		deferred.addCallback(dojo.lang.hitch(this, function() {
+			return this.loadIfNeeded(parent, sync);
+		}));
+		return deferred;
+	},
+	
+	finalizeCreateChild: function(parent) {
+		this.finishProcessing(parent);
+	},
+
+	// ---------------- clone ---------------
+	
+	prepareClone: function(child, newParent, index, deep, sync) {
+		var deferred = this.startProcessing(child, newParent);
+		deferred.addCallback(dojo.lang.hitch(this, function() {
+			return this.loadIfNeeded(newParent, sync);
+		}));		
+		return deferred;	
+	},	
+	
+	finalizeClone: function(child, newParent) {
+		this.finishProcessing(child, newParent);
+	}
+
+});



Mime
View raw message