@canonical/yui 3.18.2-pre

package/build/dd-drop/dd-drop.js

@@ -0,0 +1,552 @@
+YUI.add('dd-drop', function (Y, NAME) {
+
+
+    /**
+     * Provides the ability to create a Drop Target.
+     * @module dd
+     * @submodule dd-drop
+     */
+    /**
+     * Provides the ability to create a Drop Target.
+     * @class Drop
+     * @extends Base
+     * @constructor
+     * @namespace DD
+     */
+
+    var NODE = 'node',
+        DDM = Y.DD.DDM,
+        OFFSET_HEIGHT = 'offsetHeight',
+        OFFSET_WIDTH = 'offsetWidth',
+        /**
+        * Fires when a drag element is over this target.
+        * @event drop:over
+        * @param {EventFacade} event An Event Facade object with the following specific property added:
+        * <dl>
+        * <dt>drop</dt><dd>The drop object at the time of the event.</dd>
+        * <dt>drag</dt><dd>The drag object at the time of the event.</dd>
+        * </dl>
+        * @bubbles DDM
+        * @type {CustomEvent}
+        */
+        EV_DROP_OVER = 'drop:over',
+        /**
+        * Fires when a drag element enters this target.
+        * @event drop:enter
+        * @param {EventFacade} event An Event Facade object with the following specific property added:
+        * <dl>
+        * <dt>drop</dt><dd>The drop object at the time of the event.</dd>
+        * <dt>drag</dt><dd>The drag object at the time of the event.</dd>
+        * </dl>
+        * @bubbles DDM
+        * @type {CustomEvent}
+        */
+        EV_DROP_ENTER = 'drop:enter',
+        /**
+        * Fires when a drag element exits this target.
+        * @event drop:exit
+        * @param {EventFacade} event An Event Facade object
+        * @bubbles DDM
+        * @type {CustomEvent}
+        */
+        EV_DROP_EXIT = 'drop:exit',
+
+        /**
+        * Fires when a draggable node is dropped on this Drop Target. (Fired from dd-ddm-drop)
+        * @event drop:hit
+        * @param {EventFacade} event An Event Facade object with the following specific property added:
+        * <dl>
+        * <dt>drop</dt><dd>The best guess on what was dropped on.</dd>
+        * <dt>drag</dt><dd>The drag object at the time of the event.</dd>
+        * <dt>others</dt><dd>An array of all the other drop targets that was dropped on.</dd>
+        * </dl>
+        * @bubbles DDM
+        * @type {CustomEvent}
+        */
+
+
+    Drop = function() {
+        this._lazyAddAttrs = false;
+        Drop.superclass.constructor.apply(this, arguments);
+
+
+        //DD init speed up.
+        Y.on('domready', Y.bind(function() {
+            Y.later(100, this, this._createShim);
+        }, this));
+        DDM._regTarget(this);
+
+        /* TODO
+        if (Dom.getStyle(this.el, 'position') == 'fixed') {
+            Event.on(window, 'scroll', function() {
+                this.activateShim();
+            }, this, true);
+        }
+        */
+    };
+
+    Drop.NAME = 'drop';
+
+    Drop.ATTRS = {
+        /**
+        * Y.Node instance to use as the element to make a Drop Target
+        * @attribute node
+        * @type Node
+        */
+        node: {
+            setter: function(node) {
+                var n = Y.one(node);
+                if (!n) {
+                    Y.error('DD.Drop: Invalid Node Given: ' + node);
+                }
+                return n;
+            }
+        },
+        /**
+        * Array of groups to add this drop into.
+        * @attribute groups
+        * @type Array
+        */
+        groups: {
+            value: ['default'],
+            getter: function() {
+                if (!this._groups) {
+                    this._groups = {};
+                    return [];
+                }
+
+                return Y.Object.keys(this._groups);
+            },
+            setter: function(g) {
+                this._groups = Y.Array.hash(g);
+                return g;
+            }
+        },
+        /**
+        * CSS style padding to make the Drop Target bigger than the node.
+        * @attribute padding
+        * @type String
+        */
+        padding: {
+            value: '0',
+            setter: function(p) {
+                return DDM.cssSizestoObject(p);
+            }
+        },
+        /**
+        * Set to lock this drop element.
+        * @attribute lock
+        * @type Boolean
+        */
+        lock: {
+            value: false,
+            setter: function(lock) {
+                if (lock) {
+                    this.get(NODE).addClass(DDM.CSS_PREFIX + '-drop-locked');
+                } else {
+                    this.get(NODE).removeClass(DDM.CSS_PREFIX + '-drop-locked');
+                }
+                return lock;
+            }
+        },
+        /**
+        * Controls the default bubble parent for this Drop instance. Default: Y.DD.DDM. Set to false to disable bubbling.
+        * Use bubbleTargets in config.
+        * @deprecated
+        * @attribute bubbles
+        * @type Object
+        */
+        bubbles: {
+            setter: function(t) {
+                this.addTarget(t);
+                return t;
+            }
+        },
+        /**
+        * Use the Drop shim. Default: true
+        * @deprecated
+        * @attribute useShim
+        * @type Boolean
+        */
+        useShim: {
+            value: true,
+            setter: function(v) {
+                Y.DD.DDM._noShim = !v;
+                return v;
+            }
+        }
+    };
+
+    Y.extend(Drop, Y.Base, {
+        /**
+        * The default bubbleTarget for this object. Default: Y.DD.DDM
+        * @private
+        * @property _bubbleTargets
+        */
+        _bubbleTargets: Y.DD.DDM,
+        /**
+        * Add this Drop instance to a group, this should be used for on-the-fly group additions.
+        * @method addToGroup
+        * @param {String} g The group to add this Drop Instance to.
+        * @chainable
+        */
+        addToGroup: function(g) {
+            this._groups[g] = true;
+            return this;
+        },
+        /**
+        * Remove this Drop instance from a group, this should be used for on-the-fly group removals.
+        * @method removeFromGroup
+        * @param {String} g The group to remove this Drop Instance from.
+        * @chainable
+        */
+        removeFromGroup: function(g) {
+            delete this._groups[g];
+            return this;
+        },
+        /**
+        * This method creates all the events for this Event Target and publishes them so we get Event Bubbling.
+        * @private
+        * @method _createEvents
+        */
+        _createEvents: function() {
+
+            var ev = [
+                EV_DROP_OVER,
+                EV_DROP_ENTER,
+                EV_DROP_EXIT,
+                'drop:hit'
+            ];
+
+            Y.Array.each(ev, function(v) {
+                this.publish(v, {
+                    type: v,
+                    emitFacade: true,
+                    preventable: false,
+                    bubbles: true,
+                    queuable: false,
+                    prefix: 'drop'
+                });
+            }, this);
+        },
+        /**
+        * Flag for determining if the target is valid in this operation.
+        * @private
+        * @property _valid
+        * @type Boolean
+        */
+        _valid: null,
+        /**
+        * The groups this target belongs to.
+        * @private
+        * @property _groups
+        * @type Array
+        */
+        _groups: null,
+        /**
+        * Node reference to the targets shim
+        * @property shim
+        * @type {Object}
+        */
+        shim: null,
+        /**
+        * A region object associated with this target, used for checking regions while dragging.
+        * @property region
+        * @type Object
+        */
+        region: null,
+        /**
+        * This flag is tripped when a drag element is over this target.
+        * @property overTarget
+        * @type Boolean
+        */
+        overTarget: null,
+        /**
+        * Check if this target is in one of the supplied groups.
+        * @method inGroup
+        * @param {Array} groups The groups to check against
+        * @return Boolean
+        */
+        inGroup: function(groups) {
+            this._valid = false;
+            var ret = false;
+            Y.Array.each(groups, function(v) {
+                if (this._groups[v]) {
+                    ret = true;
+                    this._valid = true;
+                }
+            }, this);
+            return ret;
+        },
+        /**
+        * Private lifecycle method
+        * @private
+        * @method initializer
+        */
+        initializer: function() {
+            Y.later(100, this, this._createEvents);
+
+            var node = this.get(NODE), id;
+            if (!node.get('id')) {
+                id = Y.stamp(node);
+                node.set('id', id);
+            }
+            node.addClass(DDM.CSS_PREFIX + '-drop');
+            //Shouldn't have to do this..
+            this.set('groups', this.get('groups'));
+        },
+        /**
+        * Lifecycle destructor, unreg the drag from the DDM and remove listeners
+        * @private
+        * @method destructor
+        */
+        destructor: function() {
+            DDM._unregTarget(this);
+            if (this.shim && (this.shim !== this.get(NODE))) {
+                this.shim.detachAll();
+                this.shim.remove();
+                this.shim = null;
+            }
+            this.get(NODE).removeClass(DDM.CSS_PREFIX + '-drop');
+            this.detachAll();
+        },
+        /**
+        * Removes classes from the target, resets some flags and sets the shims deactive position [-999, -999]
+        * @private
+        * @method _deactivateShim
+        */
+        _deactivateShim: function() {
+            if (!this.shim) {
+                return false;
+            }
+            this.get(NODE).removeClass(DDM.CSS_PREFIX + '-drop-active-valid');
+            this.get(NODE).removeClass(DDM.CSS_PREFIX + '-drop-active-invalid');
+            this.get(NODE).removeClass(DDM.CSS_PREFIX + '-drop-over');
+
+            if (this.get('useShim')) {
+                this.shim.setStyles({
+                    top: '-999px',
+                    left: '-999px',
+                    zIndex: '1'
+                });
+            }
+            this.overTarget = false;
+        },
+        /**
+        * Activates the shim and adds some interaction CSS classes
+        * @private
+        * @method _activateShim
+        */
+        _activateShim: function() {
+            if (!DDM.activeDrag) {
+                return false; //Nothing is dragging, no reason to activate.
+            }
+            if (this.get(NODE) === DDM.activeDrag.get(NODE)) {
+                return false;
+            }
+            if (this.get('lock')) {
+                return false;
+            }
+            var node = this.get(NODE);
+            //TODO Visibility Check..
+            //if (this.inGroup(DDM.activeDrag.get('groups')) && this.get(NODE).isVisible()) {
+            if (this.inGroup(DDM.activeDrag.get('groups'))) {
+                node.removeClass(DDM.CSS_PREFIX + '-drop-active-invalid');
+                node.addClass(DDM.CSS_PREFIX + '-drop-active-valid');
+                DDM._addValid(this);
+                this.overTarget = false;
+                if (!this.get('useShim')) {
+                    this.shim = this.get(NODE);
+                }
+                this.sizeShim();
+            } else {
+                DDM._removeValid(this);
+                node.removeClass(DDM.CSS_PREFIX + '-drop-active-valid');
+                node.addClass(DDM.CSS_PREFIX + '-drop-active-invalid');
+            }
+        },
+        /**
+        * Positions and sizes the shim with the raw data from the node,
+        * this can be used to programatically adjust the Targets shim for Animation..
+        * @method sizeShim
+        */
+        sizeShim: function() {
+            if (!DDM.activeDrag) {
+                return false; //Nothing is dragging, no reason to activate.
+            }
+            if (this.get(NODE) === DDM.activeDrag.get(NODE)) {
+                return false;
+            }
+            //if (this.get('lock') || !this.get('useShim')) {
+            if (this.get('lock')) {
+                return false;
+            }
+            if (!this.shim) {
+                Y.later(100, this, this.sizeShim);
+                return false;
+            }
+            var node = this.get(NODE),
+                nh = node.get(OFFSET_HEIGHT),
+                nw = node.get(OFFSET_WIDTH),
+                xy = node.getXY(),
+                p = this.get('padding'),
+                dd, dH, dW;
+
+
+            //Apply padding
+            nw = nw + p.left + p.right;
+            nh = nh + p.top + p.bottom;
+            xy[0] = xy[0] - p.left;
+            xy[1] = xy[1] - p.top;
+
+
+            if (DDM.activeDrag.get('dragMode') === DDM.INTERSECT) {
+                //Intersect Mode, make the shim bigger
+                dd = DDM.activeDrag;
+                dH = dd.get(NODE).get(OFFSET_HEIGHT);
+                dW = dd.get(NODE).get(OFFSET_WIDTH);
+
+                nh = (nh + dH);
+                nw = (nw + dW);
+                xy[0] = xy[0] - (dW - dd.deltaXY[0]);
+                xy[1] = xy[1] - (dH - dd.deltaXY[1]);
+
+            }
+
+            if (this.get('useShim')) {
+                //Set the style on the shim
+                this.shim.setStyles({
+                    height: nh + 'px',
+                    width: nw + 'px',
+                    top: xy[1] + 'px',
+                    left: xy[0] + 'px'
+                });
+            }
+
+            //Create the region to be used by intersect when a drag node is over us.
+            this.region = {
+                '0': xy[0],
+                '1': xy[1],
+                area: 0,
+                top: xy[1],
+                right: xy[0] + nw,
+                bottom: xy[1] + nh,
+                left: xy[0]
+            };
+        },
+        /**
+        * Creates the Target shim and adds it to the DDM's playground..
+        * @private
+        * @method _createShim
+        */
+        _createShim: function() {
+            //No playground, defer
+            if (!DDM._pg) {
+                Y.later(10, this, this._createShim);
+                return;
+            }
+            //Shim already here, cancel
+            if (this.shim) {
+                return;
+            }
+            var s = this.get('node');
+
+            if (this.get('useShim')) {
+                s = Y.Node.create('<div id="' + this.get(NODE).get('id') + '_shim"></div>');
+                s.setStyles({
+                    height: this.get(NODE).get(OFFSET_HEIGHT) + 'px',
+                    width: this.get(NODE).get(OFFSET_WIDTH) + 'px',
+                    backgroundColor: 'yellow',
+                    opacity: '.5',
+                    zIndex: '1',
+                    overflow: 'hidden',
+                    top: '-900px',
+                    left: '-900px',
+                    position:  'absolute'
+                });
+
+                DDM._pg.appendChild(s);
+
+                s.on('mouseover', Y.bind(this._handleOverEvent, this));
+                s.on('mouseout', Y.bind(this._handleOutEvent, this));
+            }
+
+
+            this.shim = s;
+        },
+        /**
+        * This handles the over target call made from this object or from the DDM
+        * @private
+        * @method _handleOverTarget
+        */
+        _handleTargetOver: function() {
+            if (DDM.isOverTarget(this)) {
+                this.get(NODE).addClass(DDM.CSS_PREFIX + '-drop-over');
+                DDM.activeDrop = this;
+                DDM.otherDrops[this] = this;
+                if (this.overTarget) {
+                    DDM.activeDrag.fire('drag:over', { drop: this, drag: DDM.activeDrag });
+                    this.fire(EV_DROP_OVER, { drop: this, drag: DDM.activeDrag });
+                } else {
+                    //Prevent an enter before a start..
+                    if (DDM.activeDrag.get('dragging')) {
+                        this.overTarget = true;
+                        this.fire(EV_DROP_ENTER, { drop: this, drag: DDM.activeDrag });
+                        DDM.activeDrag.fire('drag:enter', { drop: this, drag: DDM.activeDrag });
+                        DDM.activeDrag.get(NODE).addClass(DDM.CSS_PREFIX + '-drag-over');
+                        //TODO - Is this needed??
+                        //DDM._handleTargetOver();
+                    }
+                }
+            } else {
+                this._handleOut();
+            }
+        },
+        /**
+        * Handles the mouseover DOM event on the Target Shim
+        * @private
+        * @method _handleOverEvent
+        */
+        _handleOverEvent: function() {
+            this.shim.setStyle('zIndex', '999');
+            DDM._addActiveShim(this);
+        },
+        /**
+        * Handles the mouseout DOM event on the Target Shim
+        * @private
+        * @method _handleOutEvent
+        */
+        _handleOutEvent: function() {
+            this.shim.setStyle('zIndex', '1');
+            DDM._removeActiveShim(this);
+        },
+        /**
+        * Handles out of target calls/checks
+        * @private
+        * @method _handleOut
+        */
+        _handleOut: function(force) {
+            if (!DDM.isOverTarget(this) || force) {
+                if (this.overTarget) {
+                    this.overTarget = false;
+                    if (!force) {
+                        DDM._removeActiveShim(this);
+                    }
+                    if (DDM.activeDrag) {
+                        this.get(NODE).removeClass(DDM.CSS_PREFIX + '-drop-over');
+                        DDM.activeDrag.get(NODE).removeClass(DDM.CSS_PREFIX + '-drag-over');
+                        this.fire(EV_DROP_EXIT, { drop: this, drag: DDM.activeDrag });
+                        DDM.activeDrag.fire('drag:exit', { drop: this, drag: DDM.activeDrag });
+                        delete DDM.otherDrops[this];
+                    }
+                }
+            }
+        }
+    });
+
+    Y.DD.Drop = Drop;
+
+
+
+
+}, '@VERSION@', {"requires": ["dd-drag", "dd-ddm-drop"]});

