roller-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From gma...@apache.org
Subject svn commit: r1609737 [9/18] - in /roller/trunk/app/src/main/webapp: WEB-INF/jsps/editor/ WEB-INF/jsps/tiles/ roller-ui/yui3/arraylist/ roller-ui/yui3/assets/ roller-ui/yui3/assets/skins/ roller-ui/yui3/assets/skins/sam/ roller-ui/yui3/async-queue/ roll...
Date Fri, 11 Jul 2014 16:23:29 GMT
Added: roller/trunk/app/src/main/webapp/roller-ui/yui3/event-simulate/event-simulate.js
URL: http://svn.apache.org/viewvc/roller/trunk/app/src/main/webapp/roller-ui/yui3/event-simulate/event-simulate.js?rev=1609737&view=auto
==============================================================================
--- roller/trunk/app/src/main/webapp/roller-ui/yui3/event-simulate/event-simulate.js (added)
+++ roller/trunk/app/src/main/webapp/roller-ui/yui3/event-simulate/event-simulate.js Fri Jul 11 16:23:25 2014
@@ -0,0 +1,964 @@
+/*
+YUI 3.17.2 (build 9c3c78e)
+Copyright 2014 Yahoo! Inc. All rights reserved.
+Licensed under the BSD License.
+http://yuilibrary.com/license/
+*/
+
+YUI.add('event-simulate', function (Y, NAME) {
+
+(function() {
+/**
+ * Simulate user interaction by generating native DOM events.
+ *
+ * @module event-simulate
+ * @requires event
+ */
+
+//shortcuts
+var L   = Y.Lang,
+    win = Y.config.win,
+    isFunction  = L.isFunction,
+    isString    = L.isString,
+    isBoolean   = L.isBoolean,
+    isObject    = L.isObject,
+    isNumber    = L.isNumber,
+
+    //mouse events supported
+    mouseEvents = {
+        click:      1,
+        dblclick:   1,
+        mouseover:  1,
+        mouseout:   1,
+        mousedown:  1,
+        mouseup:    1,
+        mousemove:  1,
+        contextmenu:1
+    },
+
+    pointerEvents = (win && win.PointerEvent) ? {
+        pointerover:  1,
+        pointerout:   1,
+        pointerdown:  1,
+        pointerup:    1,
+        pointermove:  1
+    } : {
+        MSPointerOver:  1,
+        MSPointerOut:   1,
+        MSPointerDown:  1,
+        MSPointerUp:    1,
+        MSPointerMove:  1
+    },
+
+    //key events supported
+    keyEvents   = {
+        keydown:    1,
+        keyup:      1,
+        keypress:   1
+    },
+
+    //HTML events supported
+    uiEvents  = {
+        submit:     1,
+        blur:       1,
+        change:     1,
+        focus:      1,
+        resize:     1,
+        scroll:     1,
+        select:     1
+    },
+
+    //events that bubble by default
+    bubbleEvents = {
+        scroll:     1,
+        resize:     1,
+        reset:      1,
+        submit:     1,
+        change:     1,
+        select:     1,
+        error:      1,
+        abort:      1
+    },
+
+    //touch events supported
+    touchEvents = {
+        touchstart: 1,
+        touchmove: 1,
+        touchend: 1,
+        touchcancel: 1
+    },
+
+    gestureEvents = {
+        gesturestart: 1,
+        gesturechange: 1,
+        gestureend: 1
+    };
+
+//all key, mouse and touch events bubble
+Y.mix(bubbleEvents, mouseEvents);
+Y.mix(bubbleEvents, keyEvents);
+Y.mix(bubbleEvents, touchEvents);
+
+/*
+ * Note: Intentionally not for YUIDoc generation.
+ * Simulates a key event using the given event information to populate
+ * the generated event object. This method does browser-equalizing
+ * calculations to account for differences in the DOM and IE event models
+ * as well as different browser quirks. Note: keydown causes Safari 2.x to
+ * crash.
+ * @method simulateKeyEvent
+ * @private
+ * @static
+ * @param {HTMLElement} target The target of the given event.
+ * @param {String} type The type of event to fire. This can be any one of
+ *      the following: keyup, keydown, and keypress.
+ * @param {Boolean} [bubbles=true] Indicates if the event can be
+ *      bubbled up. DOM Level 3 specifies that all key events bubble by
+ *      default.
+ * @param {Boolean} [cancelable=true] Indicates if the event can be
+ *      canceled using preventDefault(). DOM Level 3 specifies that all
+ *      key events can be cancelled.
+ * @param {Window} [view=window] The view containing the target. This is
+ *      typically the window object.
+ * @param {Boolean} [ctrlKey=false] Indicates if one of the CTRL keys
+ *      is pressed while the event is firing.
+ * @param {Boolean} [altKey=false] Indicates if one of the ALT keys
+ *      is pressed while the event is firing.
+ * @param {Boolean} [shiftKey=false] Indicates if one of the SHIFT keys
+ *      is pressed while the event is firing.
+ * @param {Boolean} [metaKey=false] Indicates if one of the META keys
+ *      is pressed while the event is firing.
+ * @param {Number} [keyCode=0] The code for the key that is in use.
+ * @param {Number} [charCode=0] The Unicode code for the character
+ *      associated with the key being used.
+ */
+function simulateKeyEvent(target /*:HTMLElement*/, type /*:String*/,
+                             bubbles /*:Boolean*/,  cancelable /*:Boolean*/,
+                             view /*:Window*/,
+                             ctrlKey /*:Boolean*/,    altKey /*:Boolean*/,
+                             shiftKey /*:Boolean*/,   metaKey /*:Boolean*/,
+                             keyCode /*:int*/,        charCode /*:int*/) /*:Void*/
+{
+    //check target
+    if (!target){
+        Y.error("simulateKeyEvent(): Invalid target.");
+    }
+
+    //check event type
+    if (isString(type)){
+        type = type.toLowerCase();
+        switch(type){
+            case "textevent": //DOM Level 3
+                type = "keypress";
+                break;
+            case "keyup":
+            case "keydown":
+            case "keypress":
+                break;
+            default:
+                Y.error("simulateKeyEvent(): Event type '" + type + "' not supported.");
+        }
+    } else {
+        Y.error("simulateKeyEvent(): Event type must be a string.");
+    }
+
+    //setup default values
+    if (!isBoolean(bubbles)){
+        bubbles = true; //all key events bubble
+    }
+    if (!isBoolean(cancelable)){
+        cancelable = true; //all key events can be cancelled
+    }
+    if (!isObject(view)){
+        view = Y.config.win; //view is typically window
+    }
+    if (!isBoolean(ctrlKey)){
+        ctrlKey = false;
+    }
+    if (!isBoolean(altKey)){
+        altKey = false;
+    }
+    if (!isBoolean(shiftKey)){
+        shiftKey = false;
+    }
+    if (!isBoolean(metaKey)){
+        metaKey = false;
+    }
+    if (!isNumber(keyCode)){
+        keyCode = 0;
+    }
+    if (!isNumber(charCode)){
+        charCode = 0;
+    }
+
+    //try to create a mouse event
+    var customEvent /*:MouseEvent*/ = null;
+
+    //check for DOM-compliant browsers first
+    if (isFunction(Y.config.doc.createEvent)){
+
+        try {
+
+            //try to create key event
+            customEvent = Y.config.doc.createEvent("KeyEvents");
+
+            /*
+             * Interesting problem: Firefox implemented a non-standard
+             * version of initKeyEvent() based on DOM Level 2 specs.
+             * Key event was removed from DOM Level 2 and re-introduced
+             * in DOM Level 3 with a different interface. Firefox is the
+             * only browser with any implementation of Key Events, so for
+             * now, assume it's Firefox if the above line doesn't error.
+             */
+            // @TODO: Decipher between Firefox's implementation and a correct one.
+            customEvent.initKeyEvent(type, bubbles, cancelable, view, ctrlKey,
+                altKey, shiftKey, metaKey, keyCode, charCode);
+
+        } catch (ex /*:Error*/){
+
+            /*
+             * If it got here, that means key events aren't officially supported.
+             * Safari/WebKit is a real problem now. WebKit 522 won't let you
+             * set keyCode, charCode, or other properties if you use a
+             * UIEvent, so we first must try to create a generic event. The
+             * fun part is that this will throw an error on Safari 2.x. The
+             * end result is that we need another try...catch statement just to
+             * deal with this mess.
+             */
+            try {
+
+                //try to create generic event - will fail in Safari 2.x
+                customEvent = Y.config.doc.createEvent("Events");
+
+            } catch (uierror /*:Error*/){
+
+                //the above failed, so create a UIEvent for Safari 2.x
+                customEvent = Y.config.doc.createEvent("UIEvents");
+
+            } finally {
+
+                customEvent.initEvent(type, bubbles, cancelable);
+
+                //initialize
+                customEvent.view = view;
+                customEvent.altKey = altKey;
+                customEvent.ctrlKey = ctrlKey;
+                customEvent.shiftKey = shiftKey;
+                customEvent.metaKey = metaKey;
+                customEvent.keyCode = keyCode;
+                customEvent.charCode = charCode;
+
+            }
+
+        }
+
+        //fire the event
+        target.dispatchEvent(customEvent);
+
+    } else if (isObject(Y.config.doc.createEventObject)){ //IE
+
+        //create an IE event object
+        customEvent = Y.config.doc.createEventObject();
+
+        //assign available properties
+        customEvent.bubbles = bubbles;
+        customEvent.cancelable = cancelable;
+        customEvent.view = view;
+        customEvent.ctrlKey = ctrlKey;
+        customEvent.altKey = altKey;
+        customEvent.shiftKey = shiftKey;
+        customEvent.metaKey = metaKey;
+
+        /*
+         * IE doesn't support charCode explicitly. CharCode should
+         * take precedence over any keyCode value for accurate
+         * representation.
+         */
+        customEvent.keyCode = (charCode > 0) ? charCode : keyCode;
+
+        //fire the event
+        target.fireEvent("on" + type, customEvent);
+
+    } else {
+        Y.error("simulateKeyEvent(): No event simulation framework present.");
+    }
+}
+
+/*
+ * Note: Intentionally not for YUIDoc generation.
+ * Simulates a mouse event using the given event information to populate
+ * the generated event object. This method does browser-equalizing
+ * calculations to account for differences in the DOM and IE event models
+ * as well as different browser quirks.
+ * @method simulateMouseEvent
+ * @private
+ * @static
+ * @param {HTMLElement} target The target of the given event.
+ * @param {String} type The type of event to fire. This can be any one of
+ *      the following: click, dblclick, mousedown, mouseup, mouseout,
+ *      mouseover, and mousemove.
+ * @param {Boolean} bubbles (Optional) Indicates if the event can be
+ *      bubbled up. DOM Level 2 specifies that all mouse events bubble by
+ *      default. The default is true.
+ * @param {Boolean} cancelable (Optional) Indicates if the event can be
+ *      canceled using preventDefault(). DOM Level 2 specifies that all
+ *      mouse events except mousemove can be cancelled. The default
+ *      is true for all events except mousemove, for which the default
+ *      is false.
+ * @param {Window} view (Optional) The view containing the target. This is
+ *      typically the window object. The default is window.
+ * @param {Number} detail (Optional) The number of times the mouse button has
+ *      been used. The default value is 1.
+ * @param {Number} screenX (Optional) The x-coordinate on the screen at which
+ *      point the event occured. The default is 0.
+ * @param {Number} screenY (Optional) The y-coordinate on the screen at which
+ *      point the event occured. The default is 0.
+ * @param {Number} clientX (Optional) The x-coordinate on the client at which
+ *      point the event occured. The default is 0.
+ * @param {Number} clientY (Optional) The y-coordinate on the client at which
+ *      point the event occured. The default is 0.
+ * @param {Boolean} ctrlKey (Optional) Indicates if one of the CTRL keys
+ *      is pressed while the event is firing. The default is false.
+ * @param {Boolean} altKey (Optional) Indicates if one of the ALT keys
+ *      is pressed while the event is firing. The default is false.
+ * @param {Boolean} shiftKey (Optional) Indicates if one of the SHIFT keys
+ *      is pressed while the event is firing. The default is false.
+ * @param {Boolean} metaKey (Optional) Indicates if one of the META keys
+ *      is pressed while the event is firing. The default is false.
+ * @param {Number} button (Optional) The button being pressed while the event
+ *      is executing. The value should be 0 for the primary mouse button
+ *      (typically the left button), 1 for the terciary mouse button
+ *      (typically the middle button), and 2 for the secondary mouse button
+ *      (typically the right button). The default is 0.
+ * @param {HTMLElement} relatedTarget (Optional) For mouseout events,
+ *      this is the element that the mouse has moved to. For mouseover
+ *      events, this is the element that the mouse has moved from. This
+ *      argument is ignored for all other events. The default is null.
+ */
+function simulateMouseEvent(target /*:HTMLElement*/, type /*:String*/,
+                               bubbles /*:Boolean*/,  cancelable /*:Boolean*/,
+                               view /*:Window*/,        detail /*:int*/,
+                               screenX /*:int*/,        screenY /*:int*/,
+                               clientX /*:int*/,        clientY /*:int*/,
+                               ctrlKey /*:Boolean*/,    altKey /*:Boolean*/,
+                               shiftKey /*:Boolean*/,   metaKey /*:Boolean*/,
+                               button /*:int*/,         relatedTarget /*:HTMLElement*/) /*:Void*/
+{
+    //check target
+    if (!target){
+        Y.error("simulateMouseEvent(): Invalid target.");
+    }
+
+
+    if (isString(type)){
+
+        //make sure it's a supported mouse event or an msPointerEvent.
+        if (!mouseEvents[type.toLowerCase()] && !pointerEvents[type]){
+            Y.error("simulateMouseEvent(): Event type '" + type + "' not supported.");
+        }
+    }
+    else {
+        Y.error("simulateMouseEvent(): Event type must be a string.");
+    }
+
+    //setup default values
+    if (!isBoolean(bubbles)){
+        bubbles = true; //all mouse events bubble
+    }
+    if (!isBoolean(cancelable)){
+        cancelable = (type !== "mousemove"); //mousemove is the only one that can't be cancelled
+    }
+    if (!isObject(view)){
+        view = Y.config.win; //view is typically window
+    }
+    if (!isNumber(detail)){
+        detail = 1;  //number of mouse clicks must be at least one
+    }
+    if (!isNumber(screenX)){
+        screenX = 0;
+    }
+    if (!isNumber(screenY)){
+        screenY = 0;
+    }
+    if (!isNumber(clientX)){
+        clientX = 0;
+    }
+    if (!isNumber(clientY)){
+        clientY = 0;
+    }
+    if (!isBoolean(ctrlKey)){
+        ctrlKey = false;
+    }
+    if (!isBoolean(altKey)){
+        altKey = false;
+    }
+    if (!isBoolean(shiftKey)){
+        shiftKey = false;
+    }
+    if (!isBoolean(metaKey)){
+        metaKey = false;
+    }
+    if (!isNumber(button)){
+        button = 0;
+    }
+
+    relatedTarget = relatedTarget || null;
+
+    //try to create a mouse event
+    var customEvent /*:MouseEvent*/ = null;
+
+    //check for DOM-compliant browsers first
+    if (isFunction(Y.config.doc.createEvent)){
+
+        customEvent = Y.config.doc.createEvent("MouseEvents");
+
+        //Safari 2.x (WebKit 418) still doesn't implement initMouseEvent()
+        if (customEvent.initMouseEvent){
+            customEvent.initMouseEvent(type, bubbles, cancelable, view, detail,
+                                 screenX, screenY, clientX, clientY,
+                                 ctrlKey, altKey, shiftKey, metaKey,
+                                 button, relatedTarget);
+        } else { //Safari
+
+            //the closest thing available in Safari 2.x is UIEvents
+            customEvent = Y.config.doc.createEvent("UIEvents");
+            customEvent.initEvent(type, bubbles, cancelable);
+            customEvent.view = view;
+            customEvent.detail = detail;
+            customEvent.screenX = screenX;
+            customEvent.screenY = screenY;
+            customEvent.clientX = clientX;
+            customEvent.clientY = clientY;
+            customEvent.ctrlKey = ctrlKey;
+            customEvent.altKey = altKey;
+            customEvent.metaKey = metaKey;
+            customEvent.shiftKey = shiftKey;
+            customEvent.button = button;
+            customEvent.relatedTarget = relatedTarget;
+        }
+
+        /*
+         * Check to see if relatedTarget has been assigned. Firefox
+         * versions less than 2.0 don't allow it to be assigned via
+         * initMouseEvent() and the property is readonly after event
+         * creation, so in order to keep YAHOO.util.getRelatedTarget()
+         * working, assign to the IE proprietary toElement property
+         * for mouseout event and fromElement property for mouseover
+         * event.
+         */
+        if (relatedTarget && !customEvent.relatedTarget){
+            if (type === "mouseout"){
+                customEvent.toElement = relatedTarget;
+            } else if (type === "mouseover"){
+                customEvent.fromElement = relatedTarget;
+            }
+        }
+
+        //fire the event
+        target.dispatchEvent(customEvent);
+
+    } else if (isObject(Y.config.doc.createEventObject)){ //IE
+
+        //create an IE event object
+        customEvent = Y.config.doc.createEventObject();
+
+        //assign available properties
+        customEvent.bubbles = bubbles;
+        customEvent.cancelable = cancelable;
+        customEvent.view = view;
+        customEvent.detail = detail;
+        customEvent.screenX = screenX;
+        customEvent.screenY = screenY;
+        customEvent.clientX = clientX;
+        customEvent.clientY = clientY;
+        customEvent.ctrlKey = ctrlKey;
+        customEvent.altKey = altKey;
+        customEvent.metaKey = metaKey;
+        customEvent.shiftKey = shiftKey;
+
+        //fix button property for IE's wacky implementation
+        switch(button){
+            case 0:
+                customEvent.button = 1;
+                break;
+            case 1:
+                customEvent.button = 4;
+                break;
+            case 2:
+                //leave as is
+                break;
+            default:
+                customEvent.button = 0;
+        }
+
+        /*
+         * Have to use relatedTarget because IE won't allow assignment
+         * to toElement or fromElement on generic events. This keeps
+         * YAHOO.util.customEvent.getRelatedTarget() functional.
+         */
+        customEvent.relatedTarget = relatedTarget;
+
+        //fire the event
+        target.fireEvent("on" + type, customEvent);
+
+    } else {
+        Y.error("simulateMouseEvent(): No event simulation framework present.");
+    }
+}
+
+/*
+ * Note: Intentionally not for YUIDoc generation.
+ * Simulates a UI event using the given event information to populate
+ * the generated event object. This method does browser-equalizing
+ * calculations to account for differences in the DOM and IE event models
+ * as well as different browser quirks.
+ * @method simulateHTMLEvent
+ * @private
+ * @static
+ * @param {HTMLElement} target The target of the given event.
+ * @param {String} type The type of event to fire. This can be any one of
+ *      the following: click, dblclick, mousedown, mouseup, mouseout,
+ *      mouseover, and mousemove.
+ * @param {Boolean} bubbles (Optional) Indicates if the event can be
+ *      bubbled up. DOM Level 2 specifies that all mouse events bubble by
+ *      default. The default is true.
+ * @param {Boolean} cancelable (Optional) Indicates if the event can be
+ *      canceled using preventDefault(). DOM Level 2 specifies that all
+ *      mouse events except mousemove can be cancelled. The default
+ *      is true for all events except mousemove, for which the default
+ *      is false.
+ * @param {Window} view (Optional) The view containing the target. This is
+ *      typically the window object. The default is window.
+ * @param {Number} detail (Optional) The number of times the mouse button has
+ *      been used. The default value is 1.
+ */
+function simulateUIEvent(target /*:HTMLElement*/, type /*:String*/,
+                               bubbles /*:Boolean*/,  cancelable /*:Boolean*/,
+                               view /*:Window*/,        detail /*:int*/) /*:Void*/
+{
+
+    //check target
+    if (!target){
+        Y.error("simulateUIEvent(): Invalid target.");
+    }
+
+    //check event type
+    if (isString(type)){
+        type = type.toLowerCase();
+
+        //make sure it's a supported mouse event
+        if (!uiEvents[type]){
+            Y.error("simulateUIEvent(): Event type '" + type + "' not supported.");
+        }
+    } else {
+        Y.error("simulateUIEvent(): Event type must be a string.");
+    }
+
+    //try to create a mouse event
+    var customEvent = null;
+
+
+    //setup default values
+    if (!isBoolean(bubbles)){
+        bubbles = (type in bubbleEvents);  //not all events bubble
+    }
+    if (!isBoolean(cancelable)){
+        cancelable = (type === "submit"); //submit is the only one that can be cancelled
+    }
+    if (!isObject(view)){
+        view = Y.config.win; //view is typically window
+    }
+    if (!isNumber(detail)){
+        detail = 1;  //usually not used but defaulted to this
+    }
+
+    //check for DOM-compliant browsers first
+    if (isFunction(Y.config.doc.createEvent)){
+
+        //just a generic UI Event object is needed
+        customEvent = Y.config.doc.createEvent("UIEvents");
+        customEvent.initUIEvent(type, bubbles, cancelable, view, detail);
+
+        //fire the event
+        target.dispatchEvent(customEvent);
+
+    } else if (isObject(Y.config.doc.createEventObject)){ //IE
+
+        //create an IE event object
+        customEvent = Y.config.doc.createEventObject();
+
+        //assign available properties
+        customEvent.bubbles = bubbles;
+        customEvent.cancelable = cancelable;
+        customEvent.view = view;
+        customEvent.detail = detail;
+
+        //fire the event
+        target.fireEvent("on" + type, customEvent);
+
+    } else {
+        Y.error("simulateUIEvent(): No event simulation framework present.");
+    }
+}
+
+/*
+ * (iOS only) This is for creating native DOM gesture events which only iOS
+ * v2.0+ is supporting.
+ *
+ * @method simulateGestureEvent
+ * @private
+ * @param {HTMLElement} target The target of the given event.
+ * @param {String} type The type of event to fire. This can be any one of
+ *      the following: touchstart, touchmove, touchend, touchcancel.
+ * @param {Boolean} bubbles (Optional) Indicates if the event can be
+ *      bubbled up. DOM Level 2 specifies that all mouse events bubble by
+ *      default. The default is true.
+ * @param {Boolean} cancelable (Optional) Indicates if the event can be
+ *      canceled using preventDefault(). DOM Level 2 specifies that all
+ *      touch events except touchcancel can be cancelled. The default
+ *      is true for all events except touchcancel, for which the default
+ *      is false.
+ * @param {Window} view (Optional) The view containing the target. This is
+ *      typically the window object. The default is window.
+ * @param {Number} detail (Optional) Specifies some detail information about
+ *      the event depending on the type of event.
+ * @param {Number} screenX (Optional) The x-coordinate on the screen at which
+ *      point the event occured. The default is 0.
+ * @param {Number} screenY (Optional) The y-coordinate on the screen at which
+ *      point the event occured. The default is 0.
+ * @param {Number} clientX (Optional) The x-coordinate on the client at which
+ *      point the event occured. The default is 0.
+ * @param {Number} clientY (Optional) The y-coordinate on the client at which
+ *      point the event occured. The default is 0.
+ * @param {Boolean} ctrlKey (Optional) Indicates if one of the CTRL keys
+ *      is pressed while the event is firing. The default is false.
+ * @param {Boolean} altKey (Optional) Indicates if one of the ALT keys
+ *      is pressed while the event is firing. The default is false.
+ * @param {Boolean} shiftKey (Optional) Indicates if one of the SHIFT keys
+ *      is pressed while the event is firing. The default is false.
+ * @param {Boolean} metaKey (Optional) Indicates if one of the META keys
+ *      is pressed while the event is firing. The default is false.
+ * @param {Number} scale (iOS v2+ only) The distance between two fingers
+ *      since the start of an event as a multiplier of the initial distance.
+ *      The default value is 1.0.
+ * @param {Number} rotation (iOS v2+ only) The delta rotation since the start
+ *      of an event, in degrees, where clockwise is positive and
+ *      counter-clockwise is negative. The default value is 0.0.
+ */
+function simulateGestureEvent(target, type,
+    bubbles,            // boolean
+    cancelable,         // boolean
+    view,               // DOMWindow
+    detail,             // long
+    screenX, screenY,   // long
+    clientX, clientY,   // long
+    ctrlKey, altKey, shiftKey, metaKey, // boolean
+    scale,              // float
+    rotation            // float
+) {
+    var customEvent;
+
+    if(!Y.UA.ios || Y.UA.ios<2.0) {
+        Y.error("simulateGestureEvent(): Native gesture DOM eventframe is not available in this platform.");
+    }
+
+    // check taget
+    if (!target){
+        Y.error("simulateGestureEvent(): Invalid target.");
+    }
+
+    //check event type
+    if (Y.Lang.isString(type)) {
+        type = type.toLowerCase();
+
+        //make sure it's a supported touch event
+        if (!gestureEvents[type]){
+            Y.error("simulateTouchEvent(): Event type '" + type + "' not supported.");
+        }
+    } else {
+        Y.error("simulateGestureEvent(): Event type must be a string.");
+    }
+
+    // setup default values
+    if (!Y.Lang.isBoolean(bubbles)) { bubbles = true; } // bubble by default
+    if (!Y.Lang.isBoolean(cancelable)) { cancelable = true; }
+    if (!Y.Lang.isObject(view))     { view = Y.config.win; }
+    if (!Y.Lang.isNumber(detail))   { detail = 2; }     // usually not used.
+    if (!Y.Lang.isNumber(screenX))  { screenX = 0; }
+    if (!Y.Lang.isNumber(screenY))  { screenY = 0; }
+    if (!Y.Lang.isNumber(clientX))  { clientX = 0; }
+    if (!Y.Lang.isNumber(clientY))  { clientY = 0; }
+    if (!Y.Lang.isBoolean(ctrlKey)) { ctrlKey = false; }
+    if (!Y.Lang.isBoolean(altKey))  { altKey = false; }
+    if (!Y.Lang.isBoolean(shiftKey)){ shiftKey = false; }
+    if (!Y.Lang.isBoolean(metaKey)) { metaKey = false; }
+
+    if (!Y.Lang.isNumber(scale)){ scale = 1.0; }
+    if (!Y.Lang.isNumber(rotation)){ rotation = 0.0; }
+
+    customEvent = Y.config.doc.createEvent("GestureEvent");
+
+    customEvent.initGestureEvent(type, bubbles, cancelable, view, detail,
+        screenX, screenY, clientX, clientY,
+        ctrlKey, altKey, shiftKey, metaKey,
+        target, scale, rotation);
+
+    target.dispatchEvent(customEvent);
+}
+
+
+/*
+ * @method simulateTouchEvent
+ * @private
+ * @param {HTMLElement} target The target of the given event.
+ * @param {String} type The type of event to fire. This can be any one of
+ *      the following: touchstart, touchmove, touchend, touchcancel.
+ * @param {Boolean} bubbles (Optional) Indicates if the event can be
+ *      bubbled up. DOM Level 2 specifies that all mouse events bubble by
+ *      default. The default is true.
+ * @param {Boolean} cancelable (Optional) Indicates if the event can be
+ *      canceled using preventDefault(). DOM Level 2 specifies that all
+ *      touch events except touchcancel can be cancelled. The default
+ *      is true for all events except touchcancel, for which the default
+ *      is false.
+ * @param {Window} view (Optional) The view containing the target. This is
+ *      typically the window object. The default is window.
+ * @param {Number} detail (Optional) Specifies some detail information about
+ *      the event depending on the type of event.
+ * @param {Number} screenX (Optional) The x-coordinate on the screen at which
+ *      point the event occured. The default is 0.
+ * @param {Number} screenY (Optional) The y-coordinate on the screen at which
+ *      point the event occured. The default is 0.
+ * @param {Number} clientX (Optional) The x-coordinate on the client at which
+ *      point the event occured. The default is 0.
+ * @param {Number} clientY (Optional) The y-coordinate on the client at which
+ *      point the event occured. The default is 0.
+ * @param {Boolean} ctrlKey (Optional) Indicates if one of the CTRL keys
+ *      is pressed while the event is firing. The default is false.
+ * @param {Boolean} altKey (Optional) Indicates if one of the ALT keys
+ *      is pressed while the event is firing. The default is false.
+ * @param {Boolean} shiftKey (Optional) Indicates if one of the SHIFT keys
+ *      is pressed while the event is firing. The default is false.
+ * @param {Boolean} metaKey (Optional) Indicates if one of the META keys
+ *      is pressed while the event is firing. The default is false.
+ * @param {TouchList} touches A collection of Touch objects representing
+ *      all touches associated with this event.
+ * @param {TouchList} targetTouches A collection of Touch objects
+ *      representing all touches associated with this target.
+ * @param {TouchList} changedTouches A collection of Touch objects
+ *      representing all touches that changed in this event.
+ * @param {Number} scale (iOS v2+ only) The distance between two fingers
+ *      since the start of an event as a multiplier of the initial distance.
+ *      The default value is 1.0.
+ * @param {Number} rotation (iOS v2+ only) The delta rotation since the start
+ *      of an event, in degrees, where clockwise is positive and
+ *      counter-clockwise is negative. The default value is 0.0.
+ */
+function simulateTouchEvent(target, type,
+    bubbles,            // boolean
+    cancelable,         // boolean
+    view,               // DOMWindow
+    detail,             // long
+    screenX, screenY,   // long
+    clientX, clientY,   // long
+    ctrlKey, altKey, shiftKey, metaKey, // boolean
+    touches,            // TouchList
+    targetTouches,      // TouchList
+    changedTouches,     // TouchList
+    scale,              // float
+    rotation            // float
+) {
+
+    var customEvent;
+
+    // check taget
+    if (!target){
+        Y.error("simulateTouchEvent(): Invalid target.");
+    }
+
+    //check event type
+    if (Y.Lang.isString(type)) {
+        type = type.toLowerCase();
+
+        //make sure it's a supported touch event
+        if (!touchEvents[type]){
+            Y.error("simulateTouchEvent(): Event type '" + type + "' not supported.");
+        }
+    } else {
+        Y.error("simulateTouchEvent(): Event type must be a string.");
+    }
+
+    // note that the caller is responsible to pass appropriate touch objects.
+    // check touch objects
+    // Android(even 4.0) doesn't define TouchList yet
+    /*if(type === 'touchstart' || type === 'touchmove') {
+        if(!touches instanceof TouchList) {
+            Y.error('simulateTouchEvent(): Invalid touches. It must be a TouchList');
+        } else {
+            if(touches.length === 0) {
+                Y.error('simulateTouchEvent(): No touch object found.');
+            }
+        }
+    } else if(type === 'touchend') {
+        if(!changedTouches instanceof TouchList) {
+            Y.error('simulateTouchEvent(): Invalid touches. It must be a TouchList');
+        } else {
+            if(changedTouches.length === 0) {
+                Y.error('simulateTouchEvent(): No touch object found.');
+            }
+        }
+    }*/
+
+    if(type === 'touchstart' || type === 'touchmove') {
+        if(touches.length === 0) {
+            Y.error('simulateTouchEvent(): No touch object in touches');
+        }
+    } else if(type === 'touchend') {
+        if(changedTouches.length === 0) {
+            Y.error('simulateTouchEvent(): No touch object in changedTouches');
+        }
+    }
+
+    // setup default values
+    if (!Y.Lang.isBoolean(bubbles)) { bubbles = true; } // bubble by default.
+    if (!Y.Lang.isBoolean(cancelable)) {
+        cancelable = (type !== "touchcancel"); // touchcancel is not cancelled
+    }
+    if (!Y.Lang.isObject(view))     { view = Y.config.win; }
+    if (!Y.Lang.isNumber(detail))   { detail = 1; } // usually not used. defaulted to # of touch objects.
+    if (!Y.Lang.isNumber(screenX))  { screenX = 0; }
+    if (!Y.Lang.isNumber(screenY))  { screenY = 0; }
+    if (!Y.Lang.isNumber(clientX))  { clientX = 0; }
+    if (!Y.Lang.isNumber(clientY))  { clientY = 0; }
+    if (!Y.Lang.isBoolean(ctrlKey)) { ctrlKey = false; }
+    if (!Y.Lang.isBoolean(altKey))  { altKey = false; }
+    if (!Y.Lang.isBoolean(shiftKey)){ shiftKey = false; }
+    if (!Y.Lang.isBoolean(metaKey)) { metaKey = false; }
+    if (!Y.Lang.isNumber(scale))    { scale = 1.0; }
+    if (!Y.Lang.isNumber(rotation)) { rotation = 0.0; }
+
+
+    //check for DOM-compliant browsers first
+    if (Y.Lang.isFunction(Y.config.doc.createEvent)) {
+        if (Y.UA.android) {
+            /*
+                * Couldn't find android start version that supports touch event.
+                * Assumed supported(btw APIs broken till icecream sandwitch)
+                * from the beginning.
+            */
+            if(Y.UA.android < 4.0) {
+                /*
+                    * Touch APIs are broken in androids older than 4.0. We will use
+                    * simulated touch apis for these versions.
+                    * App developer still can listen for touch events. This events
+                    * will be dispatched with touch event types.
+                    *
+                    * (Note) Used target for the relatedTarget. Need to verify if
+                    * it has a side effect.
+                */
+                customEvent = Y.config.doc.createEvent("MouseEvents");
+                customEvent.initMouseEvent(type, bubbles, cancelable, view, detail,
+                    screenX, screenY, clientX, clientY,
+                    ctrlKey, altKey, shiftKey, metaKey,
+                    0, target);
+
+                customEvent.touches = touches;
+                customEvent.targetTouches = targetTouches;
+                customEvent.changedTouches = changedTouches;
+            } else {
+                customEvent = Y.config.doc.createEvent("TouchEvent");
+
+                // Andoroid isn't compliant W3C initTouchEvent method signature.
+                customEvent.initTouchEvent(touches, targetTouches, changedTouches,
+                    type, view,
+                    screenX, screenY, clientX, clientY,
+                    ctrlKey, altKey, shiftKey, metaKey);
+            }
+        } else if (Y.UA.ios) {
+            if(Y.UA.ios >= 2.0) {
+                customEvent = Y.config.doc.createEvent("TouchEvent");
+
+                // Available iOS 2.0 and later
+                customEvent.initTouchEvent(type, bubbles, cancelable, view, detail,
+                    screenX, screenY, clientX, clientY,
+                    ctrlKey, altKey, shiftKey, metaKey,
+                    touches, targetTouches, changedTouches,
+                    scale, rotation);
+            } else {
+                Y.error('simulateTouchEvent(): No touch event simulation framework present for iOS, '+Y.UA.ios+'.');
+            }
+        } else {
+            Y.error('simulateTouchEvent(): Not supported agent yet, '+Y.UA.userAgent);
+        }
+
+        //fire the event
+        target.dispatchEvent(customEvent);
+    //} else if (Y.Lang.isObject(doc.createEventObject)){ // Windows Mobile/IE, support later
+    } else {
+        Y.error('simulateTouchEvent(): No event simulation framework present.');
+    }
+}
+
+/**
+ * Simulates the event or gesture with the given name on a target.
+ * @param {HTMLElement} target The DOM element that's the target of the event.
+ * @param {String} type The type of event or name of the supported gesture to simulate
+ *      (i.e., "click", "doubletap", "flick").
+ * @param {Object} options (Optional) Extra options to copy onto the event object.
+ *      For gestures, options are used to refine the gesture behavior.
+ * @for Event
+ * @method simulate
+ * @static
+ */
+Y.Event.simulate = function(target, type, options){
+
+    options = options || {};
+
+    if (mouseEvents[type] || pointerEvents[type]){
+        simulateMouseEvent(target, type, options.bubbles,
+            options.cancelable, options.view, options.detail, options.screenX,
+            options.screenY, options.clientX, options.clientY, options.ctrlKey,
+            options.altKey, options.shiftKey, options.metaKey, options.button,
+            options.relatedTarget);
+    } else if (keyEvents[type]){
+        simulateKeyEvent(target, type, options.bubbles,
+            options.cancelable, options.view, options.ctrlKey,
+            options.altKey, options.shiftKey, options.metaKey,
+            options.keyCode, options.charCode);
+    } else if (uiEvents[type]){
+        simulateUIEvent(target, type, options.bubbles,
+            options.cancelable, options.view, options.detail);
+
+    // touch low-level event simulation
+    } else if (touchEvents[type]) {
+        if((Y.config.win && ("ontouchstart" in Y.config.win)) && !(Y.UA.phantomjs) && !(Y.UA.chrome && Y.UA.chrome < 6)) {
+            simulateTouchEvent(target, type,
+                options.bubbles, options.cancelable, options.view, options.detail,
+                options.screenX, options.screenY, options.clientX, options.clientY,
+                options.ctrlKey, options.altKey, options.shiftKey, options.metaKey,
+                options.touches, options.targetTouches, options.changedTouches,
+                options.scale, options.rotation);
+        } else {
+            Y.error("simulate(): Event '" + type + "' can't be simulated. Use gesture-simulate module instead.");
+        }
+
+    // ios gesture low-level event simulation (iOS v2+ only)
+    } else if(Y.UA.ios && Y.UA.ios >= 2.0 && gestureEvents[type]) {
+        simulateGestureEvent(target, type,
+            options.bubbles, options.cancelable, options.view, options.detail,
+            options.screenX, options.screenY, options.clientX, options.clientY,
+            options.ctrlKey, options.altKey, options.shiftKey, options.metaKey,
+            options.scale, options.rotation);
+
+    // anything else
+    } else {
+        Y.error("simulate(): Event '" + type + "' can't be simulated.");
+    }
+};
+
+
+})();
+
+
+
+}, '3.17.2', {"requires": ["event-base"]});

