You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@jackrabbit.apache.org by ed...@apache.org on 2006/11/11 17:44:48 UTC
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/ ...
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