package/build/dd-drop-plugin/dd-drop-plugin-debug.js

@@ -0,0 +1,44 @@
+YUI.add('dd-drop-plugin', function (Y, NAME) {
+
+
+       /**
+        * Simple Drop plugin that can be attached to a Node via the plug method.
+        * @module dd
+        * @submodule dd-drop-plugin
+        */
+       /**
+        * Simple Drop plugin that can be attached to a Node via the plug method.
+        * @class Drop
+        * @extends DD.Drop
+        * @constructor
+        * @namespace Plugin
+        */
+
+
+        var Drop = function(config) {
+            config.node = config.host;
+            Drop.superclass.constructor.apply(this, arguments);
+        };
+
+        /**
+        * dd-drop-plugin
+        * @property NAME
+        * @type {String}
+        */
+        Drop.NAME = "dd-drop-plugin";
+        /**
+        * The Drop instance will be placed on the Node instance under the drop namespace. It can be accessed via Node.drop;
+        * @property NS
+        * @type {String}
+        */
+        Drop.NS = "drop";
+
+
+        Y.extend(Drop, Y.DD.Drop);
+        Y.namespace('Plugin');
+        Y.Plugin.Drop = Drop;
+
+
+
+
+}, '@VERSION@', {"requires": ["dd-drop"]});