Added: roller/trunk/app/src/main/webapp/roller-ui/yui3/event-synthetic/event-synthetic-min.js
URL: http://svn.apache.org/viewvc/roller/trunk/app/src/main/webapp/roller-ui/yui3/event-synthetic/event-synthetic-min.js?rev=1609737&view=auto
==============================================================================
--- roller/trunk/app/src/main/webapp/roller-ui/yui3/event-synthetic/event-synthetic-min.js (added)
+++ roller/trunk/app/src/main/webapp/roller-ui/yui3/event-synthetic/event-synthetic-min.js Fri Jul 11 16:23:25 2014
@@ -0,0 +1,8 @@
+/*
+YUI 3.17.2 (build 9c3c78e)
+Copyright 2014 Yahoo! Inc. All rights reserved.
+Licensed under the BSD License.
+http://yuilibrary.com/license/
+*/
+
+YUI.add("event-synthetic",function(e,t){function c(e,t){this.handle=e,this.emitFacade=t}function h(e,t,n){this.handles=[],this.el=e,this.key=n,this.domkey=t}function p(){this._init.apply(this,arguments)}var n=e.CustomEvent,r=e.Env.evt.dom_map,i=e.Array,s=e.Lang,o=s.isObject,u=s.isString,a=s.isArray,f=e.Selector.query,l=function(){};c.prototype.fire=function(t){var n=i(arguments,0,!0),r=this.handle,s=r.evt,u=r.sub,a=u.context,f=u.filter,l=t||{},c;if(this.emitFacade){if(!t||!t.preventDefault)l=s._getFacade(),o(t)&&!t.preventDefault?(e.mix(l,t,!0),n[0]=l):n.unshift(l);l.type=s.type,l.details=n.slice(),f&&(l.container=s.host)}else f&&o(t)&&t.currentTarget&&n.shift();return u.context=a||l.currentTarget||s.host,c=s.fire.apply(s,n),t.prevented&&s.preventedFn&&s.preventedFn.apply(s,n),t.stopped&&s.stoppedFn&&s.stoppedFn.apply(s,n),u.context=a,c},h.prototype={constructor:h,type:"_synth",fn:l,capture:!1,register:function(e){e.evt.registry=this,this.handles.push(e)},unregister:function(t){var 
 n=this.handles,i=r[this.domkey],s;for(s=n.length-1;s>=0;--s)if(n[s].sub===t){n.splice(s,1);break}n.length||(delete i[this.key],e.Object.size(i)||delete r[this.domkey])},detachAll:function(){var e=this.handles,t=e.length;while(--t>=0)e[t].detach()}},e.mix(p,{Notifier:c,SynthRegistry:h,getRegistry:function(t,n,i){var s=t._node,o=e.stamp(s),u="event:"+o+n+"_synth",a=r[o];return i&&(a||(a=r[o]={}),a[u]||(a[u]=new h(s,o,u))),a&&a[u]||null},_deleteSub:function(e){if(e&&e.fn){var t=this.eventDef,r=e.filter?"detachDelegate":"detach";this._subscribers=[],n.keepDeprecatedSubs&&(this.subscribers={}),t[r](e.node,e,this.notifier,e.filter),this.registry.unregister(e),delete e.fn,delete e.node,delete e.context}},prototype:{constructor:p,_init:function(){var e=this.publishConfig||(this.publishConfig={});this.emitFacade="emitFacade"in e?e.emitFacade:!0,e.emitFacade=!1},processArgs:l,on:l,detach:l,delegate:l,detachDelegate:l,_on:function(t,n){var r=[],s=t.slice(),o=this.processArgs(t,n),a=t[2],l=n?"d
 elegate":"on",c,h;return c=u(a)?f(a):i(a||e.one(e.config.win)),!c.length&&u(a)?(h=e.on("available",function(){e.mix(h,e[l].apply(e,s),!0)},a),h):(e.Array.each(c,function(i){var s=t.slice(),u;i=e.one(i),i&&(n&&(u=s.splice(3,1)[0]),s.splice(0,4,s[1],s[3]),(!this.preventDups||!this.getSubs(i,t,null,!0))&&r.push(this._subscribe(i,l,s,o,u)))},this),r.length===1?r[0]:new e.EventHandle(r))},_subscribe:function(t,n,r,i,s){var o=new e.CustomEvent(this.type,this.publishConfig),u=o.on.apply(o,r),a=new c(u,this.emitFacade),f=p.getRegistry(t,this.type,!0),l=u.sub;return l.node=t,l.filter=s,i&&this.applyArgExtras(i,l),e.mix(o,{eventDef:this,notifier:a,host:t,currentTarget:t,target:t,el:t._node,_delete:p._deleteSub},!0),u.notifier=a,f.register(u),this[n](t,l,a,s),u},applyArgExtras:function(e,t){t._extra=e},_detach:function(t){var n=t[2],r=u(n)?f(n):i(n),s,o,a,l,c;t.splice(2,1);for(o=0,a=r.length;o<a;++o){s=e.one(r[o]);if(s){l=this.getSubs(s,t);if(l)for(c=l.length-1;c>=0;--c)l[c].detach()}}},getSub
 s:function(e,t,n,r){var i=p.getRegistry(e,this.type),s=[],o,u,a,f;if(i){o=i.handles,n||(n=this.subMatch);for(u=0,a=o.length;u<a;++u){f=o[u];if(n.call(this,f.sub,t)){if(r)return f;s.push(o[u])}}}return s.length&&s},subMatch:function(e,t){return!t[1]||e.fn===t[1]}}},!0),e.SyntheticEvent=p,e.Event.define=function(t,n,r){var s,o,f;t&&t.type?(s=t,r=n):n&&(s=e.merge({type:t},n));if(s){if(r||!e.Node.DOM_EVENTS[s.type])o=function(){p.apply(this,arguments)},e.extend(o,p,s),f=new o,t=f.type,e.Node.DOM_EVENTS[t]=e.Env.evt.plugins[t]={eventDef:f,on:function(){return f._on(i(arguments))},delegate:function(){return f._on(i(arguments),!0)},detach:function(){return f._detach(i(arguments))}}}else(u(t)||a(t))&&e.Array.each(i(t),function(t){e.Node.DOM_EVENTS[t]=1});return f}},"3.17.2",{requires:["node-base","event-custom-complex"]});

Added: roller/trunk/app/src/main/webapp/roller-ui/yui3/event-synthetic/event-synthetic.js
URL: http://svn.apache.org/viewvc/roller/trunk/app/src/main/webapp/roller-ui/yui3/event-synthetic/event-synthetic.js?rev=1609737&view=auto
==============================================================================
--- roller/trunk/app/src/main/webapp/roller-ui/yui3/event-synthetic/event-synthetic.js (added)
+++ roller/trunk/app/src/main/webapp/roller-ui/yui3/event-synthetic/event-synthetic.js Fri Jul 11 16:23:25 2014
@@ -0,0 +1,852 @@
+/*
+YUI 3.17.2 (build 9c3c78e)
+Copyright 2014 Yahoo! Inc. All rights reserved.
+Licensed under the BSD License.
+http://yuilibrary.com/license/
+*/
+
+YUI.add('event-synthetic', function (Y, NAME) {
+
+/**
+ * Define new DOM events that can be subscribed to from Nodes.
+ *
+ * @module event
+ * @submodule event-synthetic
+ */
+var CustomEvent = Y.CustomEvent,
+    DOMMap   = Y.Env.evt.dom_map,
+    toArray  = Y.Array,
+    YLang    = Y.Lang,
+    isObject = YLang.isObject,
+    isString = YLang.isString,
+    isArray  = YLang.isArray,
+    query    = Y.Selector.query,
+    noop     = function () {};
+
+/**
+ * <p>The triggering mechanism used by SyntheticEvents.</p>
+ *
+ * <p>Implementers should not instantiate these directly.  Use the Notifier
+ * provided to the event's implemented <code>on(node, sub, notifier)</code> or
+ * <code>delegate(node, sub, notifier, filter)</code> methods.</p>
+ *
+ * @class SyntheticEvent.Notifier
+ * @constructor
+ * @param handle {EventHandle} the detach handle for the subscription to an
+ *              internal custom event used to execute the callback passed to
+ *              on(..) or delegate(..)
+ * @param emitFacade {Boolean} take steps to ensure the first arg received by
+ *              the subscription callback is an event facade
+ * @private
+ * @since 3.2.0
+ */
+function Notifier(handle, emitFacade) {
+    this.handle     = handle;
+    this.emitFacade = emitFacade;
+}
+
+/**
+ * <p>Executes the subscription callback, passing the firing arguments as the
+ * first parameters to that callback. For events that are configured with
+ * emitFacade=true, it is common practice to pass the triggering DOMEventFacade
+ * as the first parameter.  Barring a proper DOMEventFacade or EventFacade
+ * (from a CustomEvent), a new EventFacade will be generated.  In that case, if
+ * fire() is called with a simple object, it will be mixed into the facade.
+ * Otherwise, the facade will be prepended to the callback parameters.</p>
+ *
+ * <p>For notifiers provided to delegate logic, the first argument should be an
+ * object with a &quot;currentTarget&quot; property to identify what object to
+ * default as 'this' in the callback.  Typically this is gleaned from the
+ * DOMEventFacade or EventFacade, but if configured with emitFacade=false, an
+ * object must be provided.  In that case, the object will be removed from the
+ * callback parameters.</p>
+ *
+ * <p>Additional arguments passed during event subscription will be
+ * automatically added after those passed to fire().</p>
+ *
+ * @method fire
+ * @param {EventFacade|DOMEventFacade|any} e (see description)
+ * @param {any[]} [arg*] additional arguments received by all subscriptions
+ * @private
+ */
+Notifier.prototype.fire = function (e) {
+    // first arg to delegate notifier should be an object with currentTarget
+    var args     = toArray(arguments, 0, true),
+        handle   = this.handle,
+        ce       = handle.evt,
+        sub      = handle.sub,
+        thisObj  = sub.context,
+        delegate = sub.filter,
+        event    = e || {},
+        ret;
+
+    if (this.emitFacade) {
+        if (!e || !e.preventDefault) {
+            event = ce._getFacade();
+
+            if (isObject(e) && !e.preventDefault) {
+                Y.mix(event, e, true);
+                args[0] = event;
+            } else {
+                args.unshift(event);
+            }
+        }
+
+        event.type    = ce.type;
+        event.details = args.slice();
+
+        if (delegate) {
+            event.container = ce.host;
+        }
+    } else if (delegate && isObject(e) && e.currentTarget) {
+        args.shift();
+    }
+
+    sub.context = thisObj || event.currentTarget || ce.host;
+    ret = ce.fire.apply(ce, args);
+
+    // have to handle preventedFn and stoppedFn manually because
+    // Notifier CustomEvents are forced to emitFacade=false
+    if (e.prevented && ce.preventedFn) {
+        ce.preventedFn.apply(ce, args);
+    }
+
+    if (e.stopped && ce.stoppedFn) {
+        ce.stoppedFn.apply(ce, args);
+    }
+
+    sub.context = thisObj; // reset for future firing
+
+    // to capture callbacks that return false to stopPropagation.
+    // Useful for delegate implementations
+    return ret;
+};
+
+/**
+ * Manager object for synthetic event subscriptions to aggregate multiple synths on the
+ * same node without colliding with actual DOM subscription entries in the global map of
+ * DOM subscriptions.  Also facilitates proper cleanup on page unload.
+ *
+ * @class SynthRegistry
+ * @constructor
+ * @param el {HTMLElement} the DOM element
+ * @param yuid {String} the yuid stamp for the element
+ * @param key {String} the generated id token used to identify an event type +
+ *                     element in the global DOM subscription map.
+ * @private
+ */
+function SynthRegistry(el, yuid, key) {
+    this.handles = [];
+    this.el      = el;
+    this.key     = key;
+    this.domkey  = yuid;
+}
+
+SynthRegistry.prototype = {
+    constructor: SynthRegistry,
+
+    // A few object properties to fake the CustomEvent interface for page
+    // unload cleanup.  DON'T TOUCH!
+    type      : '_synth',
+    fn        : noop,
+    capture   : false,
+
+    /**
+     * Adds a subscription from the Notifier registry.
+     *
+     * @method register
+     * @param handle {EventHandle} the subscription
+     * @since 3.4.0
+     */
+    register: function (handle) {
+        handle.evt.registry = this;
+        this.handles.push(handle);
+    },
+
+    /**
+     * Removes the subscription from the Notifier registry.
+     *
+     * @method _unregisterSub
+     * @param sub {Subscription} the subscription
+     * @since 3.4.0
+     */
+    unregister: function (sub) {
+        var handles = this.handles,
+            events = DOMMap[this.domkey],
+            i;
+
+        for (i = handles.length - 1; i >= 0; --i) {
+            if (handles[i].sub === sub) {
+                handles.splice(i, 1);
+                break;
+            }
+        }
+
+        // Clean up left over objects when there are no more subscribers.
+        if (!handles.length) {
+            delete events[this.key];
+            if (!Y.Object.size(events)) {
+                delete DOMMap[this.domkey];
+            }
+        }
+    },
+
+    /**
+     * Used by the event system's unload cleanup process.  When navigating
+     * away from the page, the event system iterates the global map of element
+     * subscriptions and detaches everything using detachAll().  Normally,
+     * the map is populated with custom events, so this object needs to
+     * at least support the detachAll method to duck type its way to
+     * cleanliness.
+     *
+     * @method detachAll
+     * @private
+     * @since 3.4.0
+     */
+    detachAll : function () {
+        var handles = this.handles,
+            i = handles.length;
+
+        while (--i >= 0) {
+            handles[i].detach();
+        }
+    }
+};
+
+/**
+ * <p>Wrapper class for the integration of new events into the YUI event
+ * infrastructure.  Don't instantiate this object directly, use
+ * <code>Y.Event.define(type, config)</code>.  See that method for details.</p>
+ *
+ * <p>Properties that MAY or SHOULD be specified in the configuration are noted
+ * below and in the description of <code>Y.Event.define</code>.</p>
+ *
+ * @class SyntheticEvent
+ * @constructor
+ * @param cfg {Object} Implementation pieces and configuration
+ * @since 3.1.0
+ * @in event-synthetic
+ */
+function SyntheticEvent() {
+    this._init.apply(this, arguments);
+}
+
+Y.mix(SyntheticEvent, {
+    Notifier: Notifier,
+    SynthRegistry: SynthRegistry,
+
+    /**
+     * Returns the array of subscription handles for a node for the given event
+     * type.  Passing true as the third argument will create a registry entry
+     * in the event system's DOM map to host the array if one doesn't yet exist.
+     *
+     * @method getRegistry
+     * @param node {Node} the node
+     * @param type {String} the event
+     * @param create {Boolean} create a registration entry to host a new array
+     *                  if one doesn't exist.
+     * @return {Array}
+     * @static
+     * @protected
+     * @since 3.2.0
+     */
+    getRegistry: function (node, type, create) {
+        var el     = node._node,
+            yuid   = Y.stamp(el),
+            key    = 'event:' + yuid + type + '_synth',
+            events = DOMMap[yuid];
+
+        if (create) {
+            if (!events) {
+                events = DOMMap[yuid] = {};
+            }
+            if (!events[key]) {
+                events[key] = new SynthRegistry(el, yuid, key);
+            }
+        }
+
+        return (events && events[key]) || null;
+    },
+
+    /**
+     * Alternate <code>_delete()</code> method for the CustomEvent object
+     * created to manage SyntheticEvent subscriptions.
+     *
+     * @method _deleteSub
+     * @param sub {Subscription} the subscription to clean up
+     * @private
+     * @since 3.2.0
+     */
+    _deleteSub: function (sub) {
+        if (sub && sub.fn) {
+            var synth = this.eventDef,
+                method = (sub.filter) ? 'detachDelegate' : 'detach';
+
+            this._subscribers = [];
+
+            if (CustomEvent.keepDeprecatedSubs) {
+                this.subscribers = {};
+            }
+
+            synth[method](sub.node, sub, this.notifier, sub.filter);
+            this.registry.unregister(sub);
+
+            delete sub.fn;
+            delete sub.node;
+            delete sub.context;
+        }
+    },
+
+    prototype: {
+        constructor: SyntheticEvent,
+
+        /**
+         * Construction logic for the event.
+         *
+         * @method _init
+         * @protected
+         */
+        _init: function () {
+            var config = this.publishConfig || (this.publishConfig = {});
+
+            // The notification mechanism handles facade creation
+            this.emitFacade = ('emitFacade' in config) ?
+                                config.emitFacade :
+                                true;
+            config.emitFacade  = false;
+        },
+
+        /**
+         * <p>Implementers MAY provide this method definition.</p>
+         *
+         * <p>Implement this function if the event supports a different
+         * subscription signature.  This function is used by both
+         * <code>on()</code> and <code>delegate()</code>.  The second parameter
+         * indicates that the event is being subscribed via
+         * <code>delegate()</code>.</p>
+         *
+         * <p>Implementations must remove extra arguments from the args list
+         * before returning.  The required args for <code>on()</code>
+         * subscriptions are</p>
+         * <pre><code>[type, callback, target, context, argN...]</code></pre>
+         *
+         * <p>The required args for <code>delegate()</code>
+         * subscriptions are</p>
+         *
+         * <pre><code>[type, callback, target, filter, context, argN...]</code></pre>
+         *
+         * <p>The return value from this function will be stored on the
+         * subscription in the '_extra' property for reference elsewhere.</p>
+         *
+         * @method processArgs
+         * @param args {Array} parmeters passed to Y.on(..) or Y.delegate(..)
+         * @param delegate {Boolean} true if the subscription is from Y.delegate
+         * @return {any}
+         */
+        processArgs: noop,
+
+        /**
+         * <p>Implementers MAY override this property.</p>
+         *
+         * <p>Whether to prevent multiple subscriptions to this event that are
+         * classified as being the same.  By default, this means the subscribed
+         * callback is the same function.  See the <code>subMatch</code>
+         * method.  Setting this to true will impact performance for high volume
+         * events.</p>
+         *
+         * @property preventDups
+         * @type {Boolean}
+         * @default false
+         */
+        //preventDups  : false,
+
+        /**
+         * <p>Implementers SHOULD provide this method definition.</p>
+         *
+         * Implementation logic for subscriptions done via <code>node.on(type,
+         * fn)</code> or <code>Y.on(type, fn, target)</code>.  This
+         * function should set up the monitor(s) that will eventually fire the
+         * event.  Typically this involves subscribing to at least one DOM
+         * event.  It is recommended to store detach handles from any DOM
+         * subscriptions to make for easy cleanup in the <code>detach</code>
+         * method.  Typically these handles are added to the <code>sub</code>
+         * object.  Also for SyntheticEvents that leverage a single DOM
+         * subscription under the hood, it is recommended to pass the DOM event
+         * object to <code>notifier.fire(e)</code>.  (The event name on the
+         * object will be updated).
+         *
+         * @method on
+         * @param node {Node} the node the subscription is being applied to
+         * @param sub {Subscription} the object to track this subscription
+         * @param notifier {SyntheticEvent.Notifier} call notifier.fire(..) to
+         *              trigger the execution of the subscribers
+         */
+        on: noop,
+
+        /**
+         * <p>Implementers SHOULD provide this method definition.</p>
+         *
+         * <p>Implementation logic for detaching subscriptions done via
+         * <code>node.on(type, fn)</code>.  This function should clean up any
+         * subscriptions made in the <code>on()</code> phase.</p>
+         *
+         * @method detach
+         * @param node {Node} the node the subscription was applied to
+         * @param sub {Subscription} the object tracking this subscription
+         * @param notifier {SyntheticEvent.Notifier} the Notifier used to
+         *              trigger the execution of the subscribers
+         */
+        detach: noop,
+
+        /**
+         * <p>Implementers SHOULD provide this method definition.</p>
+         *
+         * <p>Implementation logic for subscriptions done via
+         * <code>node.delegate(type, fn, filter)</code> or
+         * <code>Y.delegate(type, fn, container, filter)</code>.  Like with
+         * <code>on()</code> above, this function should monitor the environment
+         * for the event being fired, and trigger subscription execution by
+         * calling <code>notifier.fire(e)</code>.</p>
+         *
+         * <p>This function receives a fourth argument, which is the filter
+         * used to identify which Node's are of interest to the subscription.
+         * The filter will be either a boolean function that accepts a target
+         * Node for each hierarchy level as the event bubbles, or a selector
+         * string.  To translate selector strings into filter functions, use
+         * <code>Y.delegate.compileFilter(filter)</code>.</p>
+         *
+         * @method delegate
+         * @param node {Node} the node the subscription is being applied to
+         * @param sub {Subscription} the object to track this subscription
+         * @param notifier {SyntheticEvent.Notifier} call notifier.fire(..) to
+         *              trigger the execution of the subscribers
+         * @param filter {String|Function} Selector string or function that
+         *              accepts an event object and returns null, a Node, or an
+         *              array of Nodes matching the criteria for processing.
+         * @since 3.2.0
+         */
+        delegate       : noop,
+
+        /**
+         * <p>Implementers SHOULD provide this method definition.</p>
+         *
+         * <p>Implementation logic for detaching subscriptions done via
+         * <code>node.delegate(type, fn, filter)</code> or
+         * <code>Y.delegate(type, fn, container, filter)</code>.  This function
+         * should clean up any subscriptions made in the
+         * <code>delegate()</code> phase.</p>
+         *
+         * @method detachDelegate
+         * @param node {Node} the node the subscription was applied to
+         * @param sub {Subscription} the object tracking this subscription
+         * @param notifier {SyntheticEvent.Notifier} the Notifier used to
+         *              trigger the execution of the subscribers
+         * @param filter {String|Function} Selector string or function that
+         *              accepts an event object and returns null, a Node, or an
+         *              array of Nodes matching the criteria for processing.
+         * @since 3.2.0
+         */
+        detachDelegate : noop,
+
+        /**
+         * Sets up the boilerplate for detaching the event and facilitating the
+         * execution of subscriber callbacks.
+         *
+         * @method _on
+         * @param args {Array} array of arguments passed to
+         *              <code>Y.on(...)</code> or <code>Y.delegate(...)</code>
+         * @param delegate {Boolean} true if called from
+         * <code>Y.delegate(...)</code>
+         * @return {EventHandle} the detach handle for this subscription
+         * @private
+         * since 3.2.0
+         */
+        _on: function (args, delegate) {
+            var handles  = [],
+                originalArgs = args.slice(),
+                extra    = this.processArgs(args, delegate),
+                selector = args[2],
+                method   = delegate ? 'delegate' : 'on',
+                nodes, handle;
+
+            // Can't just use Y.all because it doesn't support window (yet?)
+            nodes = (isString(selector)) ?
+                query(selector) :
+                toArray(selector || Y.one(Y.config.win));
+
+            if (!nodes.length && isString(selector)) {
+                handle = Y.on('available', function () {
+                    Y.mix(handle, Y[method].apply(Y, originalArgs), true);
+                }, selector);
+
+                return handle;
+            }
+
+            Y.Array.each(nodes, function (node) {
+                var subArgs = args.slice(),
+                    filter;
+
+                node = Y.one(node);
+
+                if (node) {
+                    if (delegate) {
+                        filter = subArgs.splice(3, 1)[0];
+                    }
+
+                    // (type, fn, el, thisObj, ...) => (fn, thisObj, ...)
+                    subArgs.splice(0, 4, subArgs[1], subArgs[3]);
+
+                    if (!this.preventDups ||
+                        !this.getSubs(node, args, null, true))
+                    {
+                        handles.push(this._subscribe(node, method, subArgs, extra, filter));
+                    }
+                }
+            }, this);
+
+            return (handles.length === 1) ?
+                handles[0] :
+                new Y.EventHandle(handles);
+        },
+
+        /**
+         * Creates a new Notifier object for use by this event's
+         * <code>on(...)</code> or <code>delegate(...)</code> implementation
+         * and register the custom event proxy in the DOM system for cleanup.
+         *
+         * @method _subscribe
+         * @param node {Node} the Node hosting the event
+         * @param method {String} "on" or "delegate"
+         * @param args {Array} the subscription arguments passed to either
+         *              <code>Y.on(...)</code> or <code>Y.delegate(...)</code>
+         *              after running through <code>processArgs(args)</code> to
+         *              normalize the argument signature
+         * @param extra {any} Extra data parsed from
+         *              <code>processArgs(args)</code>
+         * @param filter {String|Function} the selector string or function
+         *              filter passed to <code>Y.delegate(...)</code> (not
+         *              present when called from <code>Y.on(...)</code>)
+         * @return {EventHandle}
+         * @private
+         * @since 3.2.0
+         */
+        _subscribe: function (node, method, args, extra, filter) {
+            var dispatcher = new Y.CustomEvent(this.type, this.publishConfig),
+                handle     = dispatcher.on.apply(dispatcher, args),
+                notifier   = new Notifier(handle, this.emitFacade),
+                registry   = SyntheticEvent.getRegistry(node, this.type, true),
+                sub        = handle.sub;
+
+            sub.node   = node;
+            sub.filter = filter;
+            if (extra) {
+                this.applyArgExtras(extra, sub);
+            }
+
+            Y.mix(dispatcher, {
+                eventDef     : this,
+                notifier     : notifier,
+                host         : node,       // I forget what this is for
+                currentTarget: node,       // for generating facades
+                target       : node,       // for generating facades
+                el           : node._node, // For category detach
+
+                _delete      : SyntheticEvent._deleteSub
+            }, true);
+
+            handle.notifier = notifier;
+
+            registry.register(handle);
+
+            // Call the implementation's "on" or "delegate" method
+            this[method](node, sub, notifier, filter);
+
+            return handle;
+        },
+
+        /**
+         * <p>Implementers MAY provide this method definition.</p>
+         *
+         * <p>Implement this function if you want extra data extracted during
+         * processArgs to be propagated to subscriptions on a per-node basis.
+         * That is to say, if you call <code>Y.on('xyz', fn, xtra, 'div')</code>
+         * the data returned from processArgs will be shared
+         * across the subscription objects for all the divs.  If you want each
+         * subscription to receive unique information, do that processing
+         * here.</p>
+         *
+         * <p>The default implementation adds the data extracted by processArgs
+         * to the subscription object as <code>sub._extra</code>.</p>
+         *
+         * @method applyArgExtras
+         * @param extra {any} Any extra data extracted from processArgs
+         * @param sub {Subscription} the individual subscription
+         */
+        applyArgExtras: function (extra, sub) {
+            sub._extra = extra;
+        },
+
+        /**
+         * Removes the subscription(s) from the internal subscription dispatch
+         * mechanism.  See <code>SyntheticEvent._deleteSub</code>.
+         *
+         * @method _detach
+         * @param args {Array} The arguments passed to
+         *                  <code>node.detach(...)</code>
+         * @private
+         * @since 3.2.0
+         */
+        _detach: function (args) {
+            // Can't use Y.all because it doesn't support window (yet?)
+            // TODO: Does Y.all support window now?
+            var target = args[2],
+                els    = (isString(target)) ?
+                            query(target) : toArray(target),
+                node, i, len, handles, j;
+
+            // (type, fn, el, context, filter?) => (type, fn, context, filter?)
+            args.splice(2, 1);
+
+            for (i = 0, len = els.length; i < len; ++i) {
+                node = Y.one(els[i]);
+
+                if (node) {
+                    handles = this.getSubs(node, args);
+
+                    if (handles) {
+                        for (j = handles.length - 1; j >= 0; --j) {
+                            handles[j].detach();
+                        }
+                    }
+                }
+            }
+        },
+
+        /**
+         * Returns the detach handles of subscriptions on a node that satisfy a
+         * search/filter function.  By default, the filter used is the
+         * <code>subMatch</code> method.
+         *
+         * @method getSubs
+         * @param node {Node} the node hosting the event
+         * @param args {Array} the array of original subscription args passed
+         *              to <code>Y.on(...)</code> (before
+         *              <code>processArgs</code>
+         * @param filter {Function} function used to identify a subscription
+         *              for inclusion in the returned array
+         * @param first {Boolean} stop after the first match (used to check for
+         *              duplicate subscriptions)
+         * @return {EventHandle[]} detach handles for the matching subscriptions
+         */
+        getSubs: function (node, args, filter, first) {
+            var registry = SyntheticEvent.getRegistry(node, this.type),
+                handles  = [],
+                allHandles, i, len, handle;
+
+            if (registry) {
+                allHandles = registry.handles;
+
+                if (!filter) {
+                    filter = this.subMatch;
+                }
+
+                for (i = 0, len = allHandles.length; i < len; ++i) {
+                    handle = allHandles[i];
+                    if (filter.call(this, handle.sub, args)) {
+                        if (first) {
+                            return handle;
+                        } else {
+                            handles.push(allHandles[i]);
+                        }
+                    }
+                }
+            }
+
+            return handles.length && handles;
+        },
+
+        /**
+         * <p>Implementers MAY override this to define what constitutes a
+         * &quot;same&quot; subscription.  Override implementations should
+         * consider the lack of a comparator as a match, so calling
+         * <code>getSubs()</code> with no arguments will return all subs.</p>
+         *
+         * <p>Compares a set of subscription arguments against a Subscription
+         * object to determine if they match.  The default implementation
+         * compares the callback function against the second argument passed to
+         * <code>Y.on(...)</code> or <code>node.detach(...)</code> etc.</p>
+         *
+         * @method subMatch
+         * @param sub {Subscription} the existing subscription
+         * @param args {Array} the calling arguments passed to
+         *                  <code>Y.on(...)</code> etc.
+         * @return {Boolean} true if the sub can be described by the args
+         *                  present
+         * @since 3.2.0
+         */
+        subMatch: function (sub, args) {
+            // Default detach cares only about the callback matching
+            return !args[1] || sub.fn === args[1];
+        }
+    }
+}, true);
+
+Y.SyntheticEvent = SyntheticEvent;
+
+/**
+ * <p>Defines a new event in the DOM event system.  Implementers are
+ * responsible for monitoring for a scenario whereby the event is fired.  A
+ * notifier object is provided to the functions identified below.  When the
+ * criteria defining the event are met, call notifier.fire( [args] ); to
+ * execute event subscribers.</p>
+ *
+ * <p>The first parameter is the name of the event.  The second parameter is a
+ * configuration object which define the behavior of the event system when the
+ * new event is subscribed to or detached from.  The methods that should be
+ * defined in this configuration object are <code>on</code>,
+ * <code>detach</code>, <code>delegate</code>, and <code>detachDelegate</code>.
+ * You are free to define any other methods or properties needed to define your
+ * event.  Be aware, however, that since the object is used to subclass
+ * SyntheticEvent, you should avoid method names used by SyntheticEvent unless
+ * your intention is to override the default behavior.</p>
+ *
+ * <p>This is a list of properties and methods that you can or should specify
+ * in the configuration object:</p>
+ *
+ * <dl>
+ *   <dt><code>on</code></dt>
+ *       <dd><code>function (node, subscription, notifier)</code> The
+ *       implementation logic for subscription.  Any special setup you need to
+ *       do to create the environment for the event being fired--E.g. native
+ *       DOM event subscriptions.  Store subscription related objects and
+ *       state on the <code>subscription</code> object.  When the
+ *       criteria have been met to fire the synthetic event, call
+ *       <code>notifier.fire(e)</code>.  See Notifier's <code>fire()</code>
+ *       method for details about what to pass as parameters.</dd>
+ *
+ *   <dt><code>detach</code></dt>
+ *       <dd><code>function (node, subscription, notifier)</code> The
+ *       implementation logic for cleaning up a detached subscription. E.g.
+ *       detach any DOM subscriptions added in <code>on</code>.</dd>
+ *
+ *   <dt><code>delegate</code></dt>
+ *       <dd><code>function (node, subscription, notifier, filter)</code> The
+ *       implementation logic for subscription via <code>Y.delegate</code> or
+ *       <code>node.delegate</code>.  The filter is typically either a selector
+ *       string or a function.  You can use
+ *       <code>Y.delegate.compileFilter(selectorString)</code> to create a
+ *       filter function from a selector string if needed.  The filter function
+ *       expects an event object as input and should output either null, a
+ *       matching Node, or an array of matching Nodes.  Otherwise, this acts
+ *       like <code>on</code> DOM event subscriptions.  Store subscription
+ *       related objects and information on the <code>subscription</code>
+ *       object.  When the criteria have been met to fire the synthetic event,
+ *       call <code>notifier.fire(e)</code> as noted above.</dd>
+ *
+ *   <dt><code>detachDelegate</code></dt>
+ *       <dd><code>function (node, subscription, notifier)</code> The
+ *       implementation logic for cleaning up a detached delegate subscription.
+ *       E.g. detach any DOM delegate subscriptions added in
+ *       <code>delegate</code>.</dd>
+ *
+ *   <dt><code>publishConfig</code></dt>
+ *       <dd>(Object) The configuration object that will be used to instantiate
+ *       the underlying CustomEvent. See Notifier's <code>fire</code> method
+ *       for details.</dd>
+ *
+ *   <dt><code>processArgs</code></dt
+ *       <dd>
+ *          <p><code>function (argArray, fromDelegate)</code> Optional method
+ *          to extract any additional arguments from the subscription
+ *          signature.  Using this allows <code>on</code> or
+ *          <code>delegate</code> signatures like
+ *          <code>node.on(&quot;hover&quot;, overCallback,
+ *          outCallback)</code>.</p>
+ *          <p>When processing an atypical argument signature, make sure the
+ *          args array is returned to the normal signature before returning
+ *          from the function.  For example, in the &quot;hover&quot; example
+ *          above, the <code>outCallback</code> needs to be <code>splice</code>d
+ *          out of the array.  The expected signature of the args array for
+ *          <code>on()</code> subscriptions is:</p>
+ *          <pre>
+ *              <code>[type, callback, target, contextOverride, argN...]</code>
+ *          </pre>
+ *          <p>And for <code>delegate()</code>:</p>
+ *          <pre>
+ *              <code>[type, callback, target, filter, contextOverride, argN...]</code>
+ *          </pre>
+ *          <p>where <code>target</code> is the node the event is being
+ *          subscribed for.  You can see these signatures documented for
+ *          <code>Y.on()</code> and <code>Y.delegate()</code> respectively.</p>
+ *          <p>Whatever gets returned from the function will be stored on the
+ *          <code>subscription</code> object under
+ *          <code>subscription._extra</code>.</p></dd>
+ *   <dt><code>subMatch</code></dt>
+ *       <dd>
+ *           <p><code>function (sub, args)</code>  Compares a set of
+ *           subscription arguments against a Subscription object to determine
+ *           if they match.  The default implementation compares the callback
+ *           function against the second argument passed to
+ *           <code>Y.on(...)</code> or <code>node.detach(...)</code> etc.</p>
+ *       </dd>
+ * </dl>
+ *
+ * @method define
+ * @param type {String} the name of the event
+ * @param config {Object} the prototype definition for the new event (see above)
+ * @param force {Boolean} override an existing event (use with caution)
+ * @return {SyntheticEvent} the subclass implementation instance created to
+ *              handle event subscriptions of this type
+ * @static
+ * @for Event
+ * @since 3.1.0
+ * @in event-synthetic
+ */
+Y.Event.define = function (type, config, force) {
+    var eventDef, Impl, synth;
+
+    if (type && type.type) {
+        eventDef = type;
+        force = config;
+    } else if (config) {
+        eventDef = Y.merge({ type: type }, config);
+    }
+
+    if (eventDef) {
+        if (force || !Y.Node.DOM_EVENTS[eventDef.type]) {
+            Impl = function () {
+                SyntheticEvent.apply(this, arguments);
+            };
+            Y.extend(Impl, SyntheticEvent, eventDef);
+            synth = new Impl();
+
+            type = synth.type;
+
+            Y.Node.DOM_EVENTS[type] = Y.Env.evt.plugins[type] = {
+                eventDef: synth,
+
+                on: function () {
+                    return synth._on(toArray(arguments));
+                },
+
+                delegate: function () {
+                    return synth._on(toArray(arguments), true);
+                },
+
+                detach: function () {
+                    return synth._detach(toArray(arguments));
+                }
+            };
+
+        }
+    } else if (isString(type) || isArray(type)) {
+        Y.Array.each(toArray(type), function (t) {
+            Y.Node.DOM_EVENTS[t] = 1;
+        });
+    }
+
+    return synth;
+};
+
+
+}, '3.17.2', {"requires": ["node-base", "event-custom-complex"]});

Added: roller/trunk/app/src/main/webapp/roller-ui/yui3/features/features-min.js
URL: http://svn.apache.org/viewvc/roller/trunk/app/src/main/webapp/roller-ui/yui3/features/features-min.js?rev=1609737&view=auto
==============================================================================
--- roller/trunk/app/src/main/webapp/roller-ui/yui3/features/features-min.js (added)
+++ roller/trunk/app/src/main/webapp/roller-ui/yui3/features/features-min.js Fri Jul 11 16:23:25 2014
@@ -0,0 +1,8 @@
+/*
+YUI 3.17.2 (build 9c3c78e)
+Copyright 2014 Yahoo! Inc. All rights reserved.
+Licensed under the BSD License.
+http://yuilibrary.com/license/
+*/
+
+YUI.add("features",function(e,t){var n={};e.mix(e.namespace("Features"),{tests:n,add:function(e,t,r){n[e]=n[e]||{},n[e][t]=r},all:function(t,r){var i=n[t],s=[];return i&&e.Object.each(i,function(n,i){s.push(i+":"+(e.Features.test(t,i,r)?1:0))}),s.length?s.join(";"):""},test:function(t,r,i){i=i||[];var s,o,u,a=n[t],f=a&&a[r];return!f||(s=f.result,e.Lang.isUndefined(s)&&(o=f.ua,o&&(s=e.UA[o]),u=f.test,u&&(!o||s)&&(s=u.apply(e,i)),f.result=s)),s}});var r=e.Features.add;r("load","0",{name:"app-transitions-native",test:function(e){var t=e.config.doc,n=t?t.documentElement:null;return n&&n.style?"MozTransition"in n.style||"WebkitTransition"in n.style||"transition"in n.style:!1},trigger:"app-transitions"}),r("load","1",{name:"autocomplete-list-keys",test:function(e){return!e.UA.ios&&!e.UA.android},trigger:"autocomplete-list"}),r("load","2",{name:"dd-gestures",trigger:"dd-drag",ua:"touchEnabled"}),r("load","3",{name:"dom-style-ie",test:function(e){var t=e.Features.test,n=e.Features.add,r=e.c
 onfig.win,i=e.config.doc,s="documentElement",o=!1;return n("style","computedStyle",{test:function(){return r&&"getComputedStyle"in r}}),n("style","opacity",{test:function(){return i&&"opacity"in i[s].style}}),o=!t("style","opacity")&&!t("style","computedStyle"),o},trigger:"dom-style"}),r("load","4",{name:"editor-para-ie",trigger:"editor-para",ua:"ie",when:"instead"}),r("load","5",{name:"event-base-ie",test:function(e){var t=e.config.doc&&e.config.doc.implementation;return t&&!t.hasFeature("Events","2.0")},trigger:"node-base"}),r("load","6",{name:"graphics-canvas",test:function(e){var t=e.config.doc,n=e.config.defaultGraphicEngine&&e.config.defaultGraphicEngine=="canvas",r=t&&t.createElement("canvas"),i=t&&t.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure","1.1");return(!i||n)&&r&&r.getContext&&r.getContext("2d")},trigger:"graphics"}),r("load","7",{name:"graphics-canvas-default",test:function(e){var t=e.config.doc,n=e.config.defaultGraphicEngine&&e.config
 .defaultGraphicEngine=="canvas",r=t&&t.createElement("canvas"),i=t&&t.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure","1.1");return(!i||n)&&r&&r.getContext&&r.getContext("2d")},trigger:"graphics"}),r("load","8",{name:"graphics-svg",test:function(e){var t=e.config.doc,n=!e.config.defaultGraphicEngine||e.config.defaultGraphicEngine!="canvas",r=t&&t.createElement("canvas"),i=t&&t.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure","1.1");return i&&(n||!r)},trigger:"graphics"}),r("load","9",{name:"graphics-svg-default",test:function(e){var t=e.config.doc,n=!e.config.defaultGraphicEngine||e.config.defaultGraphicEngine!="canvas",r=t&&t.createElement("canvas"),i=t&&t.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure","1.1");return i&&(n||!r)},trigger:"graphics"}),r("load","10",{name:"graphics-vml",test:function(e){var t=e.config.doc,n=t&&t.createElement("canvas");return t&&!t.implementation.hasFeature("http:
 //www.w3.org/TR/SVG11/feature#BasicStructure","1.1")&&(!n||!n.getContext||!n.getContext("2d"))},trigger:"graphics"}),r("load","11",{name:"graphics-vml-default",test:function(e){var t=e.config.doc,n=t&&t.createElement("canvas");return t&&!t.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure","1.1")&&(!n||!n.getContext||!n.getContext("2d"))},trigger:"graphics"}),r("load","12",{name:"history-hash-ie",test:function(e){var t=e.config.doc&&e.config.doc.documentMode;return e.UA.ie&&(!("onhashchange"in e.config.win)||!t||t<8)},trigger:"history-hash"}),r("load","13",{name:"io-nodejs",trigger:"io-base",ua:"nodejs"}),r("load","14",{name:"json-parse-shim",test:function(e){function i(e,t){return e==="ok"?!0:t}var t=e.config.global.JSON,n=Object.prototype.toString.call(t)==="[object JSON]"&&t,r=e.config.useNativeJSONParse!==!1&&!!n;if(r)try{r=n.parse('{"ok":false}',i).ok}catch(s){r=!1}return!r},trigger:"json-parse"}),r("load","15",{name:"json-stringify-shim",test:functio
 n(e){var t=e.config.global.JSON,n=Object.prototype.toString.call(t)==="[object JSON]"&&t,r=e.config.useNativeJSONStringify!==!1&&!!n;if(r)try{r="0"===n.stringify(0)}catch(i){r=!1}return!r},trigger:"json-stringify"}),r("load","16",{name:"scrollview-base-ie",trigger:"scrollview-base",ua:"ie"}),r("load","17",{name:"selector-css2",test:function(e){var t=e.config.doc,n=t&&!("querySelectorAll"in t);return n},trigger:"selector"}),r("load","18",{name:"transition-timer",test:function(e){var t=e.config.doc,n=t?t.documentElement:null,r=!0;return n&&n.style&&(r=!("MozTransition"in n.style||"WebkitTransition"in n.style||"transition"in n.style)),r},trigger:"transition"}),r("load","19",{name:"widget-base-ie",trigger:"widget-base",ua:"ie"}),r("load","20",{name:"yql-jsonp",test:function(e){return!e.UA.nodejs&&!e.UA.winjs},trigger:"yql"}),r("load","21",{name:"yql-nodejs",trigger:"yql",ua:"nodejs"}),r("load","22",{name:"yql-winjs",trigger:"yql",ua:"winjs"})},"3.17.2",{requires:["yui-base"]});



Mime
View raw message