jackrabbit-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From edgarp...@apache.org
Subject svn commit: r473755 [11/43] - in /jackrabbit/trunk/contrib/jcr-browser: ./ src/ src/main/ src/main/java/ src/main/java/org/ src/main/java/org/apache/ src/main/java/org/apache/jackrabbit/ src/main/java/org/apache/jackrabbit/browser/ src/main/resources/ ...
Date Sat, 11 Nov 2006 16:44:48 GMT
Added: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/dnd/HtmlDragManager.js
URL: http://svn.apache.org/viewvc/jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/dnd/HtmlDragManager.js?view=auto&rev=473755
==============================================================================
--- jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/dnd/HtmlDragManager.js (added)
+++ jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/dnd/HtmlDragManager.js Sat Nov 11 08:44:22 2006
@@ -0,0 +1,495 @@
+dojo.provide("dojo.dnd.HtmlDragManager");
+dojo.require("dojo.dnd.DragAndDrop");
+dojo.require("dojo.event.*");
+dojo.require("dojo.lang.array");
+dojo.require("dojo.html.common");
+dojo.require("dojo.html.layout");
+
+// NOTE: there will only ever be a single instance of HTMLDragManager, so it's
+// safe to use prototype properties for book-keeping.
+dojo.declare("dojo.dnd.HtmlDragManager", dojo.dnd.DragManager, {
+	/**
+	 * There are several sets of actions that the DnD code cares about in the
+	 * HTML context:
+	 *	1.) mouse-down ->
+	 *			(draggable selection)
+	 *			(dragObject generation)
+	 *		mouse-move ->
+	 *			(draggable movement)
+	 *			(droppable detection)
+	 *			(inform droppable)
+	 *			(inform dragObject)
+	 *		mouse-up
+	 *			(inform/destroy dragObject)
+	 *			(inform draggable)
+	 *			(inform droppable)
+	 *	2.) mouse-down -> mouse-down
+	 *			(click-hold context menu)
+	 *	3.) mouse-click ->
+	 *			(draggable selection)
+	 *		shift-mouse-click ->
+	 *			(augment draggable selection)
+	 *		mouse-down ->
+	 *			(dragObject generation)
+	 *		mouse-move ->
+	 *			(draggable movement)
+	 *			(droppable detection)
+	 *			(inform droppable)
+	 *			(inform dragObject)
+	 *		mouse-up
+	 *			(inform draggable)
+	 *			(inform droppable)
+	 *	4.) mouse-up
+	 *			(clobber draggable selection)
+	 */
+	disabled: false, // to kill all dragging!
+	nestedTargets: false,
+	mouseDownTimer: null, // used for click-hold operations
+	dsCounter: 0,
+	dsPrefix: "dojoDragSource",
+
+	// dimension calculation cache for use durring drag
+	dropTargetDimensions: [],
+
+	currentDropTarget: null,
+	// currentDropTargetPoints: null,
+	previousDropTarget: null,
+	_dragTriggered: false,
+
+	selectedSources: [],
+	dragObjects: [],
+
+	// mouse position properties
+	currentX: null,
+	currentY: null,
+	lastX: null,
+	lastY: null,
+	mouseDownX: null,
+	mouseDownY: null,
+	threshold: 7,
+
+	dropAcceptable: false,
+
+	cancelEvent: function(e){ e.stopPropagation(); e.preventDefault();},
+
+	// method over-rides
+	registerDragSource: function(ds){
+		//dojo.profile.start("register DragSource");
+
+		if(ds["domNode"]){
+			// FIXME: dragSource objects SHOULD have some sort of property that
+			// references their DOM node, we shouldn't just be passing nodes and
+			// expecting it to work.
+			//dojo.profile.start("register DragSource 1");
+			var dp = this.dsPrefix;
+			var dpIdx = dp+"Idx_"+(this.dsCounter++);
+			ds.dragSourceId = dpIdx;
+			this.dragSources[dpIdx] = ds;
+			ds.domNode.setAttribute(dp, dpIdx);
+			//dojo.profile.end("register DragSource 1");
+
+			//dojo.profile.start("register DragSource 2");
+
+			// so we can drag links
+			if(dojo.render.html.ie){
+				//dojo.profile.start("register DragSource IE");
+				
+				dojo.event.browser.addListener(ds.domNode, "ondragstart", this.cancelEvent);
+				// terribly slow
+				//dojo.event.connect(ds.domNode, "ondragstart", this.cancelEvent);
+				//dojo.profile.end("register DragSource IE");
+
+			}
+			//dojo.profile.end("register DragSource 2");
+
+		}
+		//dojo.profile.end("register DragSource");
+	},
+
+	unregisterDragSource: function(ds){
+		if (ds["domNode"]){
+			var dp = this.dsPrefix;
+			var dpIdx = ds.dragSourceId;
+			delete ds.dragSourceId;
+			delete this.dragSources[dpIdx];
+			ds.domNode.setAttribute(dp, null);
+			if(dojo.render.html.ie){
+				dojo.event.browser.removeListener(ds.domNode, "ondragstart", this.cancelEvent);			
+			}
+		}
+	},
+
+	registerDropTarget: function(dt){
+		this.dropTargets.push(dt);
+	},
+
+	unregisterDropTarget: function(dt){
+		var index = dojo.lang.find(this.dropTargets, dt, true);
+		if (index>=0) {
+			this.dropTargets.splice(index, 1);
+		}
+	},
+
+	/**
+	* Get the DOM element that is meant to drag.
+	* Loop through the parent nodes of the event target until
+	* the element is found that was created as a DragSource and 
+	* return it.
+	*
+	* @param event object The event for which to get the drag source.
+	*/
+	getDragSource: function(e){
+		var tn = e.target;
+		if(tn === dojo.body()){ return; }
+		var ta = dojo.html.getAttribute(tn, this.dsPrefix);
+		while((!ta)&&(tn)){
+			tn = tn.parentNode;
+			if((!tn)||(tn === dojo.body())){ return; }
+			ta = dojo.html.getAttribute(tn, this.dsPrefix);
+		}
+		return this.dragSources[ta];
+	},
+
+	onKeyDown: function(e){
+	},
+
+	onMouseDown: function(e){
+		if(this.disabled) { return; }
+
+		// only begin on left click
+		if(dojo.render.html.ie) {
+			if(e.button != 1) { return; }
+		} else if(e.which != 1) {
+			return;
+		}
+
+		var target = e.target.nodeType == dojo.html.TEXT_NODE ?
+			e.target.parentNode : e.target;
+
+		// do not start drag involvement if the user is interacting with
+		// a form element.
+		if(dojo.html.isTag(target, "button", "textarea", "input", "select", "option")) {
+			return;
+		}
+
+		// find a selection object, if one is a parent of the source node
+		var ds = this.getDragSource(e);
+		
+		// this line is important.  if we aren't selecting anything then
+		// we need to return now, so preventDefault() isn't called, and thus
+		// the event is propogated to other handling code
+		if(!ds){ return; }
+
+		if(!dojo.lang.inArray(this.selectedSources, ds)){
+			this.selectedSources.push(ds);
+			ds.onSelected();
+		}
+
+ 		this.mouseDownX = e.pageX;
+ 		this.mouseDownY = e.pageY;
+
+		// Must stop the mouse down from being propogated, or otherwise can't
+		// drag links in firefox.
+		// WARNING: preventing the default action on all mousedown events
+		// prevents user interaction with the contents.
+		e.preventDefault();
+
+		dojo.event.connect(document, "onmousemove", this, "onMouseMove");
+	},
+
+	onMouseUp: function(e, cancel){
+		// if we aren't dragging then ignore the mouse-up
+		// (in particular, don't call preventDefault(), because other
+		// code may need to process this event)
+		if(this.selectedSources.length==0){
+			return;
+		}
+
+		this.mouseDownX = null;
+		this.mouseDownY = null;
+		this._dragTriggered = false;
+ 		// e.preventDefault();
+		e.dragSource = this.dragSource;
+		// let ctrl be used for multiselect or another action
+		// if I use same key to trigger treeV3 node selection and here,
+		// I have bugs with drag'n'drop. why ?? no idea..
+		if((!e.shiftKey)&&(!e.ctrlKey)){ 
+		//if(!e.shiftKey){
+			if(this.currentDropTarget) {
+				this.currentDropTarget.onDropStart();
+			}
+			dojo.lang.forEach(this.dragObjects, function(tempDragObj){
+				var ret = null;
+				if(!tempDragObj){ return; }
+				if(this.currentDropTarget) {
+					e.dragObject = tempDragObj;
+
+					// NOTE: we can't get anything but the current drop target
+					// here since the drag shadow blocks mouse-over events.
+					// This is probelematic for dropping "in" something
+					var ce = this.currentDropTarget.domNode.childNodes;
+					if(ce.length > 0){
+						e.dropTarget = ce[0];
+						while(e.dropTarget == tempDragObj.domNode){
+							e.dropTarget = e.dropTarget.nextSibling;
+						}
+					}else{
+						e.dropTarget = this.currentDropTarget.domNode;
+					}
+					if(this.dropAcceptable){
+						ret = this.currentDropTarget.onDrop(e);
+					}else{
+						 this.currentDropTarget.onDragOut(e);
+					}
+				}
+
+				e.dragStatus = this.dropAcceptable && ret ? "dropSuccess" : "dropFailure";
+				// decouple the calls for onDragEnd, so they don't block the execution here
+				// ie. if the onDragEnd would call an alert, the execution here is blocked until the
+				// user has confirmed the alert box and then the rest of the dnd code is executed
+				// while the mouse doesnt "hold" the dragged object anymore ... and so on
+				dojo.lang.delayThese([
+					function() {
+						// in FF1.5 this throws an exception, see 
+						// http://dojotoolkit.org/pipermail/dojo-interest/2006-April/006751.html
+						try{
+							tempDragObj.dragSource.onDragEnd(e)
+						} catch(err) {
+							// since the problem seems passing e, we just copy all 
+							// properties and try the copy ...
+							var ecopy = {};
+							for (var i in e) {
+								if (i=="type") { // the type property contains the exception, no idea why...
+									ecopy.type = "mouseup";
+									continue;
+								}
+								ecopy[i] = e[i];
+							}
+							tempDragObj.dragSource.onDragEnd(ecopy);
+						}
+					}
+					, function() {tempDragObj.onDragEnd(e)}]);
+			}, this);
+
+			this.selectedSources = [];
+			this.dragObjects = [];
+			this.dragSource = null;
+			if(this.currentDropTarget) {
+				this.currentDropTarget.onDropEnd();
+			}
+		} else {
+			//dojo.debug("special click");
+		}
+
+		dojo.event.disconnect(document, "onmousemove", this, "onMouseMove");
+		this.currentDropTarget = null;
+	},
+
+	onScroll: function(){
+		//dojo.profile.start("DNDManager updateoffset");
+		for(var i = 0; i < this.dragObjects.length; i++) {
+			if(this.dragObjects[i].updateDragOffset) {
+				this.dragObjects[i].updateDragOffset();
+			}
+		}
+		//dojo.profile.end("DNDManager updateoffset");
+
+		// TODO: do not recalculate, only adjust coordinates
+		if (this.dragObjects.length) {
+			this.cacheTargetLocations();
+		}
+	},
+
+	_dragStartDistance: function(x, y){
+		if((!this.mouseDownX)||(!this.mouseDownX)){
+			return;
+		}
+		var dx = Math.abs(x-this.mouseDownX);
+		var dx2 = dx*dx;
+		var dy = Math.abs(y-this.mouseDownY);
+		var dy2 = dy*dy;
+		return parseInt(Math.sqrt(dx2+dy2), 10);
+	},
+
+	cacheTargetLocations: function(){
+		dojo.profile.start("cacheTargetLocations");
+
+		this.dropTargetDimensions = [];
+		dojo.lang.forEach(this.dropTargets, function(tempTarget){
+			var tn = tempTarget.domNode;
+			//only cache dropTarget which can accept current dragSource
+			if(!tn || dojo.lang.find(tempTarget.acceptedTypes, this.dragSource.type) < 0){ return; }
+			var abs = dojo.html.getAbsolutePosition(tn, true);
+			var bb = dojo.html.getBorderBox(tn);
+			this.dropTargetDimensions.push([
+				[abs.x, abs.y],	// upper-left
+				// lower-right
+				[ abs.x+bb.width, abs.y+bb.height ],
+				tempTarget
+			]);
+			//dojo.debug("Cached for "+tempTarget)
+		}, this);
+
+		dojo.profile.end("cacheTargetLocations");
+
+		//dojo.debug("Cache locations")
+	},
+
+	onMouseMove: function(e){
+		if((dojo.render.html.ie)&&(e.button != 1)){
+			// Oooops - mouse up occurred - e.g. when mouse was not over the
+			// window. I don't think we can detect this for FF - but at least
+			// we can be nice in IE.
+			this.currentDropTarget = null;
+			this.onMouseUp(e, true);
+			return;
+		}
+
+		// if we've got some sources, but no drag objects, we need to send
+		// onDragStart to all the right parties and get things lined up for
+		// drop target detection
+
+		if(	(this.selectedSources.length)&&
+			(!this.dragObjects.length) ){
+			var dx;
+			var dy;
+			if(!this._dragTriggered){
+				this._dragTriggered = (this._dragStartDistance(e.pageX, e.pageY) > this.threshold);
+				if(!this._dragTriggered){ return; }
+				dx = e.pageX - this.mouseDownX;
+				dy = e.pageY - this.mouseDownY;
+			}
+
+			// the first element is always our dragSource, if there are multiple
+			// selectedSources (elements that move along) then the first one is the master
+			// and for it the events will be fired etc.
+			this.dragSource = this.selectedSources[0];
+			
+			dojo.lang.forEach(this.selectedSources, function(tempSource){
+				if(!tempSource){ return; }
+				var tdo = tempSource.onDragStart(e);
+				if(tdo){
+					tdo.onDragStart(e);
+
+					// "bump" the drag object to account for the drag threshold
+					tdo.dragOffset.y += dy;
+					tdo.dragOffset.x += dx;
+					tdo.dragSource = tempSource;
+
+					this.dragObjects.push(tdo);
+				}
+			}, this);
+
+			/* clean previous drop target in dragStart */
+			this.previousDropTarget = null;
+
+			this.cacheTargetLocations();
+		}
+
+		// FIXME: we need to add dragSources and dragObjects to e
+		dojo.lang.forEach(this.dragObjects, function(dragObj){
+			if(dragObj){ dragObj.onDragMove(e); }
+		});
+
+		// if we have a current drop target, check to see if we're outside of
+		// it. If so, do all the actions that need doing.
+		if(this.currentDropTarget){
+			//dojo.debug(dojo.html.hasParent(this.currentDropTarget.domNode))
+			var c = dojo.html.toCoordinateObject(this.currentDropTarget.domNode, true);
+			//		var dtp = this.currentDropTargetPoints;
+			var dtp = [
+				[c.x,c.y], [c.x+c.width, c.y+c.height]
+			];
+		}
+
+		if((!this.nestedTargets)&&(dtp)&&(this.isInsideBox(e, dtp))){
+			if(this.dropAcceptable){
+				this.currentDropTarget.onDragMove(e, this.dragObjects);
+			}
+		}else{
+			// FIXME: need to fix the event object!
+			// see if we can find a better drop target
+			var bestBox = this.findBestTarget(e);
+
+			if(bestBox.target === null){
+				if(this.currentDropTarget){
+					this.currentDropTarget.onDragOut(e);
+					this.previousDropTarget = this.currentDropTarget;
+					this.currentDropTarget = null;
+					// this.currentDropTargetPoints = null;
+				}
+				this.dropAcceptable = false;
+				return;
+			}
+
+			if(this.currentDropTarget !== bestBox.target){
+				if(this.currentDropTarget){
+					this.previousDropTarget = this.currentDropTarget;
+					this.currentDropTarget.onDragOut(e);
+				}
+				this.currentDropTarget = bestBox.target;
+				// this.currentDropTargetPoints = bestBox.points;
+				e.dragObjects = this.dragObjects;
+				this.dropAcceptable = this.currentDropTarget.onDragOver(e);
+
+			}else{
+				if(this.dropAcceptable){
+					this.currentDropTarget.onDragMove(e, this.dragObjects);
+				}
+			}
+		}
+	},
+
+	findBestTarget: function(e) {
+		var _this = this;
+		var bestBox = new Object();
+		bestBox.target = null;
+		bestBox.points = null;
+		dojo.lang.every(this.dropTargetDimensions, function(tmpDA) {
+			if(!_this.isInsideBox(e, tmpDA)){
+				return true;
+			}
+
+			bestBox.target = tmpDA[2];
+			bestBox.points = tmpDA;
+			// continue iterating only if _this.nestedTargets == true
+			return Boolean(_this.nestedTargets);
+		});
+
+		return bestBox;
+	},
+
+	isInsideBox: function(e, coords){
+		if(	(e.pageX > coords[0][0])&&
+			(e.pageX < coords[1][0])&&
+			(e.pageY > coords[0][1])&&
+			(e.pageY < coords[1][1]) ){
+			return true;
+		}
+		return false;
+	},
+
+	onMouseOver: function(e){
+	},
+
+	onMouseOut: function(e){
+	}
+});
+
+dojo.dnd.dragManager = new dojo.dnd.HtmlDragManager();
+
+// global namespace protection closure
+(function(){
+	var d = document;
+	var dm = dojo.dnd.dragManager;
+	//TODO: when focus manager is ready, dragManager should be rewritten to use it
+	// set up event handlers on the document (or no?)
+	dojo.event.connect(d, "onkeydown", dm, "onKeyDown");
+	dojo.event.connect(d, "onmouseover", dm, "onMouseOver");
+	dojo.event.connect(d, "onmouseout", dm, "onMouseOut");
+	dojo.event.connect(d, "onmousedown", dm, "onMouseDown");
+	dojo.event.connect(d, "onmouseup", dm, "onMouseUp");
+	// TODO: process scrolling of elements, not only window (focus manager would 
+	// probably come to rescue here as well)
+	dojo.event.connect(window, "onscroll", dm, "onScroll");
+})();

