first commit

lib/yuilib/3.18.1/dd-ddm-drop/dd-ddm-drop-debug.js

@@ -0,0 +1,399 @@
+YUI.add('dd-ddm-drop', function (Y, NAME) {
+
+
+    /**
+     * Extends the dd-ddm Class to add support for the placement of Drop Target
+     * shims inside the viewport shim. It also handles all Drop Target related events and interactions.
+     * @module dd
+     * @submodule dd-ddm-drop
+     * @for DDM
+     * @namespace DD
+     */
+
+    //TODO CSS class name for the bestMatch..
+    Y.mix(Y.DD.DDM, {
+        /**
+        * This flag turns off the use of the mouseover/mouseout shim. It should not be used unless you know what you are doing.
+        * @private
+        * @property _noShim
+        * @type {Boolean}
+        */
+        _noShim: false,
+        /**
+        * Placeholder for all active shims on the page
+        * @private
+        * @property _activeShims
+        * @type {Array}
+        */
+        _activeShims: [],
+        /**
+        * This method checks the _activeShims Object to see if there is a shim active.
+        * @private
+        * @method _hasActiveShim
+        * @return {Boolean}
+        */
+        _hasActiveShim: function() {
+            if (this._noShim) {
+                return true;
+            }
+            return this._activeShims.length;
+        },
+        /**
+        * Adds a Drop Target to the list of active shims
+        * @private
+        * @method _addActiveShim
+        * @param {Object} d The Drop instance to add to the list.
+        */
+        _addActiveShim: function(d) {
+            this._activeShims.push(d);
+        },
+        /**
+        * Removes a Drop Target to the list of active shims
+        * @private
+        * @method _removeActiveShim
+        * @param {Object} d The Drop instance to remove from the list.
+        */
+        _removeActiveShim: function(d) {
+            var s = [];
+            Y.Array.each(this._activeShims, function(v) {
+                if (v._yuid !== d._yuid) {
+                    s.push(v);
+                }
+
+            });
+            this._activeShims = s;
+        },
+        /**
+        * This method will sync the position of the shims on the Drop Targets that are currently active.
+        * @method syncActiveShims
+        * @param {Boolean} force Resize/sync all Targets.
+        */
+        syncActiveShims: function(force) {
+            Y.later(0, this, function(force) {
+                var drops = ((force) ? this.targets : this._lookup());
+                Y.Array.each(drops, function(v) {
+                    v.sizeShim.call(v);
+                }, this);
+            }, force);
+        },
+        /**
+        * The mode that the drag operations will run in 0 for Point, 1 for Intersect, 2 for Strict
+        * @private
+        * @property mode
+        * @type Number
+        */
+        mode: 0,
+        /**
+        * In point mode, a Drop is targeted by the cursor being over the Target
+        * @private
+        * @property POINT
+        * @type Number
+        */
+        POINT: 0,
+        /**
+        * In intersect mode, a Drop is targeted by "part" of the drag node being over the Target
+        * @private
+        * @property INTERSECT
+        * @type Number
+        */
+        INTERSECT: 1,
+        /**
+        * In strict mode, a Drop is targeted by the "entire" drag node being over the Target
+        * @private
+        * @property STRICT
+        * @type Number
+        */
+        STRICT: 2,
+        /**
+        * Should we only check targets that are in the viewport on drags (for performance), default: true
+        * @property useHash
+        * @type {Boolean}
+        */
+        useHash: true,
+        /**
+        * A reference to the active Drop Target
+        * @property activeDrop
+        * @type {Object}
+        */
+        activeDrop: null,
+        /**
+        * An array of the valid Drop Targets for this interaction.
+        * @property validDrops
+        * @type {Array}
+        */
+        //TODO Change array/object literals to be in sync..
+        validDrops: [],
+        /**
+        * An object literal of Other Drop Targets that we encountered during this interaction (in the case of overlapping Drop Targets)
+        * @property otherDrops
+        * @type {Object}
+        */
+        otherDrops: {},
+        /**
+        * All of the Targets
+        * @property targets
+        * @type {Array}
+        */
+        targets: [],
+        /**
+        * Add a Drop Target to the list of Valid Targets. This list get's regenerated on each new drag operation.
+        * @private
+        * @method _addValid
+        * @param {Object} drop
+        * @chainable
+        */
+        _addValid: function(drop) {
+            this.validDrops.push(drop);
+            return this;
+        },
+        /**
+        * Removes a Drop Target from the list of Valid Targets. This list get's regenerated on each new drag operation.
+        * @private
+        * @method _removeValid
+        * @param {Object} drop
+        * @chainable
+        */
+        _removeValid: function(drop) {
+            var drops = [];
+            Y.Array.each(this.validDrops, function(v) {
+                if (v !== drop) {
+                    drops.push(v);
+                }
+            });
+
+            this.validDrops = drops;
+            return this;
+        },
+        /**
+        * Check to see if the Drag element is over the target, method varies on current mode
+        * @method isOverTarget
+        * @param {Object} drop The drop to check against
+        * @return {Boolean}
+        */
+        isOverTarget: function(drop) {
+            if (this.activeDrag && drop) {
+                var xy = this.activeDrag.mouseXY, r, dMode = this.activeDrag.get('dragMode'),
+                    aRegion, node = drop.shim;
+                if (xy && this.activeDrag) {
+                    aRegion = this.activeDrag.region;
+                    if (dMode === this.STRICT) {
+                        return this.activeDrag.get('dragNode').inRegion(drop.region, true, aRegion);
+                    }
+                    if (drop && drop.shim) {
+                        if ((dMode === this.INTERSECT) && this._noShim) {
+                            r = aRegion || this.activeDrag.get('node');
+                            return drop.get('node').intersect(r, drop.region).inRegion;
+                        }
+
+                        if (this._noShim) {
+                            node = drop.get('node');
+                        }
+                        return node.intersect({
+                            top: xy[1],
+                            bottom: xy[1],
+                            left: xy[0],
+                            right: xy[0]
+                        }, drop.region).inRegion;
+                    }
+                }
+            }
+            return false;
+        },
+        /**
+        * Clears the cache data used for this interaction.
+        * @method clearCache
+        */
+        clearCache: function() {
+            this.validDrops = [];
+            this.otherDrops = {};
+            this._activeShims = [];
+        },
+        /**
+        * Clear the cache and activate the shims of all the targets
+        * @private
+        * @method _activateTargets
+        */
+        _activateTargets: function() {
+            this._noShim = true;
+            this.clearCache();
+            Y.Array.each(this.targets, function(v) {
+                v._activateShim([]);
+                if (v.get('noShim') === true) {
+                    this._noShim = false;
+                }
+            }, this);
+            this._handleTargetOver();
+
+        },
+        /**
+        * This method will gather the area for all potential targets and see which has the hightest covered area and return it.
+        * @method getBestMatch
+        * @param {Array} drops An Array of drops to scan for the best match.
+        * @param {Boolean} all If present, it returns an Array. First item is best match, second is an Array of the other items in the original Array.
+        * @return {Object or Array}
+        */
+        getBestMatch: function(drops, all) {
+            var biggest = null, area = 0, out;
+
+            Y.Object.each(drops, function(v) {
+                var inter = this.activeDrag.get('dragNode').intersect(v.get('node'));
+                v.region.area = inter.area;
+
+                if (inter.inRegion) {
+                    if (inter.area > area) {
+                        area = inter.area;
+                        biggest = v;
+                    }
+                }
+            }, this);
+            if (all) {
+                out = [];
+                //TODO Sort the others in numeric order by area covered..
+                Y.Object.each(drops, function(v) {
+                    if (v !== biggest) {
+                        out.push(v);
+                    }
+                }, this);
+                return [biggest, out];
+            }
+            return biggest;
+        },
+        /**
+        * This method fires the drop:hit, drag:drophit, drag:dropmiss methods and deactivates the shims..
+        * @private
+        * @method _deactivateTargets
+        */
+        _deactivateTargets: function() {
+            var other = [], tmp,
+                activeDrag = this.activeDrag,
+                activeDrop = this.activeDrop;
+
+            //TODO why is this check so hard??
+            if (activeDrag && activeDrop && this.otherDrops[activeDrop]) {
+                if (!activeDrag.get('dragMode')) {
+                    //TODO otherDrops -- private..
+                    other = this.otherDrops;
+                    delete other[activeDrop];
+                } else {
+                    tmp = this.getBestMatch(this.otherDrops, true);
+                    activeDrop = tmp[0];
+                    other = tmp[1];
+                }
+                activeDrag.get('node').removeClass(this.CSS_PREFIX + '-drag-over');
+                if (activeDrop) {
+                    activeDrop.fire('drop:hit', { drag: activeDrag, drop: activeDrop, others: other });
+                    activeDrag.fire('drag:drophit', { drag: activeDrag,  drop: activeDrop, others: other });
+                }
+            } else if (activeDrag && activeDrag.get('dragging')) {
+                activeDrag.get('node').removeClass(this.CSS_PREFIX + '-drag-over');
+                activeDrag.fire('drag:dropmiss', { pageX: activeDrag.lastXY[0], pageY: activeDrag.lastXY[1] });
+            }
+
+            this.activeDrop = null;
+
+            Y.Array.each(this.targets, function(v) {
+                v._deactivateShim([]);
+            }, this);
+        },
+        /**
+        * This method is called when the move method is called on the Drag Object.
+        * @private
+        * @method _dropMove
+        */
+        _dropMove: function() {
+            if (this._hasActiveShim()) {
+                this._handleTargetOver();
+            } else {
+                Y.Object.each(this.otherDrops, function(v) {
+                    v._handleOut.apply(v, []);
+                });
+            }
+        },
+        /**
+        * Filters the list of Drops down to those in the viewport.
+        * @private
+        * @method _lookup
+        * @return {Array} The valid Drop Targets that are in the viewport.
+        */
+        _lookup: function() {
+            if (!this.useHash || this._noShim) {
+                return this.validDrops;
+            }
+            var drops = [];
+            //Only scan drop shims that are in the Viewport
+            Y.Array.each(this.validDrops, function(v) {
+                if (v.shim && v.shim.inViewportRegion(false, v.region)) {
+                    drops.push(v);
+                }
+            });
+            return drops;
+
+        },
+        /**
+        * This method execs _handleTargetOver on all valid Drop Targets
+        * @private
+        * @method _handleTargetOver
+        */
+        _handleTargetOver: function() {
+            var drops = this._lookup();
+            Y.Array.each(drops, function(v) {
+                v._handleTargetOver.call(v);
+            }, this);
+        },
+        /**
+        * Add the passed in Target to the targets collection
+        * @private
+        * @method _regTarget
+        * @param {Object} t The Target to add to the targets collection
+        */
+        _regTarget: function(t) {
+            this.targets.push(t);
+        },
+        /**
+        * Remove the passed in Target from the targets collection
+        * @private
+        * @method _unregTarget
+        * @param {Object} drop The Target to remove from the targets collection
+        */
+        _unregTarget: function(drop) {
+            var targets = [], vdrops;
+            Y.Array.each(this.targets, function(v) {
+                if (v !== drop) {
+                    targets.push(v);
+                }
+            }, this);
+            this.targets = targets;
+
+            vdrops = [];
+            Y.Array.each(this.validDrops, function(v) {
+                if (v !== drop) {
+                    vdrops.push(v);
+                }
+            });
+
+            this.validDrops = vdrops;
+        },
+        /**
+        * Get a valid Drop instance back from a Node or a selector string, false otherwise
+        * @method getDrop
+        * @param {String/Object} node The Node instance or Selector string to check for a valid Drop Object
+        * @return {Object}
+        */
+        getDrop: function(node) {
+            var drop = false,
+                n = Y.one(node);
+            if (n instanceof Y.Node) {
+                Y.Array.each(this.targets, function(v) {
+                    if (n.compareTo(v.get('node'))) {
+                        drop = v;
+                    }
+                });
+            }
+            return drop;
+        }
+    }, true);
+
+
+
+
+}, '3.18.1', {"requires": ["dd-ddm"]});

