diff options
author | 2008-11-13 09:49:11 +0000 | |
---|---|---|
committer | 2008-11-13 09:49:11 +0000 | |
commit | e44a7e37b6c7b5961adaffc62b9042b8d442938e (patch) | |
tree | 95b67c356e93163467db2451f2b8cce84ed5d582 /includes/js/dojo/dnd/Source.js | |
parent | a62b9742ee5e28bcec6872d88f50f25b820914f6 (diff) | |
download | scuttle-e44a7e37b6c7b5961adaffc62b9042b8d442938e.tar.gz scuttle-e44a7e37b6c7b5961adaffc62b9042b8d442938e.zip |
New feature: basic Ajax suggestion for tags and implementation of Dojo toolkit
git-svn-id: https://semanticscuttle.svn.sourceforge.net/svnroot/semanticscuttle/trunk@151 b3834d28-1941-0410-a4f8-b48e95affb8f
Diffstat (limited to 'includes/js/dojo/dnd/Source.js')
-rw-r--r-- | includes/js/dojo/dnd/Source.js | 393 |
1 files changed, 393 insertions, 0 deletions
diff --git a/includes/js/dojo/dnd/Source.js b/includes/js/dojo/dnd/Source.js new file mode 100644 index 0000000..1779756 --- /dev/null +++ b/includes/js/dojo/dnd/Source.js @@ -0,0 +1,393 @@ +if(!dojo._hasResource["dojo.dnd.Source"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. +dojo._hasResource["dojo.dnd.Source"] = true; +dojo.provide("dojo.dnd.Source"); + +dojo.require("dojo.dnd.Selector"); +dojo.require("dojo.dnd.Manager"); + +/* + Container property: + "Horizontal"- if this is the horizontal container + Source states: + "" - normal state + "Moved" - this source is being moved + "Copied" - this source is being copied + Target states: + "" - normal state + "Disabled" - the target cannot accept an avatar + Target anchor state: + "" - item is not selected + "Before" - insert point is before the anchor + "After" - insert point is after the anchor +*/ + +/*===== +dojo.dnd.__SourceArgs = function(){ + // summary: + // a dict of parameters for DnD Source configuration. Note that any + // property on Source elements may be configured, but this is the + // short-list + // isSource: Boolean? + // can be used as a DnD source. Defaults to true. + // accept: Array? + // list of accepted types (text strings) for a target; defaults to + // ["text"] + // horizontal: Boolean? + // a horizontal container, if true, vertical otherwise or when omitted + // copyOnly: Boolean? + // always copy items, if true, use a state of Ctrl key otherwise + // withHandles: Boolean? + // allows dragging only by handles + this.isSource = isSource; + this.accept = accept; + this.horizontal = horizontal; + this.copyOnly = copyOnly; + this.withHandles = withHandles; +} +=====*/ + +dojo.declare("dojo.dnd.Source", dojo.dnd.Selector, { + // summary: a Source object, which can be used as a DnD source, or a DnD target + + // object attributes (for markup) + isSource: true, + horizontal: false, + copyOnly: false, + skipForm: false, + withHandles: false, + accept: ["text"], + + constructor: function(/*DOMNode|String*/node, /*dojo.dnd.__SourceArgs?*/params){ + // summary: + // a constructor of the Source + // node: + // node or node's id to build the source on + // params: + // any property of this class may be configured via the params + // object which is mixed-in to the `dojo.dnd.Source` instance + dojo.mixin(this, dojo.mixin({}, params)); + var type = this.accept; + if(type.length){ + this.accept = {}; + for(var i = 0; i < type.length; ++i){ + this.accept[type[i]] = 1; + } + } + // class-specific variables + this.isDragging = false; + this.mouseDown = false; + this.targetAnchor = null; + this.targetBox = null; + this.before = true; + // states + this.sourceState = ""; + if(this.isSource){ + dojo.addClass(this.node, "dojoDndSource"); + } + this.targetState = ""; + if(this.accept){ + dojo.addClass(this.node, "dojoDndTarget"); + } + if(this.horizontal){ + dojo.addClass(this.node, "dojoDndHorizontal"); + } + // set up events + this.topics = [ + dojo.subscribe("/dnd/source/over", this, "onDndSourceOver"), + dojo.subscribe("/dnd/start", this, "onDndStart"), + dojo.subscribe("/dnd/drop", this, "onDndDrop"), + dojo.subscribe("/dnd/cancel", this, "onDndCancel") + ]; + }, + + // methods + checkAcceptance: function(source, nodes){ + // summary: checks, if the target can accept nodes from this source + // source: Object: the source which provides items + // nodes: Array: the list of transferred items + if(this == source){ return true; } + for(var i = 0; i < nodes.length; ++i){ + var type = source.getItem(nodes[i].id).type; + // type instanceof Array + var flag = false; + for(var j = 0; j < type.length; ++j){ + if(type[j] in this.accept){ + flag = true; + break; + } + } + if(!flag){ + return false; // Boolean + } + } + return true; // Boolean + }, + copyState: function(keyPressed){ + // summary: Returns true, if we need to copy items, false to move. + // It is separated to be overwritten dynamically, if needed. + // keyPressed: Boolean: the "copy" was pressed + return this.copyOnly || keyPressed; // Boolean + }, + destroy: function(){ + // summary: prepares the object to be garbage-collected + dojo.dnd.Source.superclass.destroy.call(this); + dojo.forEach(this.topics, dojo.unsubscribe); + this.targetAnchor = null; + }, + + // markup methods + markupFactory: function(params, node){ + params._skipStartup = true; + return new dojo.dnd.Source(node, params); + }, + + // mouse event processors + onMouseMove: function(e){ + // summary: event processor for onmousemove + // e: Event: mouse event + if(this.isDragging && this.targetState == "Disabled"){ return; } + dojo.dnd.Source.superclass.onMouseMove.call(this, e); + var m = dojo.dnd.manager(); + if(this.isDragging){ + // calculate before/after + var before = false; + if(this.current){ + if(!this.targetBox || this.targetAnchor != this.current){ + this.targetBox = { + xy: dojo.coords(this.current, true), + w: this.current.offsetWidth, + h: this.current.offsetHeight + }; + } + if(this.horizontal){ + before = (e.pageX - this.targetBox.xy.x) < (this.targetBox.w / 2); + }else{ + before = (e.pageY - this.targetBox.xy.y) < (this.targetBox.h / 2); + } + } + if(this.current != this.targetAnchor || before != this.before){ + this._markTargetAnchor(before); + m.canDrop(!this.current || m.source != this || !(this.current.id in this.selection)); + } + }else{ + if(this.mouseDown && this.isSource){ + var nodes = this.getSelectedNodes(); + if(nodes.length){ + m.startDrag(this, nodes, this.copyState(dojo.dnd.getCopyKeyState(e))); + } + } + } + }, + onMouseDown: function(e){ + // summary: event processor for onmousedown + // e: Event: mouse event + if(this._legalMouseDown(e) && (!this.skipForm || !dojo.dnd.isFormElement(e))){ + this.mouseDown = true; + this.mouseButton = e.button; + dojo.dnd.Source.superclass.onMouseDown.call(this, e); + } + }, + onMouseUp: function(e){ + // summary: event processor for onmouseup + // e: Event: mouse event + if(this.mouseDown){ + this.mouseDown = false; + dojo.dnd.Source.superclass.onMouseUp.call(this, e); + } + }, + + // topic event processors + onDndSourceOver: function(source){ + // summary: topic event processor for /dnd/source/over, called when detected a current source + // source: Object: the source which has the mouse over it + if(this != source){ + this.mouseDown = false; + if(this.targetAnchor){ + this._unmarkTargetAnchor(); + } + }else if(this.isDragging){ + var m = dojo.dnd.manager(); + m.canDrop(this.targetState != "Disabled" && (!this.current || m.source != this || !(this.current.id in this.selection))); + } + }, + onDndStart: function(source, nodes, copy){ + // summary: topic event processor for /dnd/start, called to initiate the DnD operation + // source: Object: the source which provides items + // nodes: Array: the list of transferred items + // copy: Boolean: copy items, if true, move items otherwise + if(this.isSource){ + this._changeState("Source", this == source ? (copy ? "Copied" : "Moved") : ""); + } + var accepted = this.accept && this.checkAcceptance(source, nodes); + this._changeState("Target", accepted ? "" : "Disabled"); + if(accepted && this == source){ + dojo.dnd.manager().overSource(this); + } + this.isDragging = true; + }, + onDndDrop: function(source, nodes, copy){ + // summary: topic event processor for /dnd/drop, called to finish the DnD operation + // source: Object: the source which provides items + // nodes: Array: the list of transferred items + // copy: Boolean: copy items, if true, move items otherwise + do{ //break box + if(this.containerState != "Over"){ break; } + var oldCreator = this._normalizedCreator; + if(this != source){ + // transferring nodes from the source to the target + if(this.creator){ + // use defined creator + this._normalizedCreator = function(node, hint){ + return oldCreator.call(this, source.getItem(node.id).data, hint); + }; + }else{ + // we have no creator defined => move/clone nodes + if(copy){ + // clone nodes + this._normalizedCreator = function(node, hint){ + var t = source.getItem(node.id); + var n = node.cloneNode(true); + n.id = dojo.dnd.getUniqueId(); + return {node: n, data: t.data, type: t.type}; + }; + }else{ + // move nodes + this._normalizedCreator = function(node, hint){ + var t = source.getItem(node.id); + source.delItem(node.id); + return {node: node, data: t.data, type: t.type}; + }; + } + } + }else{ + // transferring nodes within the single source + if(this.current && this.current.id in this.selection){ break; } + if(this.creator){ + // use defined creator + if(copy){ + // create new copies of data items + this._normalizedCreator = function(node, hint){ + return oldCreator.call(this, source.getItem(node.id).data, hint); + }; + }else{ + // move nodes + if(!this.current){ break; } + this._normalizedCreator = function(node, hint){ + var t = source.getItem(node.id); + return {node: node, data: t.data, type: t.type}; + }; + } + }else{ + // we have no creator defined => move/clone nodes + if(copy){ + // clone nodes + this._normalizedCreator = function(node, hint){ + var t = source.getItem(node.id); + var n = node.cloneNode(true); + n.id = dojo.dnd.getUniqueId(); + return {node: n, data: t.data, type: t.type}; + }; + }else{ + // move nodes + if(!this.current){ break; } + this._normalizedCreator = function(node, hint){ + var t = source.getItem(node.id); + return {node: node, data: t.data, type: t.type}; + }; + } + } + } + this._removeSelection(); + if(this != source){ + this._removeAnchor(); + } + if(this != source && !copy && !this.creator){ + source.selectNone(); + } + this.insertNodes(true, nodes, this.before, this.current); + if(this != source && !copy && this.creator){ + source.deleteSelectedNodes(); + } + this._normalizedCreator = oldCreator; + }while(false); + this.onDndCancel(); + }, + onDndCancel: function(){ + // summary: topic event processor for /dnd/cancel, called to cancel the DnD operation + if(this.targetAnchor){ + this._unmarkTargetAnchor(); + this.targetAnchor = null; + } + this.before = true; + this.isDragging = false; + this.mouseDown = false; + delete this.mouseButton; + this._changeState("Source", ""); + this._changeState("Target", ""); + }, + + // utilities + onOverEvent: function(){ + // summary: this function is called once, when mouse is over our container + dojo.dnd.Source.superclass.onOverEvent.call(this); + dojo.dnd.manager().overSource(this); + }, + onOutEvent: function(){ + // summary: this function is called once, when mouse is out of our container + dojo.dnd.Source.superclass.onOutEvent.call(this); + dojo.dnd.manager().outSource(this); + }, + _markTargetAnchor: function(before){ + // summary: assigns a class to the current target anchor based on "before" status + // before: Boolean: insert before, if true, after otherwise + if(this.current == this.targetAnchor && this.before == before){ return; } + if(this.targetAnchor){ + this._removeItemClass(this.targetAnchor, this.before ? "Before" : "After"); + } + this.targetAnchor = this.current; + this.targetBox = null; + this.before = before; + if(this.targetAnchor){ + this._addItemClass(this.targetAnchor, this.before ? "Before" : "After"); + } + }, + _unmarkTargetAnchor: function(){ + // summary: removes a class of the current target anchor based on "before" status + if(!this.targetAnchor){ return; } + this._removeItemClass(this.targetAnchor, this.before ? "Before" : "After"); + this.targetAnchor = null; + this.targetBox = null; + this.before = true; + }, + _markDndStatus: function(copy){ + // summary: changes source's state based on "copy" status + this._changeState("Source", copy ? "Copied" : "Moved"); + }, + _legalMouseDown: function(e){ + // summary: checks if user clicked on "approved" items + // e: Event: mouse event + if(!this.withHandles){ return true; } + for(var node = e.target; node && !dojo.hasClass(node, "dojoDndItem"); node = node.parentNode){ + if(dojo.hasClass(node, "dojoDndHandle")){ return true; } + } + return false; // Boolean + } +}); + +dojo.declare("dojo.dnd.Target", dojo.dnd.Source, { + // summary: a Target object, which can be used as a DnD target + + constructor: function(node, params){ + // summary: a constructor of the Target --- see the Source constructor for details + this.isSource = false; + dojo.removeClass(this.node, "dojoDndSource"); + }, + + // markup methods + markupFactory: function(params, node){ + params._skipStartup = true; + return new dojo.dnd.Target(node, params); + } +}); + +} |