Propchange: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/dnd/HtmlDragManager.js
------------------------------------------------------------------------------
    svn:eol-style = native

Added: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/dnd/HtmlDragMove.js
URL: http://svn.apache.org/viewvc/jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/dnd/HtmlDragMove.js?view=auto&rev=473755
==============================================================================
--- jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/dnd/HtmlDragMove.js (added)
+++ jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/dnd/HtmlDragMove.js Sat Nov 11 08:44:22 2006
@@ -0,0 +1,56 @@
+dojo.provide("dojo.dnd.HtmlDragMove");
+dojo.require("dojo.dnd.*");
+
+dojo.declare("dojo.dnd.HtmlDragMoveSource", dojo.dnd.HtmlDragSource, {
+	onDragStart: function(){
+		var dragObj =  new dojo.dnd.HtmlDragMoveObject(this.dragObject, this.type);
+		if (this.constrainToContainer) {
+			dragObj.constrainTo(this.constrainingContainer);
+		}
+		return dragObj;
+	},
+	/*
+	 * see dojo.dnd.HtmlDragSource.onSelected
+	 */
+	onSelected: function() {
+		for (var i=0; i<this.dragObjects.length; i++) {
+			dojo.dnd.dragManager.selectedSources.push(new dojo.dnd.HtmlDragMoveSource(this.dragObjects[i]));
+		}
+	}
+});
+
+dojo.declare("dojo.dnd.HtmlDragMoveObject", dojo.dnd.HtmlDragObject, {
+	onDragEnd: function(e){
+		// shortly the browser will fire an onClick() event,
+		// but since this was really a drag, just squelch it
+		dojo.event.connect(this.domNode, "onclick", this, "squelchOnClick");
+	},
+	onDragStart: function(e){
+		dojo.html.clearSelection();
+
+		this.dragClone = this.domNode;
+
+		this.scrollOffset = dojo.html.getScroll().offset;
+		this.dragStartPosition = dojo.html.abs(this.domNode, true);
+		
+		this.dragOffset = {y: this.dragStartPosition.y - e.pageY,
+			x: this.dragStartPosition.x - e.pageX};
+
+		this.containingBlockPosition = this.domNode.offsetParent ? 
+			dojo.html.abs(this.domNode.offsetParent, true) : {x:0, y:0};
+
+		this.dragClone.style.position = "absolute";
+
+		if (this.constrainToContainer) {
+			this.constraints = this.getConstraints();
+		}
+	},
+	/**
+	 * Set the position of the drag node.  (x,y) is relative to <body>.
+	 */
+	setAbsolutePosition: function(x, y){
+		// The drag clone is attached to it's constraining container so offset for that
+		if(!this.disableY) { this.domNode.style.top = (y-this.containingBlockPosition.y) + "px"; }
+		if(!this.disableX) { this.domNode.style.left = (x-this.containingBlockPosition.x) + "px"; }
+	}
+});