lib/yuilib/3.18.1/dd-ddm-drop/dd-ddm-drop-min.js

@@ -0,0 +1 @@
+YUI.add("dd-ddm-drop",function(e,t){e.mix(e.DD.DDM,{_noShim:!1,_activeShims:[],_hasActiveShim:function(){return this._noShim?!0:this._activeShims.length},_addActiveShim:function(e){this._activeShims.push(e)},_removeActiveShim:function(t){var n=[];e.Array.each(this._activeShims,function(e){e._yuid!==t._yuid&&n.push(e)}),this._activeShims=n},syncActiveShims:function(t){e.later(0,this,function(t){var n=t?this.targets:this._lookup();e.Array.each(n,function(e){e.sizeShim.call(e)},this)},t)},mode:0,POINT:0,INTERSECT:1,STRICT:2,useHash:!0,activeDrop:null,validDrops:[],otherDrops:{},targets:[],_addValid:function(e){return this.validDrops.push(e),this},_removeValid:function(t){var n=[];return e.Array.each(this.validDrops,function(e){e!==t&&n.push(e)}),this.validDrops=n,this},isOverTarget:function(e){if(this.activeDrag&&e){var t=this.activeDrag.mouseXY,n,r=this.activeDrag.get("dragMode"),i,s=e.shim;if(t&&this.activeDrag){i=this.activeDrag.region;if(r===this.STRICT)return this.activeDrag.get("dragNode").inRegion(e.region,!0,i);if(e&&e.shim)return r===this.INTERSECT&&this._noShim?(n=i||this.activeDrag.get("node"),e.get("node").intersect(n,e.region).inRegion):(this._noShim&&(s=e.get("node")),s.intersect({top:t[1],bottom:t[1],left:t[0],right:t[0]},e.region).inRegion)}}return!1},clearCache:function(){this.validDrops=[],this.otherDrops={},this._activeShims=[]},_activateTargets:function(){this._noShim=!0,this.clearCache(),e.Array.each(this.targets,function(e){e._activateShim([]),e.get("noShim")===!0&&(this._noShim=!1)},this),this._handleTargetOver()},getBestMatch:function(t,n){var r=null,i=0,s;return e.Object.each(t,function(e){var t=this.activeDrag.get("dragNode").intersect(e.get("node"));e.region.area=t.area,t.inRegion&&t.area>i&&(i=t.area,r=e)},this),n?(s=[],e.Object.each(t,function(e){e!==r&&s.push(e)},this),[r,s]):r},_deactivateTargets:function(){var t=[],n,r=this.activeDrag,i=this.activeDrop;r&&i&&this.otherDrops[i]?(r.get("dragMode")?(n=this.getBestMatch(this.otherDrops,!0),i=n[0],t=n[1]):(t=this.otherDrops,delete t[i]),r.get("node").removeClass(this.CSS_PREFIX+"-drag-over"),i&&(i.fire("drop:hit",{drag:r,drop:i,others:t}),r.fire("drag:drophit",{drag:r,drop:i,others:t}))):r&&r.get("dragging")&&(r.get("node").removeClass(this.CSS_PREFIX+"-drag-over"),r.fire("drag:dropmiss",{pageX:r.lastXY[0],pageY:r.lastXY[1]})),this.activeDrop=null,e.Array.each(this.targets,function(e){e._deactivateShim([])},this)},_dropMove:function(){this._hasActiveShim()?this._handleTargetOver():e.Object.each(this.otherDrops,function(e){e._handleOut.apply(e,[])})},_lookup:function(){if(!this.useHash||this._noShim)return this.validDrops;var t=[];return e.Array.each(this.validDrops,function(e){e.shim&&e.shim.inViewportRegion(!1,e.region)&&t.push(e)}),t},_handleTargetOver:function(){var t=this._lookup();e.Array.each(t,function(e){e._handleTargetOver.call(e)},this)},_regTarget:function(e){this.targets.push(e)},_unregTarget:function(t){var n=[],r;e.Array.each(this.targets,function(e){e!==t&&n.push(e)},this),this.targets=n,r=[],e.Array.each(this.validDrops,function(e){e!==t&&r.push(e)}),this.validDrops=r},getDrop:function(t){var n=!1,r=e.one(t);return r instanceof e.Node&&e.Array.each(this.targets,function(e){r.compareTo(e.get("node"))&&(n=e)}),n}},!0)},"3.18.1",{requires:["dd-ddm"]});