package/build/dd-drop-plugin/dd-drop-plugin-min.js

@@ -0,0 +1 @@
+YUI.add("dd-drop-plugin",function(e,t){var n=function(e){e.node=e.host,n.superclass.constructor.apply(this,arguments)};n.NAME="dd-drop-plugin",n.NS="drop",e.extend(n,e.DD.Drop),e.namespace("Plugin"),e.Plugin.Drop=n},"@VERSION@",{requires:["dd-drop"]});

package/build/dd-drop-plugin/dd-drop-plugin.js

@@ -0,0 +1,44 @@
+YUI.add('dd-drop-plugin', function (Y, NAME) {
+
+
+       /**
+        * Simple Drop plugin that can be attached to a Node via the plug method.
+        * @module dd
+        * @submodule dd-drop-plugin
+        */
+       /**
+        * Simple Drop plugin that can be attached to a Node via the plug method.
+        * @class Drop
+        * @extends DD.Drop
+        * @constructor
+        * @namespace Plugin
+        */
+
+
+        var Drop = function(config) {
+            config.node = config.host;
+            Drop.superclass.constructor.apply(this, arguments);
+        };
+
+        /**
+        * dd-drop-plugin
+        * @property NAME
+        * @type {String}
+        */
+        Drop.NAME = "dd-drop-plugin";
+        /**
+        * The Drop instance will be placed on the Node instance under the drop namespace. It can be accessed via Node.drop;
+        * @property NS
+        * @type {String}
+        */
+        Drop.NS = "drop";
+
+
+        Y.extend(Drop, Y.DD.Drop);
+        Y.namespace('Plugin');
+        Y.Plugin.Drop = Drop;
+
+
+
+
+}, '@VERSION@', {"requires": ["dd-drop"]});

