source: Dev/trunk/src/client/dojo/dnd/Source.js @ 485

define([
        "../_base/array", "../_base/declare", "../_base/kernel", "../_base/lang",
        "../dom-class", "../dom-geometry", "../mouse", "../ready", "../topic",
        "./common", "./Selector", "./Manager"
], function(array, declare, kernel, lang, domClass, domGeom, mouse, ready, topic,
                        dnd, Selector, Manager){

// module:
//              dojo/dnd/Source

/*
        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
*/

/*=====
var __SourceArgs = {
        // 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"]
        // autoSync: Boolean
        //              if true refreshes the node list on every operation; false by default
        // copyOnly: Boolean?
        //              copy items, if true, use a state of Ctrl key otherwise,
        //              see selfCopy and selfAccept for more details
        // delay: Number
        //              the move delay in pixels before detecting a drag; 0 by default
        // horizontal: Boolean?
        //              a horizontal container, if true, vertical otherwise or when omitted
        // selfCopy: Boolean?
        //              copy items by default when dropping on itself,
        //              false by default, works only if copyOnly is true
        // selfAccept: Boolean?
        //              accept its own items when copyOnly is true,
        //              true by default, works only if copyOnly is true
        // withHandles: Boolean?
        //              allows dragging only by handles, false by default
        // generateText: Boolean?
        //              generate text node for drag and drop, true by default
};
=====*/

// For back-compat, remove in 2.0.
if(!kernel.isAsync){
        ready(0, function(){
                var requires = ["dojo/dnd/AutoSource", "dojo/dnd/Target"];
                require(requires);      // use indirection so modules not rolled into a build
        });
}

var Source = declare("dojo.dnd.Source", 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,
        selfCopy: false,
        selfAccept: true,
        skipForm: false,
        withHandles: false,
        autoSync: false,
        delay: 0, // pixels
        accept: ["text"],
        generateText: true,

        constructor: function(/*DOMNode|String*/ node, /*__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
                lang.mixin(this, lang.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;
                this._lastX = 0;
                this._lastY = 0;
                // states
                this.sourceState  = "";
                if(this.isSource){
                        domClass.add(this.node, "dojoDndSource");
                }
                this.targetState  = "";
                if(this.accept){
                        domClass.add(this.node, "dojoDndTarget");
                }
                if(this.horizontal){
                        domClass.add(this.node, "dojoDndHorizontal");
                }
                // set up events
                this.topics = [
                        topic.subscribe("/dnd/source/over", lang.hitch(this, "onDndSourceOver")),
                        topic.subscribe("/dnd/start",  lang.hitch(this, "onDndStart")),
                        topic.subscribe("/dnd/drop",   lang.hitch(this, "onDndDrop")),
                        topic.subscribe("/dnd/cancel", lang.hitch(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 !this.copyOnly || this.selfAccept;
                }
                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, self){
                // 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" key was pressed
                // self: Boolean?
                //              optional flag that means that we are about to drop on itself

                if(keyPressed){ return true; }
                if(arguments.length < 2){
                        self = this == Manager.manager().target;
                }
                if(self){
                        if(this.copyOnly){
                                return this.selfCopy;
                        }
                }else{
                        return this.copyOnly;
                }
                return false;   // Boolean
        },
        destroy: function(){
                // summary:
                //              prepares the object to be garbage-collected
                Source.superclass.destroy.call(this);
                array.forEach(this.topics, function(t){t.remove();});
                this.targetAnchor = null;
        },

        // mouse event processors
        onMouseMove: function(e){
                // summary:
                //              event processor for onmousemove
                // e: Event
                //              mouse event
                if(this.isDragging && this.targetState == "Disabled"){ return; }
                Source.superclass.onMouseMove.call(this, e);
                var m = Manager.manager();
                if(!this.isDragging){
                        if(this.mouseDown && this.isSource &&
                                        (Math.abs(e.pageX - this._lastX) > this.delay || Math.abs(e.pageY - this._lastY) > this.delay)){
                                var nodes = this.getSelectedNodes();
                                if(nodes.length){
                                        m.startDrag(this, nodes, this.copyState(dnd.getCopyKeyState(e), true));
                                }
                        }
                }
                if(this.isDragging){
                        // calculate before/after
                        var before = false;
                        if(this.current){
                                if(!this.targetBox || this.targetAnchor != this.current){
                                        this.targetBox = domGeom.position(this.current, true);
                                }
                                if(this.horizontal){
                                        // In LTR mode, the left part of the object means "before", but in RTL mode it means "after".
                                        before = (e.pageX - this.targetBox.x < this.targetBox.w / 2) == domGeom.isBodyLtr(this.current.ownerDocument);
                                }else{
                                        before = (e.pageY - this.targetBox.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));
                        }
                }
        },
        onMouseDown: function(e){
                // summary:
                //              event processor for onmousedown
                // e: Event
                //              mouse event
                if(!this.mouseDown && this._legalMouseDown(e) && (!this.skipForm || !dnd.isFormElement(e))){
                        this.mouseDown = true;
                        this._lastX = e.pageX;
                        this._lastY = e.pageY;
                        Source.superclass.onMouseDown.call(this, e);
                }
        },
        onMouseUp: function(e){
                // summary:
                //              event processor for onmouseup
                // e: Event
                //              mouse event
                if(this.mouseDown){
                        this.mouseDown = false;
                        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 = Manager.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.autoSync){ this.sync(); }
                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(this == source){
                        Manager.manager().overSource(this);
                }
                this.isDragging = true;
        },
        onDndDrop: function(source, nodes, copy, target){
                // 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
                // target: Object
                //              the target which accepts items
                if(this == target){
                        // this one is for us => move nodes!
                        this.onDrop(source, nodes, copy);
                }
                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;
                this._changeState("Source", "");
                this._changeState("Target", "");
        },

        // local events
        onDrop: function(source, nodes, copy){
                // summary:
                //              called only on the current target, when drop is performed
                // 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 != source){
                        this.onDropExternal(source, nodes, copy);
                }else{
                        this.onDropInternal(nodes, copy);
                }
        },
        onDropExternal: function(source, nodes, copy){
                // summary:
                //              called only on the current target, when drop is performed
                //              from an external source
                // source: Object
                //              the source which provides items
                // nodes: Array
                //              the list of transferred items
                // copy: Boolean
                //              copy items, if true, move items otherwise

                var oldCreator = this._normalizedCreator;
                // 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 = 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};
                                };
                        }
                }
                this.selectNone();
                if(!copy && !this.creator){
                        source.selectNone();
                }
                this.insertNodes(true, nodes, this.before, this.current);
                if(!copy && this.creator){
                        source.deleteSelectedNodes();
                }
                this._normalizedCreator = oldCreator;
        },
        onDropInternal: function(nodes, copy){
                // summary:
                //              called only on the current target, when drop is performed
                //              from the same target/source
                // nodes: Array
                //              the list of transferred items
                // copy: Boolean
                //              copy items, if true, move items otherwise

                var oldCreator = this._normalizedCreator;
                // transferring nodes within the single source
                if(this.current && this.current.id in this.selection){
                        // do nothing
                        return;
                }
                if(copy){
                        if(this.creator){
                                // create new copies of data items
                                this._normalizedCreator = function(node, hint){
                                        return oldCreator.call(this, this.getItem(node.id).data, hint);
                                };
                        }else{
                                // clone nodes
                                this._normalizedCreator = function(node/*=====, hint =====*/){
                                        var t = this.getItem(node.id);
                                        var n = node.cloneNode(true);
                                        n.id = dnd.getUniqueId();
                                        return {node: n, data: t.data, type: t.type};
                                };
                        }
                }else{
                        // move nodes
                        if(!this.current){
                                // do nothing
                                return;
                        }
                        this._normalizedCreator = function(node /*=====, hint =====*/){
                                var t = this.getItem(node.id);
                                return {node: node, data: t.data, type: t.type};
                        };
                }
                this._removeSelection();
                this.insertNodes(true, nodes, this.before, this.current);
                this._normalizedCreator = oldCreator;
        },
        onDraggingOver: function(){
                // summary:
                //              called during the active DnD operation, when items
                //              are dragged over this target, and it is not disabled
        },
        onDraggingOut: function(){
                // summary:
                //              called during the active DnD operation, when items
                //              are dragged away from this target, and it is not disabled
        },

        // utilities
        onOverEvent: function(){
                // summary:
                //              this function is called once, when mouse is over our container
                Source.superclass.onOverEvent.call(this);
                Manager.manager().overSource(this);
                if(this.isDragging && this.targetState != "Disabled"){
                        this.onDraggingOver();
                }
        },
        onOutEvent: function(){
                // summary:
                //              this function is called once, when mouse is out of our container
                Source.superclass.onOutEvent.call(this);
                Manager.manager().outSource(this);
                if(this.isDragging && this.targetState != "Disabled"){
                        this.onDraggingOut();
                }
        },
        _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

                // accept only the left mouse button, or the left finger
                if(e.type != "touchstart" && !mouse.isLeft(e)){ return false; }

                if(!this.withHandles){ return true; }

                // check for handles
                for(var node = e.target; node && node !== this.node; node = node.parentNode){
                        if(domClass.contains(node, "dojoDndHandle")){ return true; }
                        if(domClass.contains(node, "dojoDndItem") || domClass.contains(node, "dojoDndIgnore")){ break; }
                }
                return false;   // Boolean
        }
});

return Source;

});