lib/yuilib/3.18.1/dd-ddm-drop/dd-ddm-drop.js

@@ -0,0 +1,399 @@
+YUI.add('dd-ddm-drop', function (Y, NAME) {
+
+
+    /**
+     * Extends the dd-ddm Class to add support for the placement of Drop Target
+     * shims inside the viewport shim. It also handles all Drop Target related events and interactions.
+     * @module dd
+     * @submodule dd-ddm-drop
+     * @for DDM
+     * @namespace DD
+     */
+
+    //TODO CSS class name for the bestMatch..
+    Y.mix(Y.DD.DDM, {
+        /**
+        * This flag turns off the use of the mouseover/mouseout shim. It should not be used unless you know what you are doing.
+        * @private
+        * @property _noShim
+        * @type {Boolean}
+        */
+        _noShim: false,
+        /**
+        * Placeholder for all active shims on the page
+        * @private
+        * @property _activeShims
+        * @type {Array}
+        */
+        _activeShims: [],
+        /**
+        * This method checks the _activeShims Object to see if there is a shim active.
+        * @private
+        * @method _hasActiveShim
+        * @return {Boolean}
+        */
+        _hasActiveShim: function() {
+            if (this._noShim) {
+                return true;
+            }
+            return this._activeShims.length;
+        },
+        /**
+        * Adds a Drop Target to the list of active shims
+        * @private
+        * @method _addActiveShim
+        * @param {Object} d The Drop instance to add to the list.
+        */
+        _addActiveShim: function(d) {
+            this._activeShims.push(d);
+        },
+        /**
+        * Removes a Drop Target to the list of active shims
+        * @private
+        * @method _removeActiveShim
+        * @param {Object} d The Drop instance to remove from the list.
+        */
+        _removeActiveShim: function(d) {
+            var s = [];
+            Y.Array.each(this._activeShims, function(v) {
+                if (v._yuid !== d._yuid) {
+                    s.push(v);
+                }
+
+            });
+            this._activeShims = s;
+        },
+        /**
+        * This method will sync the position of the shims on the Drop Targets that are currently active.
+        * @method syncActiveShims
+        * @param {Boolean} force Resize/sync all Targets.
+        */
+        syncActiveShims: function(force) {
+            Y.later(0, this, function(force) {
+                var drops = ((force) ? this.targets : this._lookup());
+                Y.Array.each(drops, function(v) {
+                    v.sizeShim.call(v);
+                }, this);
+            }, force);
+        },
+        /**
+        * The mode that the drag operations will run in 0 for Point, 1 for Intersect, 2 for Strict
+        * @private
+        * @property mode
+        * @type Number
+        */
+        mode: 0,
+        /**
+        * In point mode, a Drop is targeted by the cursor being over the Target
+        * @private
+        * @property POINT
+        * @type Number
+        */
+        POINT: 0,
+        /**
+        * In intersect mode, a Drop is targeted by "part" of the drag node being over the Target
+        * @private
+        * @property INTERSECT
+        * @type Number
+        */
+        INTERSECT: 1,
+        /**
+        * In strict mode, a Drop is targeted by the "entire" drag node being over the Target
+        * @private
+        * @property STRICT
+        * @type Number
+        */
+        STRICT: 2,
+        /**
+        * Should we only check targets that are in the viewport on drags (for performance), default: true
+        * @property useHash
+        * @type {Boolean}
+        */
+        useHash: true,
+        /**
+        * A reference to the active Drop Target
+        * @property activeDrop
+        * @type {Object}
+        */
+        activeDrop: null,
+        /**
+        * An array of the valid Drop Targets for this interaction.
+        * @property validDrops
+        * @type {Array}
+        */
+        //TODO Change array/object literals to be in sync..
+        validDrops: [],
+        /**
+        * An object literal of Other Drop Targets that we encountered during this interaction (in the case of overlapping Drop Targets)
+        * @property otherDrops
+        * @type {Object}
+        */
+        otherDrops: {},
+        /**
+        * All of the Targets
+        * @property targets
+        * @type {Array}
+        */
+        targets: [],
+        /**
+        * Add a Drop Target to the list of Valid Targets. This list get's regenerated on each new drag operation.
+        * @private
+        * @method _addValid
+        * @param {Object} drop
+        * @chainable
+        */
+        _addValid: function(drop) {
+            this.validDrops.push(drop);
+            return this;
+        },
+        /**
+        * Removes a Drop Target from the list of Valid Targets. This list get's regenerated on each new drag operation.
+        * @private
+        * @method _removeValid
+        * @param {Object} drop
+        * @chainable
+        */
+        _removeValid: function(drop) {
+            var drops = [];
+            Y.Array.each(this.validDrops, function(v) {
+                if (v !== drop) {
+                    drops.push(v);
+                }
+            });
+
+            this.validDrops = drops;
+            return this;
+        },
+        /**
+        * Check to see if the Drag element is over the target, method varies on current mode
+        * @method isOverTarget
+        * @param {Object} drop The drop to check against
+        * @return {Boolean}
+        */
+        isOverTarget: function(drop) {
+            if (this.activeDrag && drop) {
+                var xy = this.activeDrag.mouseXY, r, dMode = this.activeDrag.get('dragMode'),
+                    aRegion, node = drop.shim;
+                if (xy && this.activeDrag) {
+                    aRegion = this.activeDrag.region;
+                    if (dMode === this.STRICT) {
+                        return this.activeDrag.get('dragNode').inRegion(drop.region, true, aRegion);
+                    }
+                    if (drop && drop.shim) {
+                        if ((dMode === this.INTERSECT) && this._noShim) {
+                            r = aRegion || this.activeDrag.get('node');
+                            return drop.get('node').intersect(r, drop.region).inRegion;
+                        }
+
+                        if (this._noShim) {
+                            node = drop.get('node');
+                        }
+                        return node.intersect({
+                            top: xy[1],
+                            bottom: xy[1],
+                            left: xy[0],
+                            right: xy[0]
+                        }, drop.region).inRegion;
+                    }
+                }
+            }
+            return false;
+        },
+        /**
+        * Clears the cache data used for this interaction.
+        * @method clearCache
+        */
+        clearCache: function() {
+            this.validDrops = [];
+            this.otherDrops = {};
+            this._activeShims = [];
+        },
+        /**
+        * Clear the cache and activate the shims of all the targets
+        * @private
+        * @method _activateTargets
+        */
+        _activateTargets: function() {
+            this._noShim = true;
+            this.clearCache();
+            Y.Array.each(this.targets, function(v) {
+                v._activateShim([]);
+                if (v.get('noShim') === true) {
+                    this._noShim = false;
+                }
+            }, this);
+            this._handleTargetOver();
+
+        },
+        /**
+        * This method will gather the area for all potential targets and see which has the hightest covered area and return it.
+        * @method getBestMatch
+        * @param {Array} drops An Array of drops to scan for the best match.
+        * @param {Boolean} all If present, it returns an Array. First item is best match, second is an Array of the other items in the original Array.
+        * @return {Object or Array}
+        */
+        getBestMatch: function(drops, all) {
+            var biggest = null, area = 0, out;
+
+            Y.Object.each(drops, function(v) {
+                var inter = this.activeDrag.get('dragNode').intersect(v.get('node'));
+                v.region.area = inter.area;
+
+                if (inter.inRegion) {
+                    if (inter.area > area) {
+                        area = inter.area;
+                        biggest = v;
+                    }
+                }
+            }, this);
+            if (all) {
+                out = [];
+                //TODO Sort the others in numeric order by area covered..
+                Y.Object.each(drops, function(v) {
+                    if (v !== biggest) {
+                        out.push(v);
+                    }
+                }, this);
+                return [biggest, out];
+            }
+            return biggest;
+        },
+        /**
+        * This method fires the drop:hit, drag:drophit, drag:dropmiss methods and deactivates the shims..
+        * @private
+        * @method _deactivateTargets
+        */
+        _deactivateTargets: function() {
+            var other = [], tmp,
+                activeDrag = this.activeDrag,
+                activeDrop = this.activeDrop;
+
+            //TODO why is this check so hard??
+            if (activeDrag && activeDrop && this.otherDrops[activeDrop]) {
+                if (!activeDrag.get('dragMode')) {
+                    //TODO otherDrops -- private..
+                    other = this.otherDrops;
+                    delete other[activeDrop];
+                } else {
+                    tmp = this.getBestMatch(this.otherDrops, true);
+                    activeDrop = tmp[0];
+                    other = tmp[1];
+                }
+                activeDrag.get('node').removeClass(this.CSS_PREFIX + '-drag-over');
+                if (activeDrop) {
+                    activeDrop.fire('drop:hit', { drag: activeDrag, drop: activeDrop, others: other });
+                    activeDrag.fire('drag:drophit', { drag: activeDrag,  drop: activeDrop, others: other });
+                }
+            } else if (activeDrag && activeDrag.get('dragging')) {
+                activeDrag.get('node').removeClass(this.CSS_PREFIX + '-drag-over');
+                activeDrag.fire('drag:dropmiss', { pageX: activeDrag.lastXY[0], pageY: activeDrag.lastXY[1] });
+            }
+
+            this.activeDrop = null;
+
+            Y.Array.each(this.targets, function(v) {
+                v._deactivateShim([]);
+            }, this);
+        },
+        /**
+        * This method is called when the move method is called on the Drag Object.
+        * @private
+        * @method _dropMove
+        */
+        _dropMove: function() {
+            if (this._hasActiveShim()) {
+                this._handleTargetOver();
+            } else {
+                Y.Object.each(this.otherDrops, function(v) {
+                    v._handleOut.apply(v, []);
+                });
+            }
+        },
+        /**
+        * Filters the list of Drops down to those in the viewport.
+        * @private
+        * @method _lookup
+        * @return {Array} The valid Drop Targets that are in the viewport.
+        */
+        _lookup: function() {
+            if (!this.useHash || this._noShim) {
+                return this.validDrops;
+            }
+            var drops = [];
+            //Only scan drop shims that are in the Viewport
+            Y.Array.each(this.validDrops, function(v) {
+                if (v.shim && v.shim.inViewportRegion(false, v.region)) {
+                    drops.push(v);
+                }
+            });
+            return drops;
+
+        },
+        /**
+        * This method execs _handleTargetOver on all valid Drop Targets
+        * @private
+        * @method _handleTargetOver
+        */
+        _handleTargetOver: function() {
+            var drops = this._lookup();
+            Y.Array.each(drops, function(v) {
+                v._handleTargetOver.call(v);
+            }, this);
+        },
+        /**
+        * Add the passed in Target to the targets collection
+        * @private
+        * @method _regTarget
+        * @param {Object} t The Target to add to the targets collection
+        */
+        _regTarget: function(t) {
+            this.targets.push(t);
+        },
+        /**
+        * Remove the passed in Target from the targets collection
+        * @private
+        * @method _unregTarget
+        * @param {Object} drop The Target to remove from the targets collection
+        */
+        _unregTarget: function(drop) {
+            var targets = [], vdrops;
+            Y.Array.each(this.targets, function(v) {
+                if (v !== drop) {
+                    targets.push(v);
+                }
+            }, this);
+            this.targets = targets;
+
+            vdrops = [];
+            Y.Array.each(this.validDrops, function(v) {
+                if (v !== drop) {
+                    vdrops.push(v);
+                }
+            });
+
+            this.validDrops = vdrops;
+        },
+        /**
+        * Get a valid Drop instance back from a Node or a selector string, false otherwise
+        * @method getDrop
+        * @param {String/Object} node The Node instance or Selector string to check for a valid Drop Object
+        * @return {Object}
+        */
+        getDrop: function(node) {
+            var drop = false,
+                n = Y.one(node);
+            if (n instanceof Y.Node) {
+                Y.Array.each(this.targets, function(v) {
+                    if (n.compareTo(v.get('node'))) {
+                        drop = v;
+                    }
+                });
+            }
+            return drop;
+        }
+    }, true);
+
+
+
+
+}, '3.18.1', {"requires": ["dd-ddm"]});