diff -r 322d0feea350 -r 89ef5ed3c48b src/cm/media/js/lib/yui/yui_3.10.3/build/dd-delegate/dd-delegate-debug.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cm/media/js/lib/yui/yui_3.10.3/build/dd-delegate/dd-delegate-debug.js Tue Jul 16 14:29:46 2013 +0200 @@ -0,0 +1,345 @@ +/* +YUI 3.10.3 (build 2fb5187) +Copyright 2013 Yahoo! Inc. All rights reserved. +Licensed under the BSD License. +http://yuilibrary.com/license/ +*/ + +YUI.add('dd-delegate', function (Y, NAME) { + + + /** + * Provides the ability to drag multiple nodes under a container element using only one Y.DD.Drag instance as a delegate. + * @module dd + * @submodule dd-delegate + */ + /** + * Provides the ability to drag multiple nodes under a container element using only one Y.DD.Drag instance as a delegate. + * @class Delegate + * @extends Base + * @constructor + * @namespace DD + */ + + + var Delegate = function() { + Delegate.superclass.constructor.apply(this, arguments); + }, + CONT = 'container', + NODES = 'nodes', + _tmpNode = Y.Node.create('
Temp Node
'); + + + Y.extend(Delegate, Y.Base, { + /** + * The default bubbleTarget for this object. Default: Y.DD.DDM + * @private + * @property _bubbleTargets + */ + _bubbleTargets: Y.DD.DDM, + /** + * A reference to the temporary dd instance used under the hood. + * @property dd + */ + dd: null, + /** + * The state of the Y.DD.DDM._noShim property to it can be reset. + * @property _shimState + * @private + */ + _shimState: null, + /** + * Array of event handles to be destroyed + * @private + * @property _handles + */ + _handles: null, + /** + * Listens to the nodeChange event and sets the dragNode on the temp dd instance. + * @private + * @method _onNodeChange + * @param {Event} e The Event. + */ + _onNodeChange: function(e) { + this.set('dragNode', e.newVal); + }, + /** + * Listens for the drag:end event and updates the temp dd instance. + * @private + * @method _afterDragEnd + * @param {Event} e The Event. + */ + _afterDragEnd: function() { + Y.DD.DDM._noShim = this._shimState; + + this.set('lastNode', this.dd.get('node')); + this.get('lastNode').removeClass(Y.DD.DDM.CSS_PREFIX + '-dragging'); + this.dd._unprep(); + this.dd.set('node', _tmpNode); + }, + /** + * The callback for the Y.DD.Delegate instance used + * @private + * @method _delMouseDown + * @param {Event} e The MouseDown Event. + */ + _delMouseDown: function(e) { + var tar = e.currentTarget, + dd = this.dd, + dNode = tar, + config = this.get('dragConfig'); + + if (tar.test(this.get(NODES)) && !tar.test(this.get('invalid'))) { + this._shimState = Y.DD.DDM._noShim; + Y.DD.DDM._noShim = true; + this.set('currentNode', tar); + dd.set('node', tar); + if (config && config.dragNode) { + dNode = config.dragNode; + } else if (dd.proxy) { + dNode = Y.DD.DDM._proxy; + } + dd.set('dragNode', dNode); + dd._prep(); + + dd.fire('drag:mouseDown', { ev: e }); + } + }, + /** + * Sets the target shim state + * @private + * @method _onMouseEnter + * @param {Event} e The MouseEnter Event + */ + _onMouseEnter: function() { + this._shimState = Y.DD.DDM._noShim; + Y.DD.DDM._noShim = true; + }, + /** + * Resets the target shim state + * @private + * @method _onMouseLeave + * @param {Event} e The MouseLeave Event + */ + _onMouseLeave: function() { + Y.DD.DDM._noShim = this._shimState; + }, + initializer: function() { + this._handles = []; + //Create a tmp DD instance under the hood. + //var conf = Y.clone(this.get('dragConfig') || {}), + var conf = this.get('dragConfig') || {}, + cont = this.get(CONT); + + conf.node = _tmpNode.cloneNode(true); + conf.bubbleTargets = this; + + if (this.get('handles')) { + conf.handles = this.get('handles'); + } + + this.dd = new Y.DD.Drag(conf); + + //On end drag, detach the listeners + this.dd.after('drag:end', Y.bind(this._afterDragEnd, this)); + this.dd.on('dragNodeChange', Y.bind(this._onNodeChange, this)); + this.dd.after('drag:mouseup', function() { + this._unprep(); + }); + + //Attach the delegate to the container + this._handles.push(Y.delegate(Y.DD.Drag.START_EVENT, Y.bind(this._delMouseDown, this), cont, this.get(NODES))); + + this._handles.push(Y.on('mouseenter', Y.bind(this._onMouseEnter, this), cont)); + + this._handles.push(Y.on('mouseleave', Y.bind(this._onMouseLeave, this), cont)); + + Y.later(50, this, this.syncTargets); + Y.DD.DDM.regDelegate(this); + }, + /** + * Applies the Y.Plugin.Drop to all nodes matching the cont + nodes selector query. + * @method syncTargets + * @return {Self} + * @chainable + */ + syncTargets: function() { + if (!Y.Plugin.Drop || this.get('destroyed')) { + return; + } + var items, groups, config; + + if (this.get('target')) { + items = Y.one(this.get(CONT)).all(this.get(NODES)); + groups = this.dd.get('groups'); + config = this.get('dragConfig'); + + if (config && config.groups) { + groups = config.groups; + } + + items.each(function(i) { + this.createDrop(i, groups); + }, this); + } + return this; + }, + /** + * Apply the Drop plugin to this node + * @method createDrop + * @param {Node} node The Node to apply the plugin to + * @param {Array} groups The default groups to assign this target to. + * @return Node + */ + createDrop: function(node, groups) { + var config = { + useShim: false, + bubbleTargets: this + }; + + if (!node.drop) { + node.plug(Y.Plugin.Drop, config); + } + node.drop.set('groups', groups); + return node; + }, + destructor: function() { + if (this.dd) { + this.dd.destroy(); + } + if (Y.Plugin.Drop) { + var targets = Y.one(this.get(CONT)).all(this.get(NODES)); + targets.unplug(Y.Plugin.Drop); + } + Y.Array.each(this._handles, function(v) { + v.detach(); + }); + } + }, { + NAME: 'delegate', + ATTRS: { + /** + * A selector query to get the container to listen for mousedown events on. All "nodes" should be a child of this container. + * @attribute container + * @type String + */ + container: { + value: 'body' + }, + /** + * A selector query to get the children of the "container" to make draggable elements from. + * @attribute nodes + * @type String + */ + nodes: { + value: '.dd-draggable' + }, + /** + * A selector query to test a node to see if it's an invalid item. + * @attribute invalid + * @type String + */ + invalid: { + value: 'input, select, button, a, textarea' + }, + /** + * Y.Node instance of the last item dragged. + * @attribute lastNode + * @type Node + */ + lastNode: { + value: _tmpNode + }, + /** + * Y.Node instance of the dd node. + * @attribute currentNode + * @type Node + */ + currentNode: { + value: _tmpNode + }, + /** + * Y.Node instance of the dd dragNode. + * @attribute dragNode + * @type Node + */ + dragNode: { + value: _tmpNode + }, + /** + * Is the mouse currently over the container + * @attribute over + * @type Boolean + */ + over: { + value: false + }, + /** + * Should the items also be a drop target. + * @attribute target + * @type Boolean + */ + target: { + value: false + }, + /** + * The default config to be used when creating the DD instance. + * @attribute dragConfig + * @type Object + */ + dragConfig: { + value: null + }, + /** + * The handles config option added to the temp DD instance. + * @attribute handles + * @type Array + */ + handles: { + value: null + } + } + }); + + Y.mix(Y.DD.DDM, { + /** + * Holder for all Y.DD.Delegate instances + * @private + * @for DDM + * @property _delegates + * @type Array + */ + _delegates: [], + /** + * Register a Delegate with the DDM + * @for DDM + * @method regDelegate + */ + regDelegate: function(del) { + this._delegates.push(del); + }, + /** + * Get a delegate instance from a container node + * @for DDM + * @method getDelegate + * @return Y.DD.Delegate + */ + getDelegate: function(node) { + var del = null; + node = Y.one(node); + Y.Array.each(this._delegates, function(v) { + if (node.test(v.get(CONT))) { + del = v; + } + }, this); + return del; + } + }); + + Y.namespace('DD'); + Y.DD.Delegate = Delegate; + + + + +}, '3.10.3', {"requires": ["dd-drag", "dd-drop-plugin", "event-mouseenter"]});