--- /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.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('<div>Temp Node</div>');
+
+
+ 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"]});