diff -r 000000000000 -r 40c8f766c9b8 src/cm/media/js/lib/yui/yui_3.0.0b1/build/dd/dd-ddm-drop-debug.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cm/media/js/lib/yui/yui_3.0.0b1/build/dd/dd-ddm-drop-debug.js Mon Nov 23 15:14:29 2009 +0100 @@ -0,0 +1,404 @@ +/* +Copyright (c) 2009, Yahoo! Inc. All rights reserved. +Code licensed under the BSD License: +http://developer.yahoo.net/yui/license.txt +version: 3.0.0b1 +build: 1163 +*/ +YUI.add('dd-ddm-drop', function(Y) { + + + /** + * 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, { + /** + * @private + * @property _noShim + * @description This flag turns off the use of the mouseover/mouseout shim. It should not be used unless you know what you are doing. + * @type {Boolean} + */ + _noShim: false, + /** + * @private + * @property _activeShims + * @description Placeholder for all active shims on the page + * @type {Array} + */ + _activeShims: [], + /** + * @private + * @method _hasActiveShim + * @description This method checks the _activeShims Object to see if there is a shim active. + * @return {Boolean} + */ + _hasActiveShim: function() { + if (this._noShim) { + return true; + } + return this._activeShims.length; + }, + /** + * @private + * @method _addActiveShim + * @description Adds a Drop Target to the list of active shims + * @param {Object} d The Drop instance to add to the list. + */ + _addActiveShim: function(d) { + this._activeShims[this._activeShims.length] = d; + }, + /** + * @private + * @method _removeActiveShim + * @description Removes a Drop Target to the list of active shims + * @param {Object} d The Drop instance to remove from the list. + */ + _removeActiveShim: function(d) { + var s = []; + Y.each(this._activeShims, function(v, k) { + if (v._yuid !== d._yuid) { + s[s.length] = v; + } + + }); + this._activeShims = s; + }, + /** + * @method syncActiveShims + * @description This method will sync the position of the shims on the Drop Targets that are currently active. + * @param {Boolean} force Resize/sync all Targets. + */ + syncActiveShims: function(force) { + Y.later(0, this, function(force) { + var drops = ((force) ? this.targets : this._lookup()); + Y.each(drops, function(v, k) { + v.sizeShim.call(v); + }, this); + }, force); + }, + /** + * @private + * @property mode + * @description The mode that the drag operations will run in 0 for Point, 1 for Intersect, 2 for Strict + * @type Number + */ + mode: 0, + /** + * @private + * @property POINT + * @description In point mode, a Drop is targeted by the cursor being over the Target + * @type Number + */ + POINT: 0, + /** + * @private + * @property INTERSECT + * @description In intersect mode, a Drop is targeted by "part" of the drag node being over the Target + * @type Number + */ + INTERSECT: 1, + /** + * @private + * @property STRICT + * @description In strict mode, a Drop is targeted by the "entire" drag node being over the Target + * @type Number + */ + STRICT: 2, + /** + * @property useHash + * @description Should we only check targets that are in the viewport on drags (for performance), default: true + * @type {Boolean} + */ + useHash: true, + /** + * @property activeDrop + * @description A reference to the active Drop Target + * @type {Object} + */ + activeDrop: null, + /** + * @property validDrops + * @description An array of the valid Drop Targets for this interaction. + * @type {Array} + */ + //TODO Change array/object literals to be in sync.. + validDrops: [], + /** + * @property otherDrops + * @description An object literal of Other Drop Targets that we encountered during this interaction (in the case of overlapping Drop Targets) + * @type {Object} + */ + otherDrops: {}, + /** + * @property targets + * @description All of the Targets + * @type {Array} + */ + targets: [], + /** + * @private + * @method _addValid + * @description Add a Drop Target to the list of Valid Targets. This list get's regenerated on each new drag operation. + * @param {Object} drop + * @return {Self} + * @chainable + */ + _addValid: function(drop) { + this.validDrops[this.validDrops.length] = drop; + return this; + }, + /** + * @private + * @method _removeValid + * @description Removes a Drop Target from the list of Valid Targets. This list get's regenerated on each new drag operation. + * @param {Object} drop + * @return {Self} + * @chainable + */ + _removeValid: function(drop) { + var drops = []; + Y.each(this.validDrops, function(v, k) { + if (v !== drop) { + drops[drops.length] = v; + } + }); + + this.validDrops = drops; + return this; + }, + /** + * @method isOverTarget + * @description Check to see if the Drag element is over the target, method varies on current mode + * @param {Object} drop The drop to check against + * @return {Boolean} + */ + isOverTarget: function(drop) { + if (this.activeDrag && drop) { + var xy = this.activeDrag.mouseXY; + if (xy) { + if (this.activeDrag.get('dragMode') == this.STRICT) { + return this.activeDrag.get('dragNode').inRegion(drop.region, true, this.activeDrag.region); + } else { + if (drop && drop.shim) { + return drop.shim.intersect({ + top: xy[1], + bottom: xy[1], + left: xy[0], + right: xy[0] + }, drop.region).inRegion; + } else { + return false; + } + } + } else { + return false; + } + } else { + return false; + } + }, + /** + * @method clearCache + * @description Clears the cache data used for this interaction. + */ + clearCache: function() { + this.validDrops = []; + this.otherDrops = {}; + this._activeShims = []; + }, + /** + * @private + * @method _activateTargets + * @description Clear the cache and activate the shims of all the targets + */ + _activateTargets: function() { + this.clearCache(); + Y.each(this.targets, function(v, k) { + v._activateShim.apply(v, []); + }, this); + this._handleTargetOver(); + + }, + /** + * @method getBestMatch + * @description This method will gather the area for all potential targets and see which has the hightest covered area and return it. + * @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.each(drops, function(v, k) { + 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.each(drops, function(v, k) { + if (v !== biggest) { + out[out.length] = v; + } + }, this); + return [biggest, out]; + } else { + return biggest; + } + }, + /** + * @private + * @method _deactivateTargets + * @description This method fires the drop:hit, drag:drophit, drag:dropmiss methods and deactivates the shims.. + */ + _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('node').removeClass(this.CSS_PREFIX + '-drag-over'); + activeDrag.fire('drag:dropmiss', { pageX: activeDrag.lastXY[0], pageY: activeDrag.lastXY[1] }); + } else { + } + + this.activeDrop = null; + + Y.each(this.targets, function(v, k) { + v._deactivateShim.apply(v, []); + }, this); + }, + /** + * @private + * @method _dropMove + * @description This method is called when the move method is called on the Drag Object. + */ + _dropMove: function() { + if (this._hasActiveShim()) { + this._handleTargetOver(); + } else { + Y.each(this.otherDrops, function(v, k) { + v._handleOut.apply(v, []); + }); + } + }, + /** + * @private + * @method _lookup + * @description Filters the list of Drops down to those in the viewport. + * @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.each(this.validDrops, function(v, k) { + if (v.shim && v.shim.inViewportRegion(false, v.region)) { + drops[drops.length] = v; + } + }); + return drops; + + }, + /** + * @private + * @method _handleTargetOver + * @description This method execs _handleTargetOver on all valid Drop Targets + */ + _handleTargetOver: function() { + var drops = this._lookup(); + Y.each(drops, function(v, k) { + v._handleTargetOver.call(v); + }, this); + }, + /** + * @private + * @method _regTarget + * @description Add the passed in Target to the targets collection + * @param {Object} t The Target to add to the targets collection + */ + _regTarget: function(t) { + this.targets[this.targets.length] = t; + }, + /** + * @private + * @method _unregTarget + * @description Remove the passed in Target from the targets collection + * @param {Object} drop The Target to remove from the targets collection + */ + _unregTarget: function(drop) { + var targets = [], vdrops; + Y.each(this.targets, function(v, k) { + if (v != drop) { + targets[targets.length] = v; + } + }, this); + this.targets = targets; + + vdrops = []; + Y.each(this.validDrops, function(v, k) { + if (v !== drop) { + vdrops[vdrops.length] = v; + } + }); + + this.validDrops = vdrops; + }, + /** + * @method getDrop + * @description Get a valid Drop instance back from a Node or a selector string, false otherwise + * @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.Node.get(node); + if (n instanceof Y.Node) { + Y.each(this.targets, function(v, k) { + if (n.compareTo(v.get('node'))) { + drop = v; + } + }); + } + return drop; + } + }, true); + + + + + + + +}, '3.0.0b1' ,{requires:['dd-ddm'], skinnable:false});