comt: comparison src/cm/media/js/lib/yui/yui_3.0.0b1/build/dd/dd-ddm-drop-debug.js

Mercurial Mercurial > comt / comparison

summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help

src/cm/media/js/lib/yui/yui_3.0.0b1/build/dd/dd-ddm-drop-debug.js

changeset 0

40c8f766c9b8

equal deleted inserted replaced

--1:000000000000
+:40c8f766c9b8
+/*
+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});

comt