Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dijit._tree.dndSource"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dijit._tree.dndSource"] = true;
dojo.provide("dijit._tree.dndSource");

dojo.require("dijit._tree.dndSelector");
dojo.require("dojo.dnd.Manager");

dojo.declare("dijit._tree.dndSource", dijit._tree.dndSelector, {
        // summary: a Source object, which can be used as a DnD source, or a DnD target
        
        // object attributes (for markup)
        isSource: true,
        copyOnly: false,
        skipForm: false,
        accept: ["text"],
        
        constructor: function(node, params){
                // summary: a constructor of the Source
                // node: Node: node or node's id to build the source on
                // params: Object: a dict of parameters, recognized parameters are:
                //      isSource: Boolean: can be used as a DnD source, if true; assumed to be "true" if omitted
                //      accept: Array: list of accepted types (text strings) for a target; assumed to be ["text"] if omitted
                //      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
                //      skipForm: Boolean: don't start the drag operation, if clicked on form elements
                //      the rest of parameters are passed to the selector
                if(!params){ params = {}; }
                dojo.mixin(this, params);
                this.isSource = typeof params.isSource == "undefined" ? true : params.isSource;
                var type = params.accept instanceof Array ? params.accept : ["text"];
                this.accept = null;
                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")
                ];
        },

        startup: function(){
        },
        
        // 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
                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
                this.inherited("destroy",arguments);
                dojo.forEach(this.topics, dojo.unsubscribe);
                this.targetAnchor = null;
        },

        // markup methods
        markupFactory: function(params, node){
                params._skipStartup = true;
                return new dijit._tree.dndSource(node, params);
        },

        // mouse event processors
        onMouseMove: function(e){
                // summary: event processor for onmousemove
                // e: Event: mouse event
                if(this.isDragging && this.targetState == "Disabled"){ return; }
                this.inherited("onMouseMove", arguments);
                var m = dojo.dnd.manager();
                if(this.isDragging){
                        // calculate before/after

                        if (this.allowBetween){ // not implemented yet for tree since it has no concept of order
                                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 n = this.getSelectedNodes();
                                var nodes=[];
                                for (var i in n){
                                        nodes.push(n[i]);
                                }
                                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
                this.mouseDown = true;
                this.mouseButton = e.button;
                this.inherited("onMouseDown",arguments);
        },

        onMouseUp: function(e){
                // summary: event processor for onmouseup
                // e: Event: mouse event
                if(this.mouseDown){
                        this.mouseDown = false;
                        this.inherited("onMouseUp",arguments);
                }
        },

        onMouseOver: function(e){
                // summary: event processor for onmouseover
                // e: Event: mouse event
                var n = e.relatedTarget;
                while(n){
                        if(n == this.node){ break; }
                        try{
                                n = n.parentNode;
                        }catch(x){
                                n = null;
                        }
                }
                if(!n){
                        this._changeState("Container", "Over");
                        this.onOverEvent();
                }
                n = this._getChildByEvent(e);
                if(this.current == n){ return; }
                if(this.current){ this._removeItemClass(this.current, "Over"); }
                if(n){ 
                        this._addItemClass(n, "Over"); 
                        if(this.isDragging){
                                var m = dojo.dnd.manager();
                                if(this.checkItemAcceptance(n,m.source)){
                                        m.canDrop(this.targetState != "Disabled" && (!this.current || m.source != this || !(this.current.id in this.selection)));
                                }else{
                                        m.canDrop(false);
                                }
                        }
                }else{
                        if(this.isDragging){
                                var m = dojo.dnd.manager();
                                if (m.source && this.checkAcceptance(m.source,m.source.getSelectedNodes())){
                                        m.canDrop(this.targetState != "Disabled" && (!this.current || m.source != this || !(this.current.id in this.selection)));
                                }else{
                                        m.canDrop(false);
                                }
                        }
                }
                this.current = n;
        },

        checkItemAcceptance: function(node, source){
                // summary: stub funciton to be overridden if one wants to check for the ability to drop at the node/item level 
                        return true;    
        },
        
        // 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.checkAcceptance(source, nodes);

                this._changeState("Target", accepted ? "" : "Disabled");

                if(accepted){
                        dojo.dnd.manager().overSource(this);
                }

                this.isDragging = true;
        },

        itemCreator: function(nodes){
                var items = []

                for(var i=0;i<nodes.length;i++){
                        items.push({
                                "name":nodes[i].textContent,
                                "id": nodes[i].id
                        });
                }

                return items;
        },

        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

                if(this.containerState == "Over"){
                        this.isDragging = false;
                        var target = this.current;
                        var items = this.itemCreator(nodes, target);
                        if(!target || target == this.tree.domNode){
                                for(var i = 0; i < items.length; i++){
                                        this.tree.store.newItem(items[i], null);
                                }
                        }else{
                                for(var i = 0; i < items.length; i++){
                                        pInfo = {parent: dijit.getEnclosingWidget(target).item, attribute: "children"};
                                        var newItem = this.tree.store.newItem(items[i], pInfo);
                                        console.log("newItem:", newItem);
                                }
                        }
                }
                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
                this.inherited("onOverEvent",arguments);
                dojo.dnd.manager().overSource(this);
        },
        onOutEvent: function(){
                // summary: this function is called once, when mouse is out of our container
                this.inherited("onOutEvent",arguments); 
                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");
        }
});

dojo.declare("dijit._tree.dndTarget", dijit._tree.dndSource, {
        // 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 dijit._tree.dndTarget(node, params);
        }
});

}