Show:

                                /**
                                 * Provides the base Drag Drop Manager required for making a Node draggable.
                                 * @module dd
                                 * @submodule dd-ddm-base
                                 */
                                 /**
                                 * Provides the base Drag Drop Manager required for making a Node draggable.
                                 * @class DDM
                                 * @extends Base
                                 * @constructor
                                 * @namespace DD
                                 */

                                var DDMBase = function() {
                                    DDMBase.superclass.constructor.apply(this, arguments);
                                };

                                DDMBase.NAME = 'ddm';

                                DDMBase.ATTRS = {
                                    /**
                                    * The cursor to apply when dragging, if shimmed the shim will get the cursor.
                                    * @attribute dragCursor
                                    * @type String
                                    */
                                    dragCursor: {
                                        value: 'move'
                                    },
                                    /**
                                    * The number of pixels to move to start a drag operation, default is 3.
                                    * @attribute clickPixelThresh
                                    * @type Number
                                    */
                                    clickPixelThresh: {
                                        value: 3
                                    },
                                    /**
                                    * The number of milliseconds a mousedown has to pass to start a drag operation, default is 1000.
                                    * @attribute clickTimeThresh
                                    * @type Number
                                    */
                                    clickTimeThresh: {
                                        value: 1000
                                    },
                                    /**
                                    * The number of milliseconds to throttle the mousemove event. Default: 150
                                    * @attribute throttleTime
                                    * @type Number
                                    */
                                    throttleTime: {
                                        //value: 150
                                        value: -1
                                    },
                                    /**
                                    * This attribute only works if the dd-drop module is active. It will set the dragMode (point, intersect, strict) of all future Drag instances.
                                    * @attribute dragMode
                                    * @type String
                                    */
                                    dragMode: {
                                        value: 'point',
                                        setter: function(mode) {
                                            this._setDragMode(mode);
                                            return mode;
                                        }
                                    }

                                };

                                Y.extend(DDMBase, Y.Base, {
                                    _createPG: function() {},
                                    /**
                                    * flag set when we activate our first drag, so DDM can start listening for events.
                                    * @property _active
                                    * @type {Boolean}
                                    */
                                    _active: null,
                                    /**
                                    * Handler for dragMode attribute setter.
                                    * @private
                                    * @method _setDragMode
                                    * @param {String|Number} mode The Number value or the String for the DragMode to default all future drag instances to.
                                    * @return Number The Mode to be set
                                    */
                                    _setDragMode: function(mode) {
                                        if (mode === null) {
                                            mode = Y.DD.DDM.get('dragMode');
                                        }
                                        switch (mode) {
                                            case 1:
                                            case 'intersect':
                                                return 1;
                                            case 2:
                                            case 'strict':
                                                return 2;
                                            case 0:
                                            case 'point':
                                                return 0;
                                        }
                                        return 0;
                                    },
                                    /**
                                    * The PREFIX to attach to all DD CSS class names
                                    * @property CSS_PREFIX
                                    * @type {String}
                                    */
                                    CSS_PREFIX: Y.ClassNameManager.getClassName('dd'),
                                    _activateTargets: function() {},
                                    /**
                                    * Holder for all registered drag elements.
                                    * @private
                                    * @property _drags
                                    * @type {Array}
                                    */
                                    _drags: [],
                                    /**
                                    * A reference to the currently active draggable object.
                                    * @property activeDrag
                                    * @type {Drag}
                                    */
                                    activeDrag: false,
                                    /**
                                    * Adds a reference to the drag object to the DDM._drags array, called in the constructor of Drag.
                                    * @private
                                    * @method _regDrag
                                    * @param {Drag} d The Drag object
                                    */
                                    _regDrag: function(d) {
                                        if (this.getDrag(d.get('node'))) {
                                            return false;
                                        }

                                        if (!this._active) {
                                            this._setupListeners();
                                        }
                                        this._drags.push(d);
                                        return true;
                                    },
                                    /**
                                    * Remove this drag object from the DDM._drags array.
                                    * @private
                                    * @method _unregDrag
                                    * @param {Drag} d The drag object.
                                    */
                                    _unregDrag: function(d) {
                                        var tmp = [];
                                        Y.Array.each(this._drags, function(n) {
                                            if (n !== d) {
                                                tmp[tmp.length] = n;
                                            }
                                        });
                                        this._drags = tmp;
                                    },
                                    /**
                                    * Add the document listeners.
                                    * @private
                                    * @method _setupListeners
                                    */
                                    _setupListeners: function() {
                                        this._createPG();
                                        this._active = true;

                                        var doc = Y.one(Y.config.doc);
                                        doc.on('mousemove', Y.throttle(Y.bind(this._docMove, this), this.get('throttleTime')));
                                        doc.on('mouseup', Y.bind(this._end, this));
                                    },
                                    /**
                                    * Internal method used by Drag to signal the start of a drag operation
                                    * @private
                                    * @method _start
                                    */
                                    _start: function() {
                                        this.fire('ddm:start');
                                        this._startDrag();
                                    },
                                    /**
                                    * Factory method to be overwritten by other DDM's
                                    * @private
                                    * @method _startDrag
                                    * @param {Number} x The x position of the drag element
                                    * @param {Number} y The y position of the drag element
                                    * @param {Number} w The width of the drag element
                                    * @param {Number} h The height of the drag element
                                    */
                                    _startDrag: function() {},
                                    /**
                                    * Factory method to be overwritten by other DDM's
                                    * @private
                                    * @method _endDrag
                                    */
                                    _endDrag: function() {},
                                    _dropMove: function() {},
                                    /**
                                    * Internal method used by Drag to signal the end of a drag operation
                                    * @private
                                    * @method _end
                                    */
                                    _end: function() {
                                        if (this.activeDrag) {
                                            this._shimming = false;
                                            this._endDrag();
                                            this.fire('ddm:end');
                                            this.activeDrag.end.call(this.activeDrag);
                                            this.activeDrag = null;
                                        }
                                    },
                                    /**
                                    * Method will forcefully stop a drag operation. For example calling this from inside an ESC keypress handler will stop this drag.
                                    * @method stopDrag
                                    * @chainable
                                    */
                                    stopDrag: function() {
                                        if (this.activeDrag) {
                                            this._end();
                                        }
                                        return this;
                                    },
                                    /**
                                    * Set to true when drag starts and useShim is true. Used in pairing with _docMove
                                    * @private
                                    * @property _shimming
                                    * @see _docMove
                                    * @type {Boolean}
                                    */
                                    _shimming: false,
                                    /**
                                    * Internal listener for the mousemove on Document. Checks if the shim is in place to only call _move once per mouse move
                                    * @private
                                    * @method _docMove
                                    * @param {EventFacade} ev The Dom mousemove Event
                                    */
                                    _docMove: function(ev) {
                                        if (!this._shimming) {
                                            this._move(ev);
                                        }
                                    },
                                    /**
                                    * Internal listener for the mousemove DOM event to pass to the Drag's move method.
                                    * @private
                                    * @method _move
                                    * @param {EventFacade} ev The Dom mousemove Event
                                    */
                                    _move: function(ev) {
                                        if (this.activeDrag) {
                                            this.activeDrag._move.call(this.activeDrag, ev);
                                            this._dropMove();
                                        }
                                    },
                                    /**
                                    * //TODO Private, rename??...
                                    * Helper method to use to set the gutter from the attribute setter.
                                    * CSS style string for gutter: '5 0' (sets top and bottom to 5px, left and right to 0px), '1 2 3 4' (top 1px, right 2px, bottom 3px, left 4px)
                                    * @private
                                    * @method cssSizestoObject
                                    * @param {String} gutter CSS style string for gutter
                                    * @return {Object} The gutter Object Literal.
                                    */
                                    cssSizestoObject: function(gutter) {
                                        var x = gutter.split(' ');

                                        switch (x.length) {
                                            case 1: x[1] = x[2] = x[3] = x[0]; break;
                                            case 2: x[2] = x[0]; x[3] = x[1]; break;
                                            case 3: x[3] = x[1]; break;
                                        }

                                        return {
                                            top   : parseInt(x[0],10),
                                            right : parseInt(x[1],10),
                                            bottom: parseInt(x[2],10),
                                            left  : parseInt(x[3],10)
                                        };
                                    },
                                    /**
                                    * Get a valid Drag instance back from a Node or a selector string, false otherwise
                                    * @method getDrag
                                    * @param {String/Object} node The Node instance or Selector string to check for a valid Drag Object
                                    * @return {Object}
                                    */
                                    getDrag: function(node) {
                                        var drag = false,
                                            n = Y.one(node);
                                        if (n instanceof Y.Node) {
                                            Y.Array.each(this._drags, function(v) {
                                                if (n.compareTo(v.get('node'))) {
                                                    drag = v;
                                                }
                                            });
                                        }
                                        return drag;
                                    },
                                    /**
                                    * Swap the position of 2 nodes based on their CSS positioning.
                                    * @method swapPosition
                                    * @param {Node} n1 The first node to swap
                                    * @param {Node} n2 The first node to swap
                                    * @return {Node}
                                    */
                                    swapPosition: function(n1, n2) {
                                        n1 = Y.DD.DDM.getNode(n1);
                                        n2 = Y.DD.DDM.getNode(n2);
                                        var xy1 = n1.getXY(),
                                            xy2 = n2.getXY();

                                        n1.setXY(xy2);
                                        n2.setXY(xy1);
                                        return n1;
                                    },
                                    /**
                                    * Return a node instance from the given node, selector string or Y.Base extended object.
                                    * @method getNode
                                    * @param {Node/Object/String} n The node to resolve.
                                    * @return {Node}
                                    */
                                    getNode: function(n) {
                                        if (n instanceof Y.Node) {
                                            return n;
                                        }
                                        if (n && n.get) {
                                            if (Y.Widget && (n instanceof Y.Widget)) {
                                                n = n.get('boundingBox');
                                            } else {
                                                n = n.get('node');
                                            }
                                        } else {
                                            n = Y.one(n);
                                        }
                                        return n;
                                    },
                                    /**
                                    * Swap the position of 2 nodes based on their DOM location.
                                    * @method swapNode
                                    * @param {Node} n1 The first node to swap
                                    * @param {Node} n2 The first node to swap
                                    * @return {Node}
                                    */
                                    swapNode: function(n1, n2) {
                                        n1 = Y.DD.DDM.getNode(n1);
                                        n2 = Y.DD.DDM.getNode(n2);
                                        var p = n2.get('parentNode'),
                                            s = n2.get('nextSibling');

                                        if (s === n1) {
                                            p.insertBefore(n1, n2);
                                        } else if (n2 === n1.get('nextSibling')) {
                                            p.insertBefore(n2, n1);
                                        } else {
                                            n1.get('parentNode').replaceChild(n2, n1);
                                            p.insertBefore(n1, s);
                                        }
                                        return n1;
                                    }
                                });

                                Y.namespace('DD');
                                Y.DD.DDM = new DDMBase();

                                /**
                                * Fires from the DDM before all drag events fire.
                                * @event ddm:start
                                * @type {CustomEvent}
                                */
                                /**
                                * Fires from the DDM after the DDM finishes, before the drag end events.
                                * @event ddm:end
                                * @type {CustomEvent}
                                */