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