Propchange: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/dnd/HtmlDragMove.js
------------------------------------------------------------------------------
    svn:eol-style = native

Added: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/dnd/Sortable.js
URL: http://svn.apache.org/viewvc/jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/dnd/Sortable.js?view=auto&rev=473755
==============================================================================
--- jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/dnd/Sortable.js (added)
+++ jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/dnd/Sortable.js Sat Nov 11 08:44:22 2006
@@ -0,0 +1,18 @@
+dojo.provide("dojo.dnd.Sortable");
+dojo.require("dojo.dnd.*");
+
+dojo.dnd.Sortable = function () {}
+
+dojo.lang.extend(dojo.dnd.Sortable, {
+
+	ondragstart: function (e) {
+		var dragObject = e.target;
+		while (dragObject.parentNode && dragObject.parentNode != this) {
+			dragObject = dragObject.parentNode;
+		}
+		// TODO: should apply HtmlDropTarget interface to self
+		// TODO: should apply HtmlDragObject interface?
+		return dragObject;
+	}
+
+});

Propchange: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/dnd/Sortable.js
------------------------------------------------------------------------------
    svn:eol-style = native

Added: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/dnd/TreeDragAndDrop.js
URL: http://svn.apache.org/viewvc/jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/dnd/TreeDragAndDrop.js?view=auto&rev=473755
==============================================================================
--- jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/dnd/TreeDragAndDrop.js (added)
+++ jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/dnd/TreeDragAndDrop.js Sat Nov 11 08:44:22 2006
@@ -0,0 +1,465 @@
+/**
+ * TreeDrag* specialized on managing subtree drags
+ * It selects nodes and visualises what's going on,
+ * but delegates real actions upon tree to the controller
+ *
+ * This code is considered a part of controller
+*/
+
+dojo.provide("dojo.dnd.TreeDragAndDrop");
+
+dojo.require("dojo.dnd.HtmlDragAndDrop");
+dojo.require("dojo.lang.func");
+dojo.require("dojo.lang.array");
+dojo.require("dojo.lang.extras");
+dojo.require("dojo.html.layout");
+
+dojo.dnd.TreeDragSource = function(node, syncController, type, treeNode){
+	this.controller = syncController;
+	this.treeNode = treeNode;
+
+	dojo.dnd.HtmlDragSource.call(this, node, type);
+}
+
+dojo.inherits(dojo.dnd.TreeDragSource, dojo.dnd.HtmlDragSource);
+
+dojo.lang.extend(dojo.dnd.TreeDragSource, {
+	onDragStart: function(){
+		/* extend adds functions to prototype */
+		var dragObject = dojo.dnd.HtmlDragSource.prototype.onDragStart.call(this);
+		//dojo.debugShallow(dragObject)
+
+		dragObject.treeNode = this.treeNode;
+
+		dragObject.onDragStart = dojo.lang.hitch(dragObject, function(e) {
+
+			/* save selection */
+			this.savedSelectedNode = this.treeNode.tree.selector.selectedNode;
+			if (this.savedSelectedNode) {
+				this.savedSelectedNode.unMarkSelected();
+			}
+
+			var result = dojo.dnd.HtmlDragObject.prototype.onDragStart.apply(this, arguments);
+
+
+			/* remove background grid from cloned object */
+			var cloneGrid = this.dragClone.getElementsByTagName('img');
+			for(var i=0; i<cloneGrid.length; i++) {
+				cloneGrid.item(i).style.backgroundImage='url()';
+			}
+
+			return result;
+
+
+		});
+
+		dragObject.onDragEnd = function(e) {
+
+			/* restore selection */
+			if (this.savedSelectedNode) {
+				this.savedSelectedNode.markSelected();
+			}
+			//dojo.debug(e.dragStatus);
+
+			return dojo.dnd.HtmlDragObject.prototype.onDragEnd.apply(this, arguments);
+		}
+		//dojo.debug(dragObject.domNode.outerHTML)
+
+
+		return dragObject;
+	},
+
+	onDragEnd: function(e){
+
+
+		 var res = dojo.dnd.HtmlDragSource.prototype.onDragEnd.call(this, e);
+
+
+		 return res;
+	}
+});
+
+// .......................................
+
+dojo.dnd.TreeDropTarget = function(domNode, controller, type, treeNode){
+
+	this.treeNode = treeNode;
+	this.controller = controller; // I will sync-ly process drops
+	
+	dojo.dnd.HtmlDropTarget.apply(this, [domNode, type]);
+}
+
+dojo.inherits(dojo.dnd.TreeDropTarget, dojo.dnd.HtmlDropTarget);
+
+dojo.lang.extend(dojo.dnd.TreeDropTarget, {
+
+	autoExpandDelay: 1500,
+	autoExpandTimer: null,
+
+
+	position: null,
+
+	indicatorStyle: "2px black solid",
+
+	showIndicator: function(position) {
+
+		// do not change style too often, cause of blinking possible
+		if (this.position == position) {
+			return;
+		}
+
+		//dojo.debug(position)
+
+		this.hideIndicator();
+
+		this.position = position;
+
+		if (position == "before") {
+			this.treeNode.labelNode.style.borderTop = this.indicatorStyle;
+		} else if (position == "after") {
+			this.treeNode.labelNode.style.borderBottom = this.indicatorStyle;
+		} else if (position == "onto") {
+			this.treeNode.markSelected();
+		}
+
+
+	},
+
+	hideIndicator: function() {
+		this.treeNode.labelNode.style.borderBottom="";
+		this.treeNode.labelNode.style.borderTop="";
+		this.treeNode.unMarkSelected();
+		this.position = null;
+	},
+
+
+
+	// is the target possibly ok ?
+	// This function is run on dragOver, but drop possibility is also determined by position over node
+	// that's why acceptsWithPosition is called
+	// doesnt take index into account ( can change while moving mouse w/o changing target )
+
+
+	/**
+	 * Coarse (tree-level) access check.
+	 * We can't determine real accepts status w/o position
+	*/
+	onDragOver: function(e){
+//dojo.debug("onDragOver for "+e);
+
+
+		var accepts = dojo.dnd.HtmlDropTarget.prototype.onDragOver.apply(this, arguments);
+
+		//dojo.debug("TreeDropTarget.onDragOver accepts:"+accepts)
+
+		if (accepts && this.treeNode.isFolder && !this.treeNode.isExpanded) {
+			this.setAutoExpandTimer();
+		}
+
+		return accepts;
+	},
+
+	/* Parent.onDragOver calls this function to get accepts status */
+	accepts: function(dragObjects) {
+
+		var accepts = dojo.dnd.HtmlDropTarget.prototype.accepts.apply(this, arguments);
+
+		if (!accepts) return false;
+
+		var sourceTreeNode = dragObjects[0].treeNode;
+
+		if (dojo.lang.isUndefined(sourceTreeNode) || !sourceTreeNode || !sourceTreeNode.isTreeNode) {
+			dojo.raise("Source is not TreeNode or not found");
+		}
+
+		if (sourceTreeNode === this.treeNode) return false;
+
+		return true;
+	},
+
+
+
+	setAutoExpandTimer: function() {
+		// set up autoexpand timer
+		var _this = this;
+
+		var autoExpand = function () {
+			if (dojo.dnd.dragManager.currentDropTarget === _this) {
+				_this.controller.expand(_this.treeNode);
+			}
+		}
+
+		this.autoExpandTimer = dojo.lang.setTimeout(autoExpand, _this.autoExpandDelay);
+	},
+
+
+	getDNDMode: function() {
+		return this.treeNode.tree.DNDMode;
+	},
+		
+
+	getAcceptPosition: function(e, sourceTreeNode) {
+
+		var DNDMode = this.getDNDMode();
+
+		if (DNDMode & dojo.widget.Tree.prototype.DNDModes.ONTO &&
+			// check if ONTO is allowed localy
+			!(
+			  !this.treeNode.actionIsDisabled(dojo.widget.TreeNode.prototype.actions.ADDCHILD) // check dynamically cause may change w/o regeneration of dropTarget
+			  && sourceTreeNode.parent !== this.treeNode
+			  && this.controller.canMove(sourceTreeNode, this.treeNode)
+			 )
+		) {
+			// disable ONTO if can't move
+			DNDMode &= ~dojo.widget.Tree.prototype.DNDModes.ONTO;
+		}
+
+
+		var position = this.getPosition(e, DNDMode);
+
+		//dojo.debug(DNDMode & +" : "+position);
+
+
+		// if onto is here => it was allowed before, no accept check is needed
+		if (position=="onto" ||
+			(!this.isAdjacentNode(sourceTreeNode, position)
+			 && this.controller.canMove(sourceTreeNode, this.treeNode.parent)
+			)
+		) {
+			return position;
+		} else {
+			return false;
+		}
+
+	},
+
+	onDragOut: function(e) {
+		this.clearAutoExpandTimer();
+
+		this.hideIndicator();
+	},
+
+
+	clearAutoExpandTimer: function() {
+		if (this.autoExpandTimer) {
+			clearTimeout(this.autoExpandTimer);
+			this.autoExpandTimer = null;
+		}
+	},
+
+
+
+	onDragMove: function(e, dragObjects){
+
+		var sourceTreeNode = dragObjects[0].treeNode;
+
+		var position = this.getAcceptPosition(e, sourceTreeNode);
+
+		if (position) {
+			this.showIndicator(position);
+		}
+
+	},
+
+	isAdjacentNode: function(sourceNode, position) {
+
+		if (sourceNode === this.treeNode) return true;
+		if (sourceNode.getNextSibling() === this.treeNode && position=="before") return true;
+		if (sourceNode.getPreviousSibling() === this.treeNode && position=="after") return true;
+
+		return false;
+	},
+
+
+	/* get DNDMode and see which position e fits */
+	getPosition: function(e, DNDMode) {
+		var node = dojo.byId(this.treeNode.labelNode);
+		var mousey = e.pageY || e.clientY + dojo.body().scrollTop;
+		var nodey = dojo.html.getAbsolutePosition(node).y;
+		var height = dojo.html.getBorderBox(node).height;
+
+		var relY = mousey - nodey;
+		var p = relY / height;
+
+		var position = ""; // "" <=> forbidden
+		if (DNDMode & dojo.widget.Tree.prototype.DNDModes.ONTO
+		  && DNDMode & dojo.widget.Tree.prototype.DNDModes.BETWEEN) {
+			if (p<=0.3) {
+				position = "before";
+			} else if (p<=0.7) {
+				position = "onto";
+			} else {
+				position = "after";
+			}
+		} else if (DNDMode & dojo.widget.Tree.prototype.DNDModes.BETWEEN) {
+			if (p<=0.5) {
+				position = "before";
+			} else {
+				position = "after";
+			}
+		}
+		else if (DNDMode & dojo.widget.Tree.prototype.DNDModes.ONTO) {
+			position = "onto";
+		}
+
+
+		return position;
+	},
+
+
+
+	getTargetParentIndex: function(sourceTreeNode, position) {
+
+		var index = position == "before" ? this.treeNode.getParentIndex() : this.treeNode.getParentIndex()+1;
+		if (this.treeNode.parent === sourceTreeNode.parent
+		  && this.treeNode.getParentIndex() > sourceTreeNode.getParentIndex()) {
+		  	index--;  // dragging a node is different for simple move bacause of before-after issues
+		}
+
+		return index;
+	},
+
+
+	onDrop: function(e){
+		// onDragOut will clean position
+
+
+		var position = this.position;
+
+//dojo.debug(position);
+
+		this.onDragOut(e);
+
+		var sourceTreeNode = e.dragObject.treeNode;
+
+		if (!dojo.lang.isObject(sourceTreeNode)) {
+			dojo.raise("TreeNode not found in dragObject")
+		}
+
+		if (position == "onto") {
+			return this.controller.move(sourceTreeNode, this.treeNode, 0);
+		} else {
+			var index = this.getTargetParentIndex(sourceTreeNode, position);
+			return this.controller.move(sourceTreeNode, this.treeNode.parent, index);
+		}
+
+		//dojo.debug('drop2');
+
+
+
+	}
+
+
+});
+
+
+
+dojo.dnd.TreeDNDController = function(treeController) {
+
+	// I use this controller to perform actions
+	this.treeController = treeController;
+
+	this.dragSources = {};
+
+	this.dropTargets = {};
+
+}
+
+dojo.lang.extend(dojo.dnd.TreeDNDController, {
+
+
+	listenTree: function(tree) {
+		//dojo.debug("Listen tree "+tree);
+		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.addChild, this, "onAddChild");
+		dojo.event.topic.subscribe(tree.eventNames.removeNode, this, "onRemoveNode");
+		dojo.event.topic.subscribe(tree.eventNames.treeDestroy, this, "onTreeDestroy");
+	},
+
+
+	unlistenTree: function(tree) {
+		//dojo.debug("Listen tree "+tree);
+		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.addChild, this, "onAddChild");
+		dojo.event.topic.unsubscribe(tree.eventNames.removeNode, this, "onRemoveNode");
+		dojo.event.topic.unsubscribe(tree.eventNames.treeDestroy, this, "onTreeDestroy");
+	},
+
+	onTreeDestroy: function(message) {
+		this.unlistenTree(message.source);
+		// I'm not widget so don't use destroy() call and dieWithTree
+	},
+
+	onCreateDOMNode: function(message) {
+		this.registerDNDNode(message.source);
+	},
+
+	onAddChild: function(message) {
+		this.registerDNDNode(message.child);
+	},
+
+	onMoveFrom: function(message) {
+		var _this = this;
+		dojo.lang.forEach(
+			message.child.getDescendants(),
+			function(node) { _this.unregisterDNDNode(node); }
+		);
+	},
+
+	onMoveTo: function(message) {
+		var _this = this;
+		dojo.lang.forEach(
+			message.child.getDescendants(),
+			function(node) { _this.registerDNDNode(node); }
+		);
+	},
+
+	/**
+	 * 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
+	*/
+	registerDNDNode: function(node) {
+		if (!node.tree.DNDMode) return;
+
+//dojo.debug("registerDNDNode "+node);
+
+		/* 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")
+			var source = new dojo.dnd.TreeDragSource(node.labelNode, this, node.tree.widgetId, node);
+			this.dragSources[node.widgetId] = source;
+		}
+
+		var target = new dojo.dnd.TreeDropTarget(node.labelNode, this.treeController, node.tree.DNDAcceptTypes, node);
+
+		this.dropTargets[node.widgetId] = target;
+
+	},
+
+
+	unregisterDNDNode: 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];
+		}
+	}
+
+
+
+
+
+});

Propchange: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/dnd/TreeDragAndDrop.js
------------------------------------------------------------------------------
    svn:eol-style = native

Added: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/dnd/TreeDragAndDropV3.js
URL: http://svn.apache.org/viewvc/jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/dnd/TreeDragAndDropV3.js?view=auto&rev=473755
==============================================================================
--- jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/dnd/TreeDragAndDropV3.js (added)
+++ jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/dnd/TreeDragAndDropV3.js Sat Nov 11 08:44:22 2006
@@ -0,0 +1,394 @@
+/**
+ * TreeDrag* specialized on managing subtree drags
+ * It selects nodes and visualises what's going on,
+ * but delegates real actions upon tree to the controller
+ *
+ * This code is considered a part of controller
+*/
+
+dojo.provide("dojo.dnd.TreeDragAndDropV3");
+
+dojo.require("dojo.dnd.HtmlDragAndDrop");
+dojo.require("dojo.lang.func");
+dojo.require("dojo.lang.array");
+dojo.require("dojo.lang.extras");
+dojo.require("dojo.Deferred");
+dojo.require("dojo.html.layout");
+
+// FIXME: if controller can't move then skip node on move start
+dojo.dnd.TreeDragSourceV3 = function(node, syncController, type, treeNode){
+	//dojo.profile.start("TreeDragSourceV3 "+treeNode);
+	this.controller = syncController;
+	this.treeNode = treeNode;
+
+	dojo.dnd.HtmlDragSource.call(this, node, type);
+	//dojo.profile.end("TreeDragSourceV3 "+treeNode);
+
+}
+
+dojo.inherits(dojo.dnd.TreeDragSourceV3, dojo.dnd.HtmlDragSource);
+
+
+// .......................................
+
+dojo.dnd.TreeDropTargetV3 = function(domNode, controller, type, treeNode){
+
+	this.treeNode = treeNode;
+	this.controller = controller; // I will sync-ly process drops
+	
+	dojo.dnd.HtmlDropTarget.call(this, domNode, type);
+}
+
+dojo.inherits(dojo.dnd.TreeDropTargetV3, dojo.dnd.HtmlDropTarget);
+
+dojo.lang.extend(dojo.dnd.TreeDropTargetV3, {
+
+	autoExpandDelay: 1500,
+	autoExpandTimer: null,
+
+
+	position: null,
+
+	indicatorStyle: "2px black groove",
+
+	showIndicator: function(position) {
+
+		// do not change style too often, cause of blinking possible
+		if (this.position == position) {
+			return;
+		}
+
+		//dojo.debug("set position for "+this.treeNode)
+
+		this.hideIndicator();
+
+		this.position = position;
+		
+		var node = this.treeNode;
+			
+		
+		node.contentNode.style.width = dojo.html.getBorderBox(node.labelNode).width + "px";
+
+		if (position == "onto") {					
+			node.contentNode.style.border = this.indicatorStyle;
+		} else {
+			// FIXME: bottom-top or highlight should cover ONLY top/bottom or div itself,
+			// not span whole line (try Dnd)
+			// FAILURE: Can't put span inside div: multiline bottom-top will span multiple lines
+			if (position == "before") {
+				node.contentNode.style.borderTop = this.indicatorStyle;
+			} else if (position == "after") {
+				node.contentNode.style.borderBottom = this.indicatorStyle;
+			}									
+		}  
+	},
+
+	hideIndicator: function() {
+		this.treeNode.contentNode.style.borderBottom = "";
+		this.treeNode.contentNode.style.borderTop = "";
+		this.treeNode.contentNode.style.border = "";
+		this.treeNode.contentNode.style.width=""
+		this.position = null;
+	},
+
+
+
+	// is the target possibly ok ?
+	// This function is run on dragOver, but drop possibility is also determined by position over node
+	// that's why acceptsWithPosition is called
+	// doesnt take index into account ( can change while moving mouse w/o changing target )
+	/**
+	 * Coarse (tree-level) access check.
+	 * We can't determine real accepts status w/o position
+	*/
+	onDragOver: function(e){
+		//dojo.debug("onDragOver for "+e);
+
+		var accepts = dojo.dnd.HtmlDropTarget.prototype.onDragOver.apply(this, arguments);
+
+		//dojo.debug("TreeDropTarget.onDragOver accepts:"+accepts)
+
+		if (accepts && this.treeNode.isFolder && !this.treeNode.isExpanded) {
+			this.setAutoExpandTimer();
+		}
+		
+		if (accepts) {
+			this.cacheNodeCoords();
+		}
+
+
+		return accepts;
+	},
+
+	/* Parent.onDragOver calls this function to get accepts status */
+	accepts: function(dragObjects) {
+
+		var accepts = dojo.dnd.HtmlDropTarget.prototype.accepts.apply(this, arguments);
+
+		//dojo.debug("accepts "+accepts);
+
+		if (!accepts) return false;
+
+		for(var i=0; i<dragObjects.length; i++) {
+			// there may be NO treeNode
+			var sourceTreeNode = dragObjects[i].dragSource.treeNode;
+			
+			if (sourceTreeNode === this.treeNode) return false;
+		}
+
+		return true;
+	},
+
+
+
+	setAutoExpandTimer: function() {
+		// set up autoexpand timer
+		var _this = this;
+
+		var autoExpand = function () {
+			if (dojo.dnd.dragManager.currentDropTarget === _this) {
+				_this.controller.expand(_this.treeNode);
+				// SLOW. Coordinates will not be recalculated if collapse occurs, or
+				// other (generic) resize. So that's a kind of hack.
+				dojo.dnd.dragManager.cacheTargetLocations();
+			}
+		}
+
+		this.autoExpandTimer = dojo.lang.setTimeout(autoExpand, _this.autoExpandDelay);
+	},
+
+		
+
+	getAcceptPosition: function(e, dragObjects) {
+
+
+		var DndMode = this.treeNode.tree.DndMode;
+
+		// disable ONTO mode possibility if impossible 
+		if (DndMode & dojo.widget.TreeV3.prototype.DndModes.ONTO &&
+			// check if ONTO is allowed localy
+			// check dynamically cause may change w/o regeneration of dropTarget
+			this.treeNode.actionIsDisabledNow(this.treeNode.actions.ADDCHILD) 
+		) {
+			// disable ONTO if can't move
+			DndMode &= ~dojo.widget.TreeV3.prototype.DndModes.ONTO;
+		}
+		
+
+		var position = this.getPosition(e, DndMode);
+
+		//dojo.debug(DndMode & +" : "+position);
+
+
+		// if onto is here => it was allowed before, no accept check is needed
+		if (position=="onto") {
+			return position;
+		}
+		
+		for(var i=0; i<dragObjects.length; i++) {
+			var source = dragObjects[i].dragSource;
+			if (source.treeNode && this.isAdjacentNode(source.treeNode, position)) { // skip check if same parent
+				continue;
+			}		
+						
+			if (!this.controller.canMove(source.treeNode ? source.treeNode : source, this.treeNode.parent)) {
+				return false;
+			}
+		}
+		
+		return position;
+	
+	},
+
+	
+
+	onDropEnd: function(e) {
+		this.clearAutoExpandTimer();
+
+		this.hideIndicator();
+	},
+
+
+	onDragOut: function(e) {
+		this.clearAutoExpandTimer();
+
+		this.hideIndicator();
+	},
+
+	clearAutoExpandTimer: function() {
+		if (this.autoExpandTimer) {
+			clearTimeout(this.autoExpandTimer);
+			this.autoExpandTimer = null;
+		}
+	},
+
+
+
+	onDragMove: function(e, dragObjects){
+		
+		var position = this.getAcceptPosition(e, dragObjects);
+
+		if (position) {
+			this.showIndicator(position);
+		}
+
+	},
+
+	isAdjacentNode: function(sourceNode, position) {
+
+		if (sourceNode === this.treeNode) return true;
+		if (sourceNode.getNextSibling() === this.treeNode && position=="before") return true;
+		if (sourceNode.getPreviousSibling() === this.treeNode && position=="after") return true;
+
+		return false;
+	},
+
+
+	/**
+	 * cache node coordinates to speed up onDragMove
+	 */
+	cacheNodeCoords: function() {
+		var node = this.treeNode.contentNode;
+		
+		this.cachedNodeY = dojo.html.getAbsolutePosition(node).y;
+		this.cachedNodeHeight = dojo.html.getBorderBox(node).height;
+	},
+	
+	
+
+	/* get DndMode and see which position e fits */
+	getPosition: function(e, DndMode) {
+		var mousey = e.pageY || e.clientY + dojo.body().scrollTop;
+		
+		var relY = mousey - this.cachedNodeY;
+		var p = relY / this.cachedNodeHeight;
+
+		var position = ""; // "" <=> forbidden
+		if (DndMode & dojo.widget.TreeV3.prototype.DndModes.ONTO
+		  && DndMode & dojo.widget.TreeV3.prototype.DndModes.BETWEEN) {
+			//dojo.debug("BOTH");
+			if (p<=0.33) {
+				position = "before";
+				// if children are expanded then I ignore understrike, cause it is confusing with firstChild
+				// but for last nodes I put understrike there
+			} else if (p<=0.66 || this.treeNode.isExpanded && this.treeNode.children.length && !this.treeNode.isLastChild()) {
+				position = "onto";
+			} else {
+				position = "after";
+			}
+		} else if (DndMode & dojo.widget.TreeV3.prototype.DndModes.BETWEEN) {
+			//dojo.debug("BETWEEN");
+			if (p<=0.5 || this.treeNode.isExpanded && this.treeNode.children.length && !this.treeNode.isLastChild()) {
+				position = "before";
+			} else {
+				position = "after";
+			}
+		}
+		else if (DndMode & dojo.widget.TreeV3.prototype.DndModes.ONTO) {
+			//dojo.debug("ONTO");
+			position = "onto";
+		}
+
+		//dojo.debug(position);
+
+		return position;
+	},
+
+
+
+	getTargetParentIndex: function(source, position) {
+
+		var index = position == "before" ? this.treeNode.getParentIndex() : this.treeNode.getParentIndex()+1;
+		if (source.treeNode
+		  && this.treeNode.parent === source.treeNode.parent
+		  && this.treeNode.getParentIndex() > source.treeNode.getParentIndex()) {
+		  	index--;  // dragging a node is different for simple move bacause of before-after issues
+		}
+
+		return index;
+	},
+
+
+	onDrop: function(e) {
+		// onDropEnd will clean position
+
+		
+		var position = this.position;
+
+//dojo.debug(position);
+		var source = e.dragObject.dragSource;
+		
+		//dojo.debug("onDrop "+source.treeNode+" " + position + " "+this.treeNode);
+
+
+		var targetParent, targetIndex;
+		if (position == "onto") {
+			targetParent = this.treeNode;
+			targetIndex = 0;
+		} else {
+			targetIndex = this.getTargetParentIndex(source, position);
+			targetParent = this.treeNode.parent;
+		}
+		
+		//dojo.profile.start("onDrop "+sourceTreeNode);
+		var r = this.getDropHandler(e, source, targetParent, targetIndex)();
+		
+		//dojo.profile.end("onDrop "+sourceTreeNode);
+			
+		return r;
+
+	},
+	
+	/**
+	 * determine, which action I should perform with nodes
+	 * e.g move, clone..
+	 */
+	getDropHandler: function(e, source, targetParent, targetIndex) {
+		var handler;
+		var _this = this;
+		handler = function () {
+			var result;
+			
+			//dojo.debug("Move "+source.treeNode+" to parent "+targetParent+":"+targetIndex);
+			if (source.treeNode) {
+				result = _this.controller.move(source.treeNode, targetParent, targetIndex, true);
+				//dojo.debug("moved "+result);
+			} else {
+				if (dojo.lang.isFunction(source.onDrop)) {
+					source.onDrop(targetParent, targetIndex);
+				}
+				
+				var treeNode = source.getTreeNode();
+				if (treeNode) {
+					result = _this.controller.createChild(targetParent, targetIndex, treeNode, true);
+				} else {
+					result = true;
+				}
+			}
+			
+			if (result instanceof dojo.Deferred) {
+				// this Deferred is always sync
+				var isSuccess = result.fired == 0;
+				if (!isSuccess) {
+					_this.handleDropError(source, targetParent, targetIndex, result);
+				}
+				
+				return isSuccess;				
+				
+			} else {
+				return result;
+			}
+		}
+		
+		return handler;
+	},
+	
+	
+	handleDropError: function(source, parent, index, result) {
+		dojo.debug("TreeDropTargetV3.handleDropError: DND error occured");
+		dojo.debugShallow(result);
+	}
+
+
+});
+

Propchange: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/dnd/TreeDragAndDropV3.js
------------------------------------------------------------------------------
    svn:eol-style = native

Added: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/dnd/__package__.js
URL: http://svn.apache.org/viewvc/jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/dnd/__package__.js?view=auto&rev=473755
==============================================================================
--- jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/dnd/__package__.js (added)
+++ jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/dnd/__package__.js Sat Nov 11 08:44:22 2006
@@ -0,0 +1,6 @@
+dojo.kwCompoundRequire({
+	common: ["dojo.dnd.DragAndDrop"],
+	browser: ["dojo.dnd.HtmlDragAndDrop"],
+	dashboard: ["dojo.dnd.HtmlDragAndDrop"]
+});
+dojo.provide("dojo.dnd.*");

Propchange: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/dnd/__package__.js
------------------------------------------------------------------------------
    svn:eol-style = native

Added: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/docs.js
URL: http://svn.apache.org/viewvc/jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/docs.js?view=auto&rev=473755
==============================================================================
--- jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/docs.js (added)
+++ jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/docs.js Sat Nov 11 08:44:22 2006
@@ -0,0 +1,1038 @@
+dojo.provide("dojo.docs");
+dojo.require("dojo.io.*");
+dojo.require("dojo.event.topic");
+dojo.require("dojo.rpc.JotService");
+dojo.require("dojo.dom");
+dojo.require("dojo.uri.Uri");
+dojo.require("dojo.Deferred");
+dojo.require("dojo.DeferredList");
+
+/*
+ * TODO:
+ *
+ * Package summary needs to compensate for "is"
+ * Handle host environments
+ * Deal with dojo.widget weirdness
+ * Parse parameters
+ * Limit function parameters to only the valid ones (Involves packing parameters onto meta during rewriting)
+ *
+ */
+
+dojo.docs = new function() {
+	this._url = dojo.uri.dojoUri("docscripts");
+	this._rpc = new dojo.rpc.JotService;
+	this._rpc.serviceUrl = dojo.uri.dojoUri("docscripts/jsonrpc.php");
+};
+dojo.lang.mixin(dojo.docs, {
+	_count: 0,
+	_callbacks: {function_names: []},
+	_cache: {}, // Saves the JSON objects in cache
+	require: function(/*String*/ require, /*bool*/ sync) {
+		dojo.debug("require(): " + require);
+		var parts = require.split("/");
+		var size = parts.length;
+		var deferred = new dojo.Deferred;
+		var args = {
+			mimetype: "text/json",
+			load: function(type, data){
+				dojo.debug("require(): loaded");
+				
+				if(parts[0] != "function_names") {
+					for(var i = 0, part; part = parts[i]; i++){
+						data = data[part];
+					}
+				}
+				deferred.callback(data);
+			},
+			error: function(){
+				deferred.errback();
+			}
+		};
+		
+		if (sync) {
+			args.sync = true;
+		}
+
+		if(location.protocol == "file:"){
+			if(size){
+				if(parts[0] == "function_names"){
+					args.url = [this._url, "local_json", "function_names"].join("/");
+				}else{
+					var dirs = parts[0].split(".");
+					args.url = [this._url, "local_json", dirs[0]].join("/");
+					if(dirs.length > 1){
+						args.url = [args.url, dirs[1]].join(".");
+					}
+				}
+			}
+		}
+		
+		dojo.io.bind(args);
+		return deferred;
+	},
+	getFunctionNames: function(){
+		return this.require("function_names"); // dojo.Deferred
+	},
+	unFormat: function(/*String*/ string){
+		var fString = string;
+		if(string.charAt(string.length - 1) == "_"){
+			fString = [string.substring(0, string.length - 1), "*"].join("");
+		}
+		return fString;
+	},
+	getMeta: function(/*mixed*/ selectKey, /*String*/ pkg, /*String*/ name, /*Function*/ callback, /*String?*/ id){
+		// summary: Gets information about a function in regards to its meta data
+		if(typeof name == "function"){
+			// pId: a
+			// pkg: ignore
+			id = callback;
+			callback = name;
+			name = pkg;
+			pkg = null;
+			dojo.debug("getMeta(" + name + ")");
+		}else{
+			dojo.debug("getMeta(" + pkg + "/" + name + ")");
+		}
+		
+		if(!id){
+			id = "_";
+		}
+
+		if(!selectKey){
+			selectKey = ++dojo.docs._count;
+		}
+
+		var input;
+		if(typeof selectKey == "object" && selectKey.selectKey){
+			input = selectKey;
+			selectKey = selectKey.selectKey;
+		}else{
+			input = {};
+		}
+
+		dojo.docs._buildCache({
+			type: "meta",
+			callbacks: [dojo.docs._gotMeta, callback],
+			pkg: pkg,
+			name: name,
+			id: id,
+			selectKey: selectKey,
+			input: input
+		});
+	},
+	_withPkg: function(/*String*/ type, /*Object*/ data, /*Object*/ evt, /*Object*/ input, /*String*/ newType){
+		dojo.debug("_withPkg(" + evt.name + ") has package: " + data[0]);
+		evt.pkg = data[0];
+		if("load" == type && evt.pkg){
+			evt.type = newType;
+			dojo.docs._buildCache(evt);
+		}else{
+			if(evt.callbacks && evt.callbacks.length){
+				evt.callbacks.shift()("error", {}, evt, evt.input);
+			}
+		}
+	},
+	_gotMeta: function(/*String*/ type, /*Object*/ data, /*Object*/ evt){
+		dojo.debug("_gotMeta(" + evt.name + ")");
+
+		var cached = dojo.docs._getCache(evt.pkg, evt.name, "meta", "functions", evt.id);
+		if(cached.summary){
+			data.summary = cached.summary;
+		}
+		if(evt.callbacks && evt.callbacks.length){
+			evt.callbacks.shift()(type, data, evt, evt.input);
+		}
+	},
+	getSrc: function(/*mixed*/ selectKey, /*String*/ name, /*Function*/ callback, /*String?*/ id){
+		// summary: Gets src file (created by the doc parser)
+		dojo.debug("getSrc(" + name + ")");
+		if(!id){
+			id = "_";
+		}
+		if(!selectKey){
+			selectKey = ++dojo.docs._count;
+		}
+		
+		var input;
+		if(typeof selectKey == "object" && selectKey.selectKey){
+			input = selectKey;
+			selectKey = selectKey.selectKey;
+		}else{
+			input = {};
+		}
+		
+		dojo.docs._buildCache({
+			type: "src",
+			callbacks: [callback],
+			name: name,
+			id: id,
+			input: input,
+			selectKey: selectKey
+		});
+	},
+	getDoc: function(/*mixed*/ selectKey, /*String*/ name, /*Function*/ callback, /*String?*/ id){
+		// summary: Gets external documentation stored on Jot for a given function
+		dojo.debug("getDoc(" + name  + ")");
+
+		if(!id){
+			id = "_";
+		}
+
+		if(!selectKey){
+			selectKey = ++dojo.docs._count;
+		}
+
+		var input = {};
+		if(typeof selectKey == "object" && selectKey.selectKey){
+			input.input = selectKey;
+			selectKey = selectKey.selectKey;
+		}
+
+		input.type = "doc";
+		input.name = name;
+		input.selectKey = selectKey;
+		input.callbacks = [callback];
+		input.selectKey = selectKey;
+
+		dojo.docs._buildCache(input);
+	},
+	_gotDoc: function(/*String*/ type, /*Array*/ data, /*Object*/ evt, /*Object*/ input){
+		dojo.debug("_gotDoc(" + evt.type + ")");
+		
+		evt[evt.type] = data;
+		if(evt.expects && evt.expects.doc){
+			for(var i = 0, expect; expect = evt.expects.doc[i]; i++){
+				if(!(expect in evt)){
+					dojo.debug("_gotDoc() waiting for more data");
+					return;
+				}
+			}
+		}
+		
+		var cache = dojo.docs._getCache(evt.pkg, "meta", "functions", evt.name, evt.id, "meta");
+
+		var description = evt.fn.description;
+		cache.description = description;
+		data = {
+			returns: evt.fn.returns,
+			id: evt.id,
+			variables: [],
+			selectKey: evt.selectKey
+		}
+		if(!cache.parameters){
+			cache.parameters = {};
+		}
+		for(var i = 0, param; param = evt.param[i]; i++){
+			var fName = param["DocParamForm/name"];
+			if(!cache.parameters[fName]){
+				cache.parameters[fName] = {};
+			}
+			cache.parameters[fName].description = param["DocParamForm/desc"]
+		}
+
+		data.description = cache.description;
+		data.parameters = cache.parameters;
+		
+		evt.type = "doc";
+	
+		if(evt.callbacks && evt.callbacks.length){
+			evt.callbacks.shift()("load", data, evt, input);
+		}
+	},
+	getPkgDoc: function(/*mixed*/ selectKey, /*String*/ name, /*Function*/ callback){
+		// summary: Gets external documentation stored on Jot for a given package
+		dojo.debug("getPkgDoc(" + name + ")");
+		var input = {};
+		if(typeof selectKey == "object" && selectKey.selectKey){
+			input = selectKey;
+			selectKey = selectKey.selectKey;
+		}
+		if(!selectKey){
+			selectKey = ++dojo.docs._count;
+		}
+		dojo.docs._buildCache({
+			type: "pkgdoc",
+			callbacks: [callback],
+			name: name,
+			selectKey: selectKey,
+			input: input
+		});
+	},
+	getPkgInfo: function(/*mixed*/ selectKey, /*String*/ name, /*Function*/ callback){
+		// summary: Gets a combination of the metadata and external documentation for a given package
+		dojo.debug("getPkgInfo(" + name + ")");
+		if(!selectKey){
+			selectKey = ++dojo.docs._count;
+		}
+
+		var input = {
+			selectKey: selectKey,
+			expects: {
+				pkginfo: ["pkgmeta", "pkgdoc"]
+			},
+			callback: callback
+		};
+		dojo.docs.getPkgMeta(input, name, dojo.docs._getPkgInfo);
+		dojo.docs.getPkgDoc(input, name, dojo.docs._getPkgInfo);
+	},
+	_getPkgInfo: function(/*String*/ type, /*Object*/ data, /*Object*/ evt){
+		dojo.debug("_getPkgInfo() for " + evt.type);
+		var key = evt.selectKey;
+		var input = {};
+		var results = {};
+		if(typeof key == "object"){
+			input = key;
+			key = key.selectKey;
+			input[evt.type] = data;
+			if(input.expects && input.expects.pkginfo){
+				for(var i = 0, expect; expect = input.expects.pkginfo[i]; i++){
+					if(!(expect in input)){
+						dojo.debug("_getPkgInfo() waiting for more data");
+						return;
+					}
+				}
+			}
+			results = input.pkgmeta;
+			results.description = input.pkgdoc;
+		}
+
+		if(input.callback){
+			input.callback("load", results, evt);
+		}
+	},
+	getInfo: function(/*mixed*/ selectKey, /*String*/ name, /*Function*/ callback){
+		dojo.debug("getInfo(" + name + ")");
+		var input = {
+			expects: {
+				"info": ["meta", "doc"]
+			},
+			selectKey: selectKey,
+			callback: callback
+		}
+		dojo.docs.getMeta(input, name, dojo.docs._getInfo);
+		dojo.docs.getDoc(input, name, dojo.docs._getInfo);
+	},
+	_getInfo: function(/*String*/ type, /*String*/ data, /*Object*/ evt, /*Object*/ input){
+		dojo.debug("_getInfo(" + evt.type + ")");
+		if(input && input.expects && input.expects.info){
+			input[evt.type] = data;
+			for(var i = 0, expect; expect = input.expects.info[i]; i++){
+				if(!(expect in input)){
+					dojo.debug("_getInfo() waiting for more data");
+					return;
+				}
+			}
+		}
+
+		if(input.callback){
+			input.callback("load", dojo.docs._getCache(evt.pkg, "meta", "functions", evt.name, evt.id, "meta"), evt, input);
+		}
+	},
+	_getMainText: function(/*String*/ text){
+		// summary: Grabs the innerHTML from a Jot Rech Text node
+		dojo.debug("_getMainText()");
+		return text.replace(/^<html[^<]*>/, "").replace(/<\/html>$/, "").replace(/<\w+\s*\/>/g, "");
+	},
+	getPackageMeta: function(/*Object*/ input){
+		dojo.debug("getPackageMeta(): " + input.pkg);
+		return this.require(input.pkg + "/meta", input.sync);
+	},
+	OLDgetPkgMeta: function(/*mixed*/ selectKey, /*String*/ name, /*Function*/ callback){
+		dojo.debug("getPkgMeta(" + name + ")");
+		var input = {};
+		if(typeof selectKey == "object" && selectKey.selectKey){
+			input = selectKey;
+			selectKey = selectKey.selectKey;
+		}else if(!selectKey){
+			selectKey = ++dojo.docs._count;
+		}
+		dojo.docs._buildCache({
+			type: "pkgmeta",
+			callbacks: [callback],
+			name: name,
+			selectKey: selectKey,
+			input: input
+		});
+	},
+	OLD_getPkgMeta: function(/*Object*/ input){
+		dojo.debug("_getPkgMeta(" + input.name + ")");
+		input.type = "pkgmeta";
+		dojo.docs._buildCache(input);
+	},
+	_onDocSearch: function(/*Object*/ input){
+		var _this = this;
+		var name = input.name.toLowerCase();
+		if(!name) return;
+
+		this.getFunctionNames().addCallback(function(data){
+			dojo.debug("_onDocSearch(): function names loaded for " + name);
+
+			var output = [];
+			var list = [];
+			var closure = function(pkg, fn) {
+				return function(data){
+					dojo.debug("_onDocSearch(): package meta loaded for: " + pkg);
+					if(data.functions){
+						var functions = data.functions;
+						for(var key in functions){
+							if(fn == key){
+								var ids = functions[key];
+								for(var id in ids){
+									var fnMeta = ids[id];
+									output.push({
+										package: pkg,
+										name: fn,
+										id: id,
+										summary: fnMeta.summary
+									});
+								}
+							}
+						}
+					}
+					return output;
+				}
+			}
+
+			pkgLoop:
+			for(var pkg in data){
+				if(pkg.toLowerCase() == name){
+					name = pkg;
+					dojo.debug("_onDocSearch found a package");
+					//dojo.docs._onDocSelectPackage(input);
+					return;
+				}
+				for(var i = 0, fn; fn = data[pkg][i]; i++){
+					if(fn.toLowerCase().indexOf(name) != -1){
+						dojo.debug("_onDocSearch(): Search matched " + fn);
+						var meta = _this.getPackageMeta({pkg: pkg});
+						meta.addCallback(closure(pkg, fn));
+						list.push(meta);
+
+						// Build a list of all packages that need to be loaded and their loaded state.
+						continue pkgLoop;
+					}
+				}
+			}
+			
+			list = new dojo.DeferredList(list);
+			list.addCallback(function(results){
+				dojo.debug("_onDocSearch(): All packages loaded");
+				_this._printFunctionResults(results[0][1]);
+			});
+		});
+	},
+	_onDocSearchFn: function(/*String*/ type, /*Array*/ data, /*Object*/ evt){
+		dojo.debug("_onDocSearchFn(" + evt.name + ")");
+
+		var name = evt.name || evt.pkg;
+
+		dojo.debug("_onDocSearchFn found a function");
+
+		evt.pkgs = packages;
+		evt.pkg = name;
+		evt.loaded = 0;
+		for(var i = 0, pkg; pkg = packages[i]; i++){
+			dojo.docs.getPkgMeta(evt, pkg, dojo.docs._onDocResults);
+		}
+	},
+	_onPkgResults: function(/*String*/ type, /*Object*/ data, /*Object*/ evt, /*Object*/ input){
+		dojo.debug("_onPkgResults(" + evt.type + ")");
+		var description = "";
+		var path = "";
+		var methods = {};
+		var requires = {};
+		if(input){
+			input[evt.type] = data;
+			if(input.expects && input.expects.pkgresults){
+				for(var i = 0, expect; expect = input.expects.pkgresults[i]; i++){
+					if(!(expect in input)){
+						dojo.debug("_onPkgResults() waiting for more data");
+						return;
+					}
+				}
+			}
+			path = input.pkgdoc.path;
+			description = input.pkgdoc.description;
+			methods = input.pkgmeta.methods;
+			requires = input.pkgmeta.requires;
+		}
+		var pkg = evt.name.replace("_", "*");
+		var results = {
+			path: path,
+			description: description,
+			size: 0,
+			methods: [],
+			pkg: pkg,
+			selectKey: evt.selectKey,
+			requires: requires
+		}
+		var rePrivate = /_[^.]+$/;
+		for(var method in methods){
+			if(!rePrivate.test(method)){
+				for(var pId in methods[method]){
+					results.methods.push({
+						pkg: pkg,
+						name: method,
+						id: pId,
+						summary: methods[method][pId].summary
+					})
+				}
+			}
+		}
+		results.size = results.methods.length;
+		dojo.docs._printPkgResult(results);
+	},
+	_onDocResults: function(/*String*/ type, /*Object*/ data, /*Object*/ evt, /*Object*/ input){
+		dojo.debug("_onDocResults(" + evt.name + "/" + input.pkg + ") " + type);
+		++input.loaded;
+
+		if(input.loaded == input.pkgs.length){
+			var pkgs = input.pkgs;
+			var name = input.pkg;
+			var results = {selectKey: evt.selectKey, methods: []};
+			var rePrivate = /_[^.]+$/;
+			data = dojo.docs._cache;
+
+			for(var i = 0, pkg; pkg = pkgs[i]; i++){
+				var methods = dojo.docs._getCache(pkg, "meta", "methods");
+				for(var fn in methods){
+					if(fn.toLowerCase().indexOf(name) == -1){
+						continue;
+					}
+					if(fn != "requires" && !rePrivate.test(fn)){
+						for(var pId in methods[fn]){
+							var result = {
+								pkg: pkg,
+								name: fn,
+								id: "_",
+								summary: ""
+							}
+							if(methods[fn][pId].summary){
+								result.summary = methods[fn][pId].summary;
+							}
+							results.methods.push(result);
+						}
+					}
+				}
+			}
+
+			dojo.debug("Publishing docResults");
+			dojo.docs._printFnResults(results);
+		}
+	},
+	_printFunctionResults: function(results){
+		dojo.debug("_printFnResults(): called");
+		// summary: Call this function to send the /docs/function/results topic
+	},
+	_printPkgResult: function(results){
+		dojo.debug("_printPkgResult(): called");
+	},
+	_onDocSelectFunction: function(/*Object*/ input){
+		// summary: Get doc, meta, and src
+		var name = input.name;
+		var pkg = input.pkg;
+		dojo.debug("_onDocSelectFunction(" + name + ")");
+		if(!name){
+			return false;
+		}
+		if(!input.selectKey){
+			input.selectKey = ++dojo.docs._count;
+		}
+		input.expects = {
+			"docresults": ["meta", "doc", "pkgmeta"]
+		}
+		dojo.docs.getMeta(input, pkg, name, dojo.docs._onDocSelectResults);
+		dojo.docs.getDoc(input, pkg, name, dojo.docs._onDocSelectResults);
+	},
+	_onDocSelectPackage: function(/*Object*/ input){
+		dojo.debug("_onDocSelectPackage(" + input.name + ")")
+		input.expects = {
+			"pkgresults": ["pkgmeta", "pkgdoc"]
+		};
+		if(!input.selectKey){
+			input.selectKey = ++dojo.docs._count;
+		}
+		dojo.docs.getPkgMeta(input, input.name, dojo.docs._onPkgResults);
+		dojo.docs.getPkgDoc(input, input.name, dojo.docs._onPkgResults);
+	},
+	_onDocSelectResults: function(/*String*/ type, /*Object*/ data, /*Object*/ evt, /*Object*/ input){
+		dojo.debug("_onDocSelectResults(" + evt.type + ", " + evt.name + ")");
+		if(evt.type == "meta"){
+			dojo.docs.getPkgMeta(input, evt.pkg, dojo.docs._onDocSelectResults);
+		}
+		if(input){
+			input[evt.type] = data;
+			if(input.expects && input.expects.docresults){
+				for(var i = 0, expect; expect = input.expects.docresults[i]; i++){
+					if(!(expect in input)){
+						dojo.debug("_onDocSelectResults() waiting for more data");
+						return;
+					}
+				}
+			}
+		}
+
+		dojo.docs._printFunctionDetail(input);
+	},
+	
+	_printFunctionDetail: function(results) {
+		// summary: Call this function to send the /docs/function/detail topic event
+	},
+
+	_buildCache: function(/*Object*/ input){
+		dojo.debug("_buildCache(" + input.type + ", " + input.name + ")");
+		// Get stuff from the input object
+		var type = input.type;
+		var pkg = input.pkg;
+		var callbacks = input.callbacks;
+		var id = input.id;
+		if(!id){
+			id = input.id = "_";
+		}
+		var name = input.name;
+		var selectKey = input.selectKey;
+
+		var META = "meta";
+		var METHODS = "methods";
+		var SRC = "src";
+		var DESCRIPTION = "description";
+		var INPUT = "input";
+		var LOAD = "load";
+		var ERROR = "error";
+		
+		var docs = dojo.docs;
+		var getCache = docs._getCache;
+		
+		// Stuff to pass to RPC
+		var search = [];
+	
+		if(type == "doc"){
+			if(!pkg){
+				docs.functionPackages(selectKey, name, function(){ var a = arguments; docs._withPkg.call(this, a[0], a[1], a[2], a[3], "doc"); }, input);
+				return;
+			}else{
+				var cached = getCache(pkg, META, METHODS, name, id, META);
+			
+				if(cached[DESCRIPTION]){
+					callbacks.shift()(LOAD, cached[DESCRIPTION], input, input[INPUT]);
+					return;
+				}
+
+				var obj = {};
+				obj.forFormName = "DocFnForm";
+				obj.limit = 1;
+
+				obj.filter = "it/DocFnForm/require = '" + pkg + "' and it/DocFnForm/name = '" + name + "' and ";
+				if(id == "_"){
+					obj.filter += " not(it/DocFnForm/id)";
+				}else{
+					obj.filter += " it/DocFnForm/id = '" + id + "'";
+				}
+
+				obj.load = function(data){
+					var cached = getCache(pkg, META, METHODS, name, id, META);
+
+					var description = "";
+					var returns = "";
+					if(data.list && data.list.length){
+						description = docs._getMainText(data.list[0]["main/text"]);
+						returns = data.list[0]["DocFnForm/returns"];
+					}
+
+					cached[DESCRIPTION]  = description;
+					if(!cached.returns){
+						cached.returns = {};
+					}
+					cached.returns.summary = returns;
+
+					input.type = "fn";
+					docs._gotDoc(LOAD, cached, input, input[INPUT]);				
+				}
+				obj.error = function(data){
+					input.type = "fn";
+					docs._gotDoc(ERROR, {}, input, input[INPUT]);
+				}
+				search.push(obj);
+
+				obj = {};
+				obj.forFormName = "DocParamForm";
+
+				obj.filter = "it/DocParamForm/fns = '" + pkg + "=>" + name;
+				if(id != "_"){
+					obj.filter += "=>" + id;
+				}
+				obj.filter += "'";
+			
+				obj.load = function(data){
+					var cache = getCache(pkg, META, METHODS, name, id, META);
+					for(var i = 0, param; param = data.list[i]; i++){
+						var pName = param["DocParamForm/name"];
+						if(!cache.parameters[pName]){
+							cache.parameters[pName] = {};
+						}
+						cache.parameters[pName].summary = param["DocParamForm/desc"];
+					}
+					input.type = "param";
+					docs._gotDoc(LOAD, cache.parameters, input);
+				}
+				obj.error = function(data){
+					input.type = "param";
+					docs._gotDoc(ERROR, {}, input);
+				}
+				search.push(obj);
+			}
+		}else if(type == "pkgdoc"){
+			var cached = getCache(name, META);
+
+			if(cached[DESCRIPTION]){
+				callbacks.shift()(LOAD, {description: cached[DESCRIPTION], path: cached.path}, input, input.input);
+				return;
+			}
+
+			var obj = {};
+			obj.forFormName = "DocPkgForm";
+			obj.limit = 1;
+			obj.filter = "it/DocPkgForm/require = '" + name + "'";
+			
+			obj.load = function(data){
+				var description = "";
+				var list = data.list;
+				if(list && list.length && list[0]["main/text"]){
+					description = docs._getMainText(list[0]["main/text"]);
+					cached[DESCRIPTION] = description;
+					cached.path = list[0].name;
+				}
+
+				if(callbacks && callbacks.length){
+					callbacks.shift()(LOAD, {description: description, path: cached.path}, input, input.input);
+				}
+			}
+			obj.error = function(data){
+				if(callbacks && callbacks.length){
+					callbacks.shift()(ERROR, "", input, input.input);
+				}
+			}
+			search.push(obj);
+		}else if(type == "function_names"){
+			var cached = getCache();
+			if(!cached.function_names){
+				dojo.debug("_buildCache() new cache");
+				if(callbacks && callbacks.length){
+					docs._callbacks.function_names.push([input, callbacks.shift()]);
+				}
+				cached.function_names = {loading: true};
+				
+				var obj = {};
+				obj.url = "function_names";
+				obj.load = function(type, data, evt){
+					cached.function_names = data;
+					while(docs._callbacks.function_names.length){
+						var parts = docs._callbacks.function_names.pop();
+						parts[1](LOAD, data, parts[0]);
+					}
+				}
+				obj.error = function(type, data, evt){
+					while(docs._callbacks.function_names.length){
+						var parts = docs._callbacks.function_names.pop();
+						parts[1](LOAD, {}, parts[0]);
+					}
+				}
+				search.push(obj);
+			}else if(cached.function_names.loading){
+				dojo.debug("_buildCache() loading cache, adding to callback list");
+				if(callbacks && callbacks.length){
+					docs._callbacks.function_names.push([input, callbacks.shift()]);
+				}
+				return;
+			}else{
+				dojo.debug("_buildCache() loading from cache");
+				if(callbacks && callbacks.length){
+					callbacks.shift()(LOAD, cached.function_names, input);
+				}
+				return;
+			}
+		}else if(type == META || type == SRC){
+			if(!pkg){
+				if(type == META){
+					docs.functionPackages(selectKey, name, function(){ var a = arguments; docs._withPkg.call(this, a[0], a[1], a[2], a[3], META); }, input);
+					return;
+				}else{
+					docs.functionPackages(selectKey, name, function(){ var a = arguments; docs._withPkg.call(this, a[0], a[1], a[2], a[3], SRC); }, input);
+					return;
+				}
+			}else{
+				var cached = getCache(pkg, META, METHODS, name, id);
+
+				if(cached[type] && cached[type].returns){
+					if(callbacks && callbacks.length){
+						callbacks.shift()(LOAD, cached[type], input);
+						return;
+					}
+				}
+
+				dojo.debug("Finding " + type + " for: " + pkg + ", function: " + name + ", id: " + id);
+
+				var obj = {};
+
+				if(type == SRC){
+					obj.mimetype = "text/plain"
+				}
+				obj.url = pkg + "/" + name + "/" + id + "/" + type;
+				obj.load = function(type, data, evt){
+					dojo.debug("_buildCache() loaded " + input.type);
+
+					if(input.type == SRC){
+						getCache(pkg, META, METHODS, name, id).src = data;
+						if(callbacks && callbacks.length){
+							callbacks.shift()(LOAD, data, input, input[INPUT]);
+						}
+					}else{
+						var cache = getCache(pkg, META, METHODS, name, id, META);
+						if(!cache.parameters){
+							cache.parameters = {};
+						}
+						for(var i = 0, param; param = data.parameters[i]; i++){
+							if(!cache.parameters[param[1]]){
+								cache.parameters[param[1]] = {};
+							}
+							cache.parameters[param[1]].type = param[0];
+						}
+						if(!cache.returns){
+							cache.returns = {};
+						}
+						cache.returns.type = data.returns;
+					}
+
+					if(callbacks && callbacks.length){
+						callbacks.shift()(LOAD, cache, input, input[INPUT]);
+					}
+				}
+				obj.error = function(type, data, evt){
+					if(callbacks && callbacks.length){
+						callbacks.shift()(ERROR, {}, input, input[INPUT]);
+					}
+				}
+			}
+
+			search.push(obj);
+		}else if(type == "pkgmeta"){
+			var cached = getCache(name, "meta");
+
+			if(cached.requires){
+				if(callbacks && callbacks.length){
+					callbacks.shift()(LOAD, cached, input, input[INPUT]);
+					return;
+				}
+			}
+
+			dojo.debug("Finding package meta for: " + name);
+
+			var obj = {};
+
+			obj.url = name + "/meta";
+			obj.load = function(type, data, evt){
+				dojo.debug("_buildCache() loaded for: " + name);
+		
+				var methods = data.methods;
+				if(methods){
+					for(var method in methods){
+						if (method == "is") {
+							continue;
+						}
+						for(var pId in methods[method]){
+							getCache(name, META, METHODS, method, pId, META).summary = methods[method][pId];
+						}
+					}
+				}
+
+				var requires = data.requires;
+				var cache = getCache(name, META);
+				if(requires){
+					cache.requires = requires;
+				}
+				if(callbacks && callbacks.length){
+					callbacks.shift()(LOAD, cache, input, input[INPUT]);
+				}
+			}
+			obj.error = function(type, data, evt){
+				if(callbacks && callbacks.length){
+					callbacks.shift()(ERROR, {}, input, input[INPUT]);
+				}
+			}
+			search.push(obj);
+		}
+		
+		for(var i = 0, obj; obj = search[i]; i++){
+			var load = obj.load;
+			var error = obj.error;
+			delete obj.load;
+			delete obj.error;
+			var mimetype = obj.mimetype;
+			if(!mimetype){
+				mimetype = "text/json"
+			}
+			if(obj.url){
+				dojo.io.bind({
+					url: new dojo.uri.Uri(docs._url, obj.url),
+					input: input,
+					mimetype: mimetype,
+					error: error,
+					load: load
+				});
+			}else{
+				docs._rpc.callRemote("search", obj).addCallbacks(load, error);
+			}
+		}
+	},
+	selectFunction: function(/*String*/ name, /*String?*/ id){
+		// summary: The combined information
+	},
+	savePackage: function(/*Object*/ callbackObject, /*String*/ callback, /*Object*/ parameters){
+		dojo.event.kwConnect({
+			srcObj: dojo.docs,
+			srcFunc: "_savedPkgRpc",
+			targetObj: callbackObject,
+			targetFunc: callback,
+			once: true
+		});
+		
+		var props = {};
+		var cache = dojo.docs._getCache(parameters.pkg, "meta");
+
+		var i = 1;
+
+		if(!cache.path){
+			var path = "id";
+			props[["pname", i].join("")] = "DocPkgForm/require";
+			props[["pvalue", i++].join("")] = parameters.pkg;
+		}else{
+			var path = cache.path;
+		}
+
+		props.form = "//DocPkgForm";
+		props.path = ["/WikiHome/DojoDotDoc/", path].join("");
+
+		if(parameters.description){
+			props[["pname", i].join("")] = "main/text";
+			props[["pvalue", i++].join("")] = parameters.description;
+		}
+		
+		dojo.docs._rpc.callRemote("saveForm",	props).addCallbacks(dojo.docs._pkgRpc, dojo.docs._pkgRpc);
+	},
+	_pkgRpc: function(data){
+		if(data.name){
+			dojo.docs._getCache(data["DocPkgForm/require"], "meta").path = data.name;
+			dojo.docs._savedPkgRpc("load");
+		}else{
+			dojo.docs._savedPkgRpc("error");
+		}
+	},
+	_savedPkgRpc: function(type){
+	},
+	functionPackages: function(/*mixed*/ selectKey, /*String*/ name, /*Function*/ callback, /*Object*/ input){
+		// summary: Gets the package associated with a function and stores it in the .pkg value of input
+		dojo.debug("functionPackages() name: " + name);
+
+		if(!input){
+			input = {};
+		}
+		if(!input.callbacks){
+			input.callbacks = [];
+		}
+
+		input.type = "function_names";
+		input.name = name;
+		input.callbacks.unshift(callback);
+		input.callbacks.unshift(dojo.docs._functionPackages);
+		dojo.docs._buildCache(input);
+	},
+	_functionPackages: function(/*String*/ type, /*Array*/ data, /*Object*/ evt){
+		dojo.debug("_functionPackages() name: " + evt.name);
+		evt.pkg = '';
+
+		var results = [];
+		var data = dojo.docs._cache['function_names'];
+		for(var key in data){
+			if(dojo.lang.inArray(data[key], evt.name)){
+				dojo.debug("_functionPackages() package: " + key);
+				results.push(key);
+			}
+		}
+
+		if(evt.callbacks && evt.callbacks.length){
+			evt.callbacks.shift()(type, results, evt, evt.input);
+		}
+	},
+	setUserName: function(/*String*/ name){
+		dojo.docs._userName = name;
+		if(name && dojo.docs._password){
+			dojo.docs._logIn();
+		}
+	},
+	setPassword: function(/*String*/ password){
+		dojo.docs._password = password;
+		if(password && dojo.docs._userName){
+			dojo.docs._logIn();
+		}
+	},
+	_logIn: function(){
+		dojo.io.bind({
+			url: dojo.docs._rpc.serviceUrl.toString(),
+			method: "post",
+			mimetype: "text/json",
+			content: {
+				username: dojo.docs._userName,
+				password: dojo.docs._password
+			},
+			load: function(type, data){
+				if(data.error){
+					dojo.docs.logInSuccess();
+				}else{
+					dojo.docs.logInFailure();
+				}
+			},
+			error: function(){
+				dojo.docs.logInFailure();
+			}
+		});
+	},
+	logInSuccess: function(){},
+	logInFailure: function(){},
+	_set: function(/*Object*/ base, /*String...*/ keys, /*String*/ value){
+		var args = [];
+		for(var i = 0, arg; arg = arguments[i]; i++){
+			args.push(arg);
+		}
+
+		if(args.length < 3) return;
+		base = args.shift();
+		value = args.pop();
+		var key = args.pop();
+		for(var i = 0, arg; arg = args[i]; i++){
+			if(typeof base[arg] != "object"){
+				base[arg] = {};
+			}
+			base = base[arg];
+		}
+		base[key] = value;
+	},
+	_getCache: function(/*String...*/ keys){
+		var obj = dojo.docs._cache;
+		for(var i = 0; i < arguments.length; i++){
+			var arg = arguments[i];
+			if(!obj[arg]){
+				obj[arg] = {};
+			}
+			obj = obj[arg];
+		}
+		return obj;
+	}
+});
+
+dojo.event.topic.subscribe("/docs/search", dojo.docs, "_onDocSearch");
+dojo.event.topic.subscribe("/docs/function/select", dojo.docs, "_onDocSelectFunction");
+dojo.event.topic.subscribe("/docs/package/select", dojo.docs, "_onDocSelectPackage");
+
+dojo.event.topic.registerPublisher("/docs/function/results", dojo.docs, "_printFunctionResults");
+dojo.event.topic.registerPublisher("/docs/function/detail", dojo.docs, "_printFunctionDetail");
+dojo.event.topic.registerPublisher("/docs/package/detail", dojo.docs, "_printPkgResult");
\ No newline at end of file

Propchange: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/docs.js
------------------------------------------------------------------------------
    svn:eol-style = native



Mime
View raw message