Show:

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