package/build/dd-gestures/dd-gestures-debug.js

@@ -0,0 +1,56 @@
+YUI.add('dd-gestures', function (Y, NAME) {
+
+
+    /**
+    * This module is the conditional loaded `dd` module to support gesture events
+    * in the event that `dd` is loaded onto a device that support touch based events.
+    *
+    * This module is loaded and over rides 2 key methods on `DD.Drag` and `DD.DDM` to
+    * attach the gesture events. Overrides `DD.Drag._prep` and `DD.DDM._setupListeners`
+    * methods as well as set's the property `DD.Drag.START_EVENT` to `gesturemovestart`
+    * to enable gesture movement instead of mouse based movement.
+    * @module dd
+    * @submodule dd-gestures
+    */
+    Y.log('Drag gesture support loaded', 'info', 'drag-gestures');
+
+    Y.DD.Drag.START_EVENT = 'gesturemovestart';
+
+    Y.DD.Drag.prototype._prep = function() {
+        Y.log('Using DD override prep to attach gesture events', 'info', 'drag-gestures');
+        this._dragThreshMet = false;
+        var node = this.get('node'), DDM = Y.DD.DDM;
+
+        node.addClass(DDM.CSS_PREFIX + '-draggable');
+
+        node.on(Y.DD.Drag.START_EVENT, Y.bind(this._handleMouseDownEvent, this), {
+            minDistance: this.get('clickPixelThresh'),
+            minTime: this.get('clickTimeThresh')
+        });
+
+        node.on('gesturemoveend', Y.bind(this._handleMouseUp, this), { standAlone: true });
+        node.on('dragstart', Y.bind(this._fixDragStart, this));
+
+    };
+
+    var _unprep = Y.DD.Drag.prototype._unprep;
+
+    Y.DD.Drag.prototype._unprep = function() {
+        var node = this.get('node');
+        _unprep.call(this);
+        node.detachAll('gesturemoveend');
+    };
+
+    Y.DD.DDM._setupListeners = function() {
+        var DDM = Y.DD.DDM;
+
+        this._createPG();
+        this._active = true;
+        Y.one(Y.config.doc).on('gesturemove', Y.throttle(Y.bind(DDM._move, DDM), DDM.get('throttleTime')), {
+            standAlone: true
+        });
+    };
+
+
+
+}, '@VERSION@', {"requires": ["dd-drag", "event-synthetic", "event-gestures"]});

package/build/dd-gestures/dd-gestures-min.js

@@ -0,0 +1 @@
+YUI.add("dd-gestures",function(e,t){e.DD.Drag.START_EVENT="gesturemovestart",e.DD.Drag.prototype._prep=function(){this._dragThreshMet=!1;var t=this.get("node"),n=e.DD.DDM;t.addClass(n.CSS_PREFIX+"-draggable"),t.on(e.DD.Drag.START_EVENT,e.bind(this._handleMouseDownEvent,this),{minDistance:this.get("clickPixelThresh"),minTime:this.get("clickTimeThresh")}),t.on("gesturemoveend",e.bind(this._handleMouseUp,this),{standAlone:!0}),t.on("dragstart",e.bind(this._fixDragStart,this))};var n=e.DD.Drag.prototype._unprep;e.DD.Drag.prototype._unprep=function(){var e=this.get("node");n.call(this),e.detachAll("gesturemoveend")},e.DD.DDM._setupListeners=function(){var t=e.DD.DDM;this._createPG(),this._active=!0,e.one(e.config.doc).on("gesturemove",e.throttle(e.bind(t._move,t),t.get("throttleTime")),{standAlone:!0})}},"@VERSION@",{requires:["dd-drag","event-synthetic","event-gestures"]});