Proyectos de Subversion Moodle

YUI.add('uploader-flash', function (Y, NAME) {

/**

* This module provides a UI for file selection and multiple file upload capability using

* Flash as a transport engine.

* The supported features include: automatic upload queue management, upload progress

* tracking, file filtering, server response retrieval and error reporting.

*

* @module uploader-flash

* @deprecated

*/

// Shorthands for external modules

var substitute            = Y.Lang.sub,

    UploaderQueue         = Y.Uploader.Queue;

/**

 * Embed a Flash applications in a standard manner and communicate with it

 * via External Interface.

 * @module swf

 */

    var Event = Y.Event,

        SWFDetect = Y.SWFDetect,

        Lang = Y.Lang,

        uA = Y.UA,

        Node = Y.Node,

        Escape = Y.Escape,

        // private

        FLASH_CID = "clsid:d27cdb6e-ae6d-11cf-96b8-444553540000",

        FLASH_TYPE = "application/x-shockwave-flash",

        FLASH_VER = "10.0.22",

        EXPRESS_INSTALL_URL = "http://fpdownload.macromedia.com/pub/flashplayer/update/current/swf/autoUpdater.swf?" + Math.random(),

        EVENT_HANDLER = "SWF.eventHandler",

        possibleAttributes = {align:"", allowFullScreen:"", allowNetworking:"", allowScriptAccess:"", base:"", bgcolor:"", loop:"", menu:"", name:"", play: "", quality:"", salign:"", scale:"", tabindex:"", wmode:""};

        /**

         * The SWF utility is a tool for embedding Flash applications in HTML pages.

         * @module swf

         * @title SWF Utility

         * @requires event-custom, node, swfdetect

         */

        /**

         * Creates the SWF instance and keeps the configuration data

         *

         * @class SWF

         * @uses Y.Event.Target

         * @constructor

         * @param {String|HTMLElement} id The id of the element, or the element itself that the SWF will be inserted into.

         *        The width and height of the SWF will be set to the width and height of this container element.

         * @param {String} swfURL The URL of the SWF to be embedded into the page.

         * @param {Object} p_oAttributes (optional) Configuration parameters for the Flash application and values for Flashvars

         *        to be passed to the SWF. The p_oAttributes object allows the following additional properties:

         *        <dl>

         *          <dt>version : String</dt>

         *          <dd>The minimum version of Flash required on the user's machine.</dd>

         *          <dt>fixedAttributes : Object</dt>

         *          <dd>An object literal containing one or more of the following String keys and their values: <code>align,

         *              allowFullScreen, allowNetworking, allowScriptAccess, base, bgcolor, menu, name, quality, salign, scale,

         *              tabindex, wmode.</code> event from the thumb</dd>

         *        </dl>

         */

function SWF (p_oElement /*:String*/, swfURL /*:String*/, p_oAttributes /*:Object*/ ) {

    this._id = Y.guid("yuiswf");

    var _id = this._id;

    var oElement = Node.one(p_oElement);

    var p_oAttributes = p_oAttributes || {};

    var flashVersion = p_oAttributes.version || FLASH_VER;

    var flashVersionSplit = (flashVersion + '').split(".");

    var isFlashVersionRight = SWFDetect.isFlashVersionAtLeast(parseInt(flashVersionSplit[0], 10), parseInt(flashVersionSplit[1], 10), parseInt(flashVersionSplit[2], 10));

    var canExpressInstall = (SWFDetect.isFlashVersionAtLeast(8,0,0));

    var shouldExpressInstall = canExpressInstall && !isFlashVersionRight && p_oAttributes.useExpressInstall;

    var flashURL = (shouldExpressInstall)?EXPRESS_INSTALL_URL:swfURL;

    var objstring = '<object ';

    var w, h;

    var flashvarstring = "yId=" + Y.id + "&YUISwfId=" + _id + "&YUIBridgeCallback=" + EVENT_HANDLER + "&allowedDomain=" + document.location.hostname;

    Y.SWF._instances[_id] = this;

    if (oElement && (isFlashVersionRight || shouldExpressInstall) && flashURL) {

        objstring += 'id="' + _id + '" ';

        if (uA.ie) {

            objstring += 'classid="' + FLASH_CID + '" ';

        } else {

            objstring += 'type="' + FLASH_TYPE + '" data="' + Escape.html(flashURL) + '" ';

        }

        w = "100%";

        h = "100%";

        objstring += 'width="' + w + '" height="' + h + '">';

        if (uA.ie) {

            objstring += '<param name="movie" value="' + Escape.html(flashURL) + '"/>';

        }

        for (var attribute in p_oAttributes.fixedAttributes) {

            if (possibleAttributes.hasOwnProperty(attribute)) {

                objstring += '<param name="' + Escape.html(attribute) + '" value="' + Escape.html(p_oAttributes.fixedAttributes[attribute]) + '"/>';

            }

        }

        for (var flashvar in p_oAttributes.flashVars) {

            var fvar = p_oAttributes.flashVars[flashvar];

            if (Lang.isString(fvar)) {

                flashvarstring += "&" + Escape.html(flashvar) + "=" + Escape.html(encodeURIComponent(fvar));

            }

        }

        if (flashvarstring) {

            objstring += '<param name="flashVars" value="' + flashvarstring + '"/>';

        }

        objstring += "</object>";

        //using innerHTML as setHTML/setContent causes some issues with ExternalInterface for IE versions of the player

        oElement.set("innerHTML", objstring);

        this._swf = Node.one("#" + _id);

    } else {

        /**

         * Fired when the Flash player version on the user's machine is

         * below the required value.

         *

         * @event wrongflashversion

         */

        var event = {};

        event.type = "wrongflashversion";

        this.publish("wrongflashversion", {fireOnce:true});

        this.fire("wrongflashversion", event);

    }

}

/**

 * @private

 * The static collection of all instances of the SWFs on the page.

 * @property _instances

 * @type Object

 */

SWF._instances = SWF._instances || {};

/**

 * @private

 * Handles an event coming from within the SWF and delegate it

 * to a specific instance of SWF.

 * @method eventHandler

 * @param swfid {String} the id of the SWF dispatching the event

 * @param event {Object} the event being transmitted.

 */

SWF.eventHandler = function (swfid, event) {

    SWF._instances[swfid]._eventHandler(event);

};

SWF.prototype = {

    /**

     * @private

     * Propagates a specific event from Flash to JS.

     * @method _eventHandler

     * @param event {Object} The event to be propagated from Flash.

     */

    _eventHandler: function(event) {

        if (event.type === "swfReady") {

            this.publish("swfReady", {fireOnce:true});

            this.fire("swfReady", event);

        } else if(event.type === "log") {

        } else {

            this.fire(event.type, event);

        }

    },

        /**

     * Calls a specific function exposed by the SWF's

     * ExternalInterface.

     * @method callSWF

     * @param func {String} the name of the function to call

     * @param args {Array} the set of arguments to pass to the function.

     */

    callSWF: function (func, args)

    {

    if (!args) {

          args= [];

    }

        if (this._swf._node[func]) {

        return(this._swf._node[func].apply(this._swf._node, args));

        } else {

        return null;

        }

    },

    /**

     * Public accessor to the unique name of the SWF instance.

     *

     * @method toString

     * @return {String} Unique name of the SWF instance.

     */

    toString: function()

    {

        return "SWF " + this._id;

    }

};

Y.augment(SWF, Y.EventTarget);

Y.SWF = SWF;

    /**

     * The FileFlash class provides a wrapper for a file pointer stored in Flash. The File wrapper

     * also implements the mechanics for uploading a file and tracking its progress.

     * @module file-flash

     */

    /**

     * The class provides a wrapper for a file pointer in Flash.

     * @class FileFlash

     * @extends Base

     * @constructor

     * @param {Object} config Configuration object.

     */

    var FileFlash = function(o) {

        FileFlash.superclass.constructor.apply(this, arguments);

    };

    Y.extend(FileFlash, Y.Base, {

       /**

        * Construction logic executed during FileFlash instantiation.

        *

        * @method initializer

        * @protected

        */

        initializer : function (cfg) {

            if (!this.get("id")) {

                this._set("id", Y.guid("file"));

            }

        },

       /**

        * Handler of events dispatched by the Flash player.

        *

        * @method _swfEventHandler

        * @param {Event} event The event object received from the Flash player.

        * @protected

        */

        _swfEventHandler: function (event) {

          if (event.id === this.get("id")) {

          switch (event.type) {

            /**

             * Signals that this file's upload has started.

             *

             * @event uploadstart

             * @param event {Event} The event object for the `uploadstart` with the

             *                      following payload:

             *  <dl>

             *      <dt>uploader</dt>

             *          <dd>The Y.SWF instance of Flash uploader that's handling the upload.</dd>

             *  </dl>

             */

            case "uploadstart":

                 this.fire("uploadstart", {uploader: this.get("uploader")});

                 break;

            case "uploadprogress":

                  /**

                   * Signals that progress has been made on the upload of this file.

                   *

                   * @event uploadprogress

                   * @param event {Event} The event object for the `uploadprogress` with the

                   *                      following payload:

                   *  <dl>

                   *      <dt>originEvent</dt>

                   *          <dd>The original event fired by the Flash uploader instance.</dd>

                   *      <dt>bytesLoaded</dt>

                   *          <dd>The number of bytes of the file that has been uploaded.</dd>

                   *      <dt>bytesTotal</dt>

                   *          <dd>The total number of bytes in the file (the file size)</dd>

                   *      <dt>percentLoaded</dt>

                   *          <dd>The fraction of the file that has been uploaded, out of 100.</dd>

                   *  </dl>

                   */

                 this.fire("uploadprogress", {originEvent: event,

                                              bytesLoaded: event.bytesLoaded,

                                              bytesTotal: event.bytesTotal,

                                              percentLoaded: Math.min(100, Math.round(10000*event.bytesLoaded/event.bytesTotal)/100)

                                             });

                 this._set("bytesUploaded", event.bytesLoaded);

                 break;

            case "uploadcomplete":

                  /**

                   * Signals that this file's upload has completed, but data has not yet been received from the server.

                   *

                   * @event uploadfinished

                   * @param event {Event} The event object for the `uploadfinished` with the

                   *                      following payload:

                   *  <dl>

                   *      <dt>originEvent</dt>

                   *          <dd>The original event fired by the Flash player instance.</dd>

                   *  </dl>

                   */

                 this.fire("uploadfinished", {originEvent: event});

                 break;

            case "uploadcompletedata":

                /**

                 * Signals that this file's upload has completed and data has been received from the server.

                 *

                 * @event uploadcomplete

                 * @param event {Event} The event object for the `uploadcomplete` with the

                 *                      following payload:

                 *  <dl>

                 *      <dt>originEvent</dt>

                 *          <dd>The original event fired by the Flash player instance.</dd>

                 *      <dt>data</dt>

                 *          <dd>The data returned by the server.</dd>

                 *  </dl>

                 */

                 this.fire("uploadcomplete", {originEvent: event,

                                              data: event.data});

                 break;

            case "uploadcancel":

                /**

                 * Signals that this file's upload has been cancelled.

                 *

                 * @event uploadcancel

                 * @param event {Event} The event object for the `uploadcancel` with the

                 *                      following payload:

                 *  <dl>

                 *      <dt>originEvent</dt>

                 *          <dd>The original event fired by the Flash player instance.</dd>

                 *  </dl>

                 */

                 this.fire("uploadcancel", {originEvent: event});

                 break;

            case "uploaderror":

                /**

                 * Signals that this file's upload has encountered an error.

                 *

                 * @event uploaderror

                 * @param event {Event} The event object for the `uploaderror` with the

                 *                      following payload:

                 *  <dl>

                 *      <dt>originEvent</dt>

                 *          <dd>The original event fired by the Flash player instance.</dd>

                 *      <dt>status</dt>

                 *          <dd>The status code reported by the Flash Player. If it's an HTTP error,

                 *                then this corresponds to the HTTP status code received by the uploader.</dd>

                 *      <dt>statusText</dt>

                 *          <dd>The text of the error event reported by the Flash Player.</dd>

                 *      <dt>source</dt>

                 *          <dd>Either "http" (if it's an HTTP error), or "io" (if it's a network transmission

                 *              error.)</dd>

                 *  </dl>

                 */

                 this.fire("uploaderror", {originEvent: event, status: event.status, statusText: event.message, source: event.source});

          }

        }

        },

       /**

        * Starts the upload of a specific file.

        *

        * @method startUpload

        * @param url {String} The URL to upload the file to.

        * @param parameters {Object} (optional) A set of key-value pairs to send as variables along with the file upload HTTP request.

        * @param fileFieldName {String} (optional) The name of the POST variable that should contain the uploaded file ('Filedata' by default)

        */

        startUpload: function(url, parameters, fileFieldName) {

        if (this.get("uploader")) {

            var myUploader = this.get("uploader"),

                fileField = fileFieldName || "Filedata",

                id = this.get("id"),

                params = parameters || null;

            this._set("bytesUploaded", 0);

            myUploader.on("uploadstart", this._swfEventHandler, this);

            myUploader.on("uploadprogress", this._swfEventHandler, this);

            myUploader.on("uploadcomplete", this._swfEventHandler, this);

            myUploader.on("uploadcompletedata", this._swfEventHandler, this);

            myUploader.on("uploaderror", this._swfEventHandler, this);

            myUploader.callSWF("upload", [id, url, params, fileField]);

         }

        },

       /**

        * Cancels the upload of a specific file, if currently in progress.

        *

        * @method cancelUpload

        */

        cancelUpload: function () {

         if (this.get("uploader")) {

           this.get("uploader").callSWF("cancel", [this.get("id")]);

           this.fire("uploadcancel");

         }

        }

    }, {

       /**

        * The identity of the class.

        *

        * @property NAME

        * @type String

        * @default 'file'

        * @readOnly

        * @protected

        * @static

        */

        NAME: 'file',

       /**

        * The type of transport.

        *

        * @property TYPE

        * @type String

        * @default 'flash'

        * @readOnly

        * @protected

        * @static

        */

        TYPE: "flash",

       /**

        * Static property used to define the default attribute configuration of

        * the File.

        *

        * @property ATTRS

        * @type {Object}

        * @protected

        * @static

        */

        ATTRS: {

       /**

        * A String containing the unique id of the file wrapped by the FileFlash instance.

        * The id is supplied by the Flash player uploader.

        *

        * @attribute id

        * @type {String}

        * @initOnly

        */

        id: {

            writeOnce: "initOnly",

            value: null

        },

       /**

        * The size of the file wrapped by FileFlash. This value is supplied by the Flash player uploader.

        *

        * @attribute size

        * @type {Number}

        * @initOnly

        */

        size: {

            writeOnce: "initOnly",

            value: 0

        },

       /**

        * The name of the file wrapped by FileFlash. This value is supplied by the Flash player uploader.

        *

        * @attribute name

        * @type {String}

        * @initOnly

        */

        name: {

            writeOnce: "initOnly",

            value: null

        },

       /**

        * The date that the file wrapped by FileFlash was created on. This value is supplied by the Flash player uploader.

        *

        * @attribute dateCreated

        * @type {Date}

        * @initOnly

        */

        dateCreated: {

            writeOnce: "initOnly",

            value: null

        },

       /**

        * The date that the file wrapped by FileFlash was last modified on. This value is supplied by the Flash player uploader.

        *

        * @attribute dateModified

        * @type {Date}

        * @initOnly

        */

        dateModified: {

            writeOnce: "initOnly",

            value: null

        },

       /**

        * The number of bytes of the file that has been uploaded to the server. This value is

        * non-zero only while a file is being uploaded.

        *

        * @attribute bytesUploaded

        * @type {Date}

        * @readOnly

        */

        bytesUploaded: {

            readOnly: true,

            value: 0

        },

       /**

        * The type of the file wrapped by FileFlash. This value is provided by the Flash player

        * uploader.

        *

        * @attribute type

        * @type {String}

        * @initOnly

        */

        type: {

            writeOnce: "initOnly",

            value: null

        },

       /**

        * The instance of Y.SWF wrapping the Flash player uploader associated with this file.

        *

        * @attribute uploder

        * @type {SWF}

        * @initOnly

        */

        uploader: {

            writeOnce: "initOnly",

            value: null

        }

        }

    });

    Y.FileFlash = FileFlash;

/**

* This module provides a UI for file selection and multiple file upload capability

* using Flash as a transport engine.

* @class UploaderFlash

* @extends Widget

* @param {Object} config Configuration object.

* @constructor

* @deprecated

*/

function UploaderFlash() {

    UploaderFlash.superclass.constructor.apply ( this, arguments );

}

Y.UploaderFlash = Y.extend(UploaderFlash, Y.Widget, {

    /**

    * Stored value of the current button state (based on

    * mouse events dispatched by the Flash player)

    * @property _buttonState

    * @type {String}

    * @protected

    */

    _buttonState: "up",

    /**

    * Stored value of the current button focus state (based

    * on keyboard and mouse events).

    * @property _buttonFocus

    * @type {Boolean}

    * @protected

    */

    _buttonFocus: false,

    /**

    * Stored value of the unique id for the container that holds the

    * Flash uploader.

    *

    * @property _swfContainerId

    * @type {String}

    * @protected

    */

    _swfContainerId: null,

    /**

    * Stored reference to the instance of SWF used to host the

    * Flash uploader.

    *

    * @property _swfReference

    * @type {SWF}

    * @protected

    */

    _swfReference: null,

    /**

    * Stored reference to the instance of Uploader.Queue used to manage

    * the upload process. This is a read-only property that only exists

    * during an active upload process. Only one queue can be active at

    * a time; if an upload start is attempted while a queue is active,

    * it will be ignored.

    *

    * @property queue

    * @type {Uploader.Queue}

    */

    queue: null,

    /**

    * Stored event bindings for keyboard navigation to and from the uploader.

    *

    * @property _tabElementBindings

    * @type {Object}

    * @protected

    */

    _tabElementBindings: null,

    /**

    * Construction logic executed during UploaderFlash instantiation.

    *

    * @method initializer

    * @protected

    */

    initializer : function () {

        // Assign protected variable values

        this._swfContainerId = Y.guid("uploader");

        this._swfReference = null;

        this.queue = null;

        this._buttonState = "up";

        this._buttonFocus = null;

        this._tabElementBindings = null;

        this._fileList = [];

        // Publish available events

        /**

        * Signals that files have been selected.

        *

        * @event fileselect

        * @param event {Event} The event object for the `fileselect` with the

        *                      following payload:

        *  <dl>

        *      <dt>fileList</dt>

        *          <dd>An `Array` of files selected by the user, encapsulated

        *              in Y.FileFlash objects.</dd>

        *  </dl>

        */

        this.publish("fileselect");

        /**

        * Signals that an upload of multiple files has been started.

        *

        * @event uploadstart

        * @param event {Event} The event object for the `uploadstart`.

        */

        this.publish("uploadstart");

        /**

        * Signals that an upload of a specific file has started.

        *

        * @event fileuploadstart

        * @param event {Event} The event object for the `fileuploadstart` with the

        *                      following payload:

        *  <dl>

        *      <dt>file</dt>

        *          <dd>A reference to the Y.File that dispatched the event.</dd>

        *      <dt>originEvent</dt>

        *          <dd>The original event dispatched by Y.File.</dd>

        *  </dl>

        */

        this.publish("fileuploadstart");

        /**

        * Reports on upload progress of a specific file.

        *

        * @event uploadprogress

        * @param event {Event} The event object for the `uploadprogress` with the

        *                      following payload:

        *  <dl>

        *      <dt>bytesLoaded</dt>

        *          <dd>The number of bytes of the file that has been uploaded</dd>

        *      <dt>bytesTotal</dt>

        *          <dd>The total number of bytes in the file</dd>

        *      <dt>percentLoaded</dt>

        *          <dd>The fraction of the file that has been uploaded, out of 100</dd>

        *      <dt>originEvent</dt>

        *          <dd>The original event dispatched by the SWF uploader</dd>

        *  </dl>

        */

        this.publish("uploadprogress");

        /**

        * Reports on the total upload progress of the file list.

        *

        * @event totaluploadprogress

        * @param event {Event} The event object for the `totaluploadprogress` with the

        *                      following payload:

        *  <dl>

        *      <dt>bytesLoaded</dt>

        *          <dd>The number of bytes of the file list that has been uploaded</dd>

        *      <dt>bytesTotal</dt>

        *          <dd>The total number of bytes in the file list</dd>

        *      <dt>percentLoaded</dt>

        *          <dd>The fraction of the file list that has been uploaded, out of 100</dd>

        *  </dl>

        */

        this.publish("totaluploadprogress");

        /**

        * Signals that a single file upload has been completed.

        *

        * @event uploadcomplete

        * @param event {Event} The event object for the `uploadcomplete` with the

        *                      following payload:

        *  <dl>

        *      <dt>file</dt>

        *          <dd>The pointer to the instance of `Y.File` whose upload has been completed.</dd>

        *      <dt>originEvent</dt>

        *          <dd>The original event fired by the SWF Uploader</dd>

        *      <dt>data</dt>

        *          <dd>Data returned by the server.</dd>

        *  </dl>

        */

        this.publish("uploadcomplete");

        /**

        * Signals that the upload process of the entire file list has been completed.

        *

        * @event alluploadscomplete

        * @param event {Event} The event object for the `alluploadscomplete`.

        */

        this.publish("alluploadscomplete");

        /**

        * Signals that a error has occurred in a specific file's upload process.

        *

        * @event uploaderror

        * @param event {Event} The event object for the `uploaderror` with the

        *                      following payload:

        *  <dl>

        *      <dt>originEvent</dt>

        *          <dd>The original error event fired by the SWF Uploader. </dd>

        *      <dt>file</dt>

        *          <dd>The pointer at the instance of Y.FileFlash that returned the error.</dd>

        *      <dt>source</dt>

        *          <dd>The source of the upload error, either "io" or "http"</dd>

        *      <dt>message</dt>

        *          <dd>The message that accompanied the error. Corresponds to the text of

        *              the error in cases where source is "io", and to the HTTP status for

                                     cases where source is "http".</dd>

        *  </dl>

        */

        this.publish("uploaderror");

        /**

        * Signals that a mouse has begun hovering over the `Select Files` button.

        *

        * @event mouseenter

        * @param event {Event} The event object for the `mouseenter` event.

        */

        this.publish("mouseenter");

        /**

        * Signals that a mouse has stopped hovering over the `Select Files` button.

        *

        * @event mouseleave

        * @param event {Event} The event object for the `mouseleave` event.

        */

        this.publish("mouseleave");

        /**

        * Signals that a mouse button has been pressed over the `Select Files` button.

        *

        * @event mousedown

        * @param event {Event} The event object for the `mousedown` event.

        */

        this.publish("mousedown");

        /**

        * Signals that a mouse button has been released over the `Select Files` button.

        *

        * @event mouseup

        * @param event {Event} The event object for the `mouseup` event.

        */

        this.publish("mouseup");

        /**

        * Signals that a mouse has been clicked over the `Select Files` button.

        *

        * @event click

        * @param event {Event} The event object for the `click` event.

        */

        this.publish("click");

    },

    /**

    * Creates the DOM structure for the UploaderFlash.

    * UploaderFlash's DOM structure consists of two layers: the base "Select Files"

    * button that can be replaced by the developer's widget of choice; and a transparent

    * Flash overlay positoned above the button that captures all input events.

    * The `position` style attribute of the `boundingBox` of the `Uploader` widget

    * is forced to be `relative`, in order to accommodate the Flash player overlay

    * (which is `position`ed `absolute`ly).

    *

    * @method renderUI

    * @protected

    */

    renderUI : function () {

        var boundingBox = this.get("boundingBox"),

            contentBox = this.get('contentBox'),

            selFilesButton = this.get("selectFilesButton"),

            flashContainer = Y.Node.create(substitute(UploaderFlash.FLASH_CONTAINER, {

                swfContainerId: this._swfContainerId

            })),

            params = {

                version: "10.0.45",

                fixedAttributes: {

                    wmode: "transparent",

                    allowScriptAccess:"always",

                    allowNetworking:"all",

                    scale: "noscale"

                }

            };

        boundingBox.setStyle("position", "relative");

        selFilesButton.setStyles({width: "100%", height: "100%"});

        contentBox.append(selFilesButton);

        contentBox.append(flashContainer);

        this._swfReference = new Y.SWF(flashContainer, this.get("swfURL"), params);

    },

    /**

    * Binds handlers to the UploaderFlash UI events and propagates attribute

    * values to the Flash player.

    * The propagation of initial values is set to occur once the Flash player

    * instance is ready (as indicated by the `swfReady` event.)

    *

    * @method bindUI

    * @protected

    */

    bindUI : function () {

        this._swfReference.on("swfReady", function () {

            this._setMultipleFiles();

            this._setFileFilters();

            this._triggerEnabled();

            this._attachTabElements();

            this.after("multipleFilesChange", this._setMultipleFiles, this);

            this.after("fileFiltersChange", this._setFileFilters, this);

            this.after("enabledChange", this._triggerEnabled, this);

            this.after("tabElementsChange", this._attachTabElements);

        }, this);

        this._swfReference.on("fileselect", this._updateFileList, this);

        // this._swfReference.on("trace", function (ev) {console.log(ev.message);});

        this._swfReference.on("mouseenter", function () {

            this.fire("mouseenter");

            this._setButtonClass("hover", true);

            if (this._buttonState === "down") {

                this._setButtonClass("active", true);

            }

        }, this);

        this._swfReference.on("mouseleave", function () {

            this.fire("mouseleave");

            this._setButtonClass("hover", false);

            this._setButtonClass("active", false);

        }, this);

        this._swfReference.on("mousedown", function () {

            this.fire("mousedown");

            this._buttonState = "down";

            this._setButtonClass("active", true);

        }, this);

        this._swfReference.on("mouseup", function () {

            this.fire("mouseup");

            this._buttonState = "up";

            this._setButtonClass("active", false);

        }, this);

        this._swfReference.on("click", function () {

            this.fire("click");

            this._buttonFocus = true;

            this._setButtonClass("focus", true);

            Y.one("body").focus();

            this._swfReference._swf.focus();

        }, this);

    },

    /**

    * Attaches keyboard bindings to enabling tabbing to and from the instance of the Flash

    * player in the Uploader widget. If the previous and next elements are specified, the

    * keyboard bindings enable the user to tab from the `tabElements["from"]` node to the

    * Flash-powered "Select Files" button, and to the `tabElements["to"]` node.

    *

    * @method _attachTabElements

    * @protected

    * @param ev {Event} Optional event payload if called as a `tabElementsChange` handler.

    */

    _attachTabElements : function () {

        if (this.get("tabElements") !== null && this.get("tabElements").from !== null && this.get("tabElements").to !== null) {

            if (this._tabElementBindings !== null) {

                this._tabElementBindings.from.detach();

                this._tabElementBindings.to.detach();

                this._tabElementBindings.tabback.detach();

                this._tabElementBindings.tabforward.detach();

                this._tabElementBindings.focus.detach();

                this._tabElementBindings.blur.detach();

            }

            else {

                this._tabElementBindings = {};

            }

            var fromElement = Y.one(this.get("tabElements").from),

                toElement = Y.one(this.get("tabElements").to);

            this._tabElementBindings.from = fromElement.on("keydown", function (ev) {

                if (ev.keyCode === 9 && !ev.shiftKey) {

                    ev.preventDefault();

                    this._swfReference._swf.setAttribute("tabindex", 0);

                    this._swfReference._swf.setAttribute("role", "button");

                    this._swfReference._swf.setAttribute("aria-label", this.get("selectButtonLabel"));

                    this._swfReference._swf.focus();

                }

            }, this);

            this._tabElementBindings.to = toElement.on("keydown", function (ev) {

                if (ev.keyCode === 9 && ev.shiftKey) {

                    ev.preventDefault();

                    this._swfReference._swf.setAttribute("tabindex", 0);

                    this._swfReference._swf.setAttribute("role", "button");

                    this._swfReference._swf.setAttribute("aria-label", this.get("selectButtonLabel"));

                    this._swfReference._swf.focus();

                }

            }, this);

            this._tabElementBindings.tabback = this._swfReference.on("tabback", function () {

                this._swfReference._swf.blur();

                setTimeout(function () {

                    fromElement.focus();

                }, 30);

            }, this);

            this._tabElementBindings.tabforward = this._swfReference.on("tabforward", function () {

                this._swfReference._swf.blur();

                setTimeout(function () {

                    toElement.focus();

                }, 30);

            }, this);

            this._tabElementBindings.focus = this._swfReference._swf.on("focus", function () {

                this._buttonFocus = true;

                this._setButtonClass("focus", true);

            }, this);

            this._tabElementBindings.blur = this._swfReference._swf.on("blur", function () {

                this._buttonFocus = false;

                this._setButtonClass("focus", false);

            }, this);

        }

        else if (this._tabElementBindings !== null) {

            this._tabElementBindings.from.detach();

            this._tabElementBindings.to.detach();

            this._tabElementBindings.tabback.detach();

            this._tabElementBindings.tabforward.detach();

            this._tabElementBindings.focus.detach();

            this._tabElementBindings.blur.detach();

        }

    },

    /**

    * Adds or removes a specified state CSS class to the underlying uploader button.

    *

    * @method _setButtonClass

    * @protected

    * @param state {String} The name of the state enumerated in `buttonClassNames` attribute

    * from which to derive the needed class name.

    * @param add {Boolean} A Boolean indicating whether to add or remove the class.

    */

    _setButtonClass : function (state, add) {

        if (add) {