You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1618 lines
54 KiB
1618 lines
54 KiB
/*
|
|
YUI 3.17.2 (build 9c3c78e)
|
|
Copyright 2014 Yahoo! Inc. All rights reserved.
|
|
Licensed under the BSD License.
|
|
http://yuilibrary.com/license/
|
|
*/
|
|
|
|
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) {
|
|
this.get("selectFilesButton").addClass(this.get("buttonClassNames")[state]);
|
|
}
|
|
else {
|
|
this.get("selectFilesButton").removeClass(this.get("buttonClassNames")[state]);
|
|
}
|
|
},
|
|
|
|
|
|
/**
|
|
* Syncs the state of the `fileFilters` attribute between the instance of UploaderFlash
|
|
* and the Flash player.
|
|
*
|
|
* @method _setFileFilters
|
|
* @private
|
|
*/
|
|
_setFileFilters : function () {
|
|
if (this._swfReference && this.get("fileFilters").length > 0) {
|
|
this._swfReference.callSWF("setFileFilters", [this.get("fileFilters")]);
|
|
}
|
|
},
|
|
|
|
|
|
|
|
/**
|
|
* Syncs the state of the `multipleFiles` attribute between this class
|
|
* and the Flash uploader.
|
|
*
|
|
* @method _setMultipleFiles
|
|
* @private
|
|
*/
|
|
_setMultipleFiles : function () {
|
|
if (this._swfReference) {
|
|
this._swfReference.callSWF("setAllowMultipleFiles", [this.get("multipleFiles")]);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Syncs the state of the `enabled` attribute between this class
|
|
* and the Flash uploader.
|
|
*
|
|
* @method _triggerEnabled
|
|
* @private
|
|
*/
|
|
_triggerEnabled : function () {
|
|
if (this.get("enabled")) {
|
|
this._swfReference.callSWF("enable");
|
|
this._swfReference._swf.setAttribute("aria-disabled", "false");
|
|
this._setButtonClass("disabled", false);
|
|
}
|
|
else {
|
|
this._swfReference.callSWF("disable");
|
|
this._swfReference._swf.setAttribute("aria-disabled", "true");
|
|
this._setButtonClass("disabled", true);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Getter for the `fileList` attribute
|
|
*
|
|
* @method _getFileList
|
|
* @private
|
|
*/
|
|
_getFileList : function () {
|
|
return this._fileList.concat();
|
|
},
|
|
|
|
/**
|
|
* Setter for the `fileList` attribute
|
|
*
|
|
* @method _setFileList
|
|
* @private
|
|
*/
|
|
_setFileList : function (val) {
|
|
this._fileList = val.concat();
|
|
return this._fileList.concat();
|
|
},
|
|
|
|
/**
|
|
* Adjusts the content of the `fileList` based on the results of file selection
|
|
* and the `appendNewFiles` attribute. If the `appendNewFiles` attribute is true,
|
|
* then selected files are appended to the existing list; otherwise, the list is
|
|
* cleared and populated with the newly selected files.
|
|
*
|
|
* @method _updateFileList
|
|
* @param ev {Event} The file selection event received from the uploader.
|
|
* @private
|
|
*/
|
|
_updateFileList : function (ev) {
|
|
|
|
Y.one("body").focus();
|
|
this._swfReference._swf.focus();
|
|
|
|
|
|
var newfiles = ev.fileList,
|
|
fileConfObjects = [],
|
|
parsedFiles = [],
|
|
swfRef = this._swfReference,
|
|
filterFunc = this.get("fileFilterFunction"),
|
|
oldfiles;
|
|
|
|
Y.each(newfiles, function (value) {
|
|
var newFileConf = {};
|
|
newFileConf.id = value.fileId;
|
|
newFileConf.name = value.fileReference.name;
|
|
newFileConf.size = value.fileReference.size;
|
|
newFileConf.type = value.fileReference.type;
|
|
newFileConf.dateCreated = value.fileReference.creationDate;
|
|
newFileConf.dateModified = value.fileReference.modificationDate;
|
|
newFileConf.uploader = swfRef;
|
|
|
|
fileConfObjects.push(newFileConf);
|
|
});
|
|
|
|
if (filterFunc) {
|
|
Y.each(fileConfObjects, function (value) {
|
|
var newfile = new Y.FileFlash(value);
|
|
if (filterFunc(newfile)) {
|
|
parsedFiles.push(newfile);
|
|
}
|
|
});
|
|
}
|
|
else {
|
|
Y.each(fileConfObjects, function (value) {
|
|
parsedFiles.push(new Y.FileFlash(value));
|
|
});
|
|
}
|
|
|
|
if (parsedFiles.length > 0) {
|
|
oldfiles = this.get("fileList");
|
|
|
|
this.set("fileList",
|
|
this.get("appendNewFiles") ? oldfiles.concat(parsedFiles) : parsedFiles );
|
|
|
|
this.fire("fileselect", { fileList: parsedFiles });
|
|
}
|
|
|
|
},
|
|
|
|
|
|
|
|
/**
|
|
* Handles and retransmits events fired by `Y.FileFlash` and `Y.Uploader.Queue`.
|
|
*
|
|
* @method _uploadEventHandler
|
|
* @param event The event dispatched during the upload process.
|
|
* @private
|
|
*/
|
|
_uploadEventHandler : function (event) {
|
|
|
|
switch (event.type) {
|
|
case "file:uploadstart":
|
|
this.fire("fileuploadstart", event);
|
|
break;
|
|
case "file:uploadprogress":
|
|
this.fire("uploadprogress", event);
|
|
break;
|
|
case "uploaderqueue:totaluploadprogress":
|
|
this.fire("totaluploadprogress", event);
|
|
break;
|
|
case "file:uploadcomplete":
|
|
this.fire("uploadcomplete", event);
|
|
break;
|
|
case "uploaderqueue:alluploadscomplete":
|
|
this.queue = null;
|
|
this.fire("alluploadscomplete", event);
|
|
break;
|
|
case "file:uploaderror": //overflow intentional
|
|
case "uploaderqueue:uploaderror":
|
|
this.fire("uploaderror", event);
|
|
break;
|
|
case "file:uploadcancel": // overflow intentional
|
|
case "uploaderqueue:uploadcancel":
|
|
this.fire("uploadcancel", event);
|
|
break;
|
|
}
|
|
|
|
},
|
|
|
|
|
|
|
|
/**
|
|
* Starts the upload of a specific file.
|
|
*
|
|
* @method upload
|
|
* @param file {FileFlash} Reference to the instance of the file to be uploaded.
|
|
* @param url {String} The URL to upload the file to.
|
|
* @param [postVars] {Object} A set of key-value pairs to send as variables along with the file upload HTTP request.
|
|
* If not specified, the values from the attribute `postVarsPerFile` are used instead.
|
|
*/
|
|
upload : function (file, url, postvars) {
|
|
|
|
var uploadURL = url || this.get("uploadURL"),
|
|
postVars = postvars || this.get("postVarsPerFile"),
|
|
fileId = file.get("id");
|
|
|
|
postVars = postVars.hasOwnProperty(fileId) ? postVars[fileId] : postVars;
|
|
|
|
if (file instanceof Y.FileFlash) {
|
|
|
|
file.on("uploadstart", this._uploadEventHandler, this);
|
|
file.on("uploadprogress", this._uploadEventHandler, this);
|
|
file.on("uploadcomplete", this._uploadEventHandler, this);
|
|
file.on("uploaderror", this._uploadEventHandler, this);
|
|
file.on("uploadcancel", this._uploadEventHandler, this);
|
|
|
|
file.startUpload(uploadURL, postVars, this.get("fileFieldName"));
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Starts the upload of all files on the file list, using an automated queue.
|
|
*
|
|
* @method uploadAll
|
|
* @param url {String} The URL to upload the files to.
|
|
* @param [postVars] {Object} A set of key-value pairs to send as variables along with the file upload HTTP request.
|
|
* If not specified, the values from the attribute `postVarsPerFile` are used instead.
|
|
*/
|
|
uploadAll : function (url, postvars) {
|
|
this.uploadThese(this.get("fileList"), url, postvars);
|
|
},
|
|
|
|
/**
|
|
* Starts the upload of the files specified in the first argument, using an automated queue.
|
|
*
|
|
* @method uploadThese
|
|
* @param files {Array} The list of files to upload.
|
|
* @param url {String} The URL to upload the files to.
|
|
* @param [postVars] {Object} A set of key-value pairs to send as variables along with the file upload HTTP request.
|
|
* If not specified, the values from the attribute `postVarsPerFile` are used instead.
|
|
*/
|
|
uploadThese : function (files, url, postvars) {
|
|
if (!this.queue) {
|
|
var uploadURL = url || this.get("uploadURL"),
|
|
postVars = postvars || this.get("postVarsPerFile");
|
|
|
|
this.queue = new UploaderQueue({
|
|
simUploads: this.get("simLimit"),
|
|
errorAction: this.get("errorAction"),
|
|
fileFieldName: this.get("fileFieldName"),
|
|
fileList: files,
|
|
uploadURL: uploadURL,
|
|
perFileParameters: postVars,
|
|
retryCount: this.get("retryCount")
|
|
});
|
|
|
|
this.queue.on("uploadstart", this._uploadEventHandler, this);
|
|
this.queue.on("uploadprogress", this._uploadEventHandler, this);
|
|
this.queue.on("totaluploadprogress", this._uploadEventHandler, this);
|
|
this.queue.on("uploadcomplete", this._uploadEventHandler, this);
|
|
this.queue.on("alluploadscomplete", this._uploadEventHandler, this);
|
|
this.queue.on("alluploadscancelled", function () {this.queue = null;}, this);
|
|
this.queue.on("uploaderror", this._uploadEventHandler, this);
|
|
this.queue.startUpload();
|
|
|
|
this.fire("uploadstart");
|
|
}
|
|
}
|
|
},
|
|
|
|
{
|
|
/**
|
|
* The template for the Flash player container. Since the Flash player container needs
|
|
* to completely overlay the &lquot;Select Files&rqot; control, it's positioned absolutely,
|
|
* with width and height set to 100% of the parent.
|
|
*
|
|
* @property FLASH_CONTAINER
|
|
* @type {String}
|
|
* @static
|
|
* @default '<div id="{swfContainerId}" style="position:absolute; top:0px; left: 0px; margin: 0; padding: 0;
|
|
* border: 0; width:100%; height:100%"></div>'
|
|
*/
|
|
FLASH_CONTAINER: '<div id="{swfContainerId}" style="position:absolute; top:0px; left: 0px; margin: 0; ' +
|
|
'padding: 0; border: 0; width:100%; height:100%"></div>',
|
|
|
|
/**
|
|
* The template for the "Select Files" button.
|
|
*
|
|
* @property SELECT_FILES_BUTTON
|
|
* @type {String}
|
|
* @static
|
|
* @default "<button type='button' class='yui3-button' tabindex='-1'>{selectButtonLabel}</button>"
|
|
*/
|
|
SELECT_FILES_BUTTON: "<button type='button' class='yui3-button' tabindex='-1'>{selectButtonLabel}</button>",
|
|
|
|
/**
|
|
* The static property reflecting the type of uploader that `Y.Uploader`
|
|
* aliases. The UploaderFlash value is `"flash"`.
|
|
*
|
|
* @property TYPE
|
|
* @type {String}
|
|
* @static
|
|
*/
|
|
TYPE: "flash",
|
|
|
|
/**
|
|
* The identity of the widget.
|
|
*
|
|
* @property NAME
|
|
* @type String
|
|
* @default 'uploader'
|
|
* @readOnly
|
|
* @protected
|
|
* @static
|
|
*/
|
|
NAME: "uploader",
|
|
|
|
/**
|
|
* Static property used to define the default attribute configuration of
|
|
* the Widget.
|
|
*
|
|
* @property ATTRS
|
|
* @type {Object}
|
|
* @protected
|
|
* @static
|
|
*/
|
|
ATTRS: {
|
|
|
|
/**
|
|
* A Boolean indicating whether newly selected files should be appended
|
|
* to the existing file list, or whether they should replace it.
|
|
*
|
|
* @attribute appendNewFiles
|
|
* @type {Boolean}
|
|
* @default true
|
|
*/
|
|
appendNewFiles : {
|
|
value: true
|
|
},
|
|
|
|
/**
|
|
* The names of CSS classes that correspond to different button states
|
|
* of the "Select Files" control. These classes are assigned to the
|
|
* "Select Files" control based on the mouse states reported by the
|
|
* Flash player. The keys for the class names are:
|
|
* <ul>
|
|
* <li> <strong>`hover`</strong>: the class corresponding to mouse hovering over
|
|
* the "Select Files" button.</li>
|
|
* <li> <strong>`active`</strong>: the class corresponding to mouse down state of
|
|
* the "Select Files" button.</li>
|
|
* <li> <strong>`disabled`</strong>: the class corresponding to the disabled state
|
|
* of the "Select Files" button.</li>
|
|
* <li> <strong>`focus`</strong>: the class corresponding to the focused state of
|
|
* the "Select Files" button.</li>
|
|
* </ul>
|
|
* @attribute buttonClassNames
|
|
* @type {Object}
|
|
* @default { hover: "yui3-button-hover",
|
|
* active: "yui3-button-active",
|
|
* disabled: "yui3-button-disabled",
|
|
* focus: "yui3-button-selected"
|
|
* }
|
|
*/
|
|
buttonClassNames: {
|
|
value: {
|
|
"hover": "yui3-button-hover",
|
|
"active": "yui3-button-active",
|
|
"disabled": "yui3-button-disabled",
|
|
"focus": "yui3-button-selected"
|
|
}
|
|
},
|
|
|
|
/**
|
|
* A Boolean indicating whether the uploader is enabled or disabled for user input.
|
|
*
|
|
* @attribute enabled
|
|
* @type {Boolean}
|
|
* @default true
|
|
*/
|
|
enabled : {
|
|
value: true
|
|
},
|
|
|
|
/**
|
|
* The action performed when an upload error occurs for a specific file being uploaded.
|
|
* The possible values are:
|
|
* <ul>
|
|
* <li> <strong>`UploaderQueue.CONTINUE`</strong>: the error is ignored and the upload process is continued.</li>
|
|
* <li> <strong>`UploaderQueue.STOP`</strong>: the upload process is stopped as soon as any other parallel file
|
|
* uploads are finished.</li>
|
|
* <li> <strong>`UploaderQueue.RESTART_ASAP`</strong>: the file is added back to the front of the queue.</li>
|
|
* <li> <strong>`UploaderQueue.RESTART_AFTER`</strong>: the file is added to the back of the queue.</li>
|
|
* </ul>
|
|
* @attribute errorAction
|
|
* @type {String}
|
|
* @default UploaderQueue.CONTINUE
|
|
*/
|
|
errorAction: {
|
|
value: "continue",
|
|
validator: function (val) {
|
|
return (
|
|
val === UploaderQueue.CONTINUE ||
|
|
val === UploaderQueue.STOP ||
|
|
val === UploaderQueue.RESTART_ASAP ||
|
|
val === UploaderQueue.RESTART_AFTER
|
|
);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* An array indicating what fileFilters should be applied to the file
|
|
* selection dialog. Each element in the array should be an object with
|
|
* the following key-value pairs:
|
|
* {
|
|
* description : String
|
|
extensions: String of the form &lquot;*.ext1;*.ext2;*.ext3;...&rquot;
|
|
* }
|
|
* @attribute fileFilters
|
|
* @type {Array}
|
|
* @default []
|
|
*/
|
|
fileFilters: {
|
|
value: []
|
|
},
|
|
|
|
/**
|
|
* A filtering function that is applied to every file selected by the user.
|
|
* The function receives the `Y.File` object and must return a Boolean value.
|
|
* If a `false` value is returned, the file in question is not added to the
|
|
* list of files to be uploaded.
|
|
* Use this function to put limits on file sizes or check the file names for
|
|
* correct extension, but make sure that a server-side check is also performed,
|
|
* since any client-side restrictions are only advisory and can be circumvented.
|
|
*
|
|
* @attribute fileFilterFunction
|
|
* @type {Function}
|
|
* @default null
|
|
*/
|
|
fileFilterFunction: {
|
|
value: null
|
|
},
|
|
|
|
/**
|
|
* A String specifying what should be the POST field name for the file
|
|
* content in the upload request.
|
|
*
|
|
* @attribute fileFieldName
|
|
* @type {String}
|
|
* @default Filedata
|
|
*/
|
|
fileFieldName: {
|
|
value: "Filedata"
|
|
},
|
|
|
|
/**
|
|
* The array of files to be uploaded. All elements in the array
|
|
* must be instances of `Y.FileFlash` and be instantiated with a `fileId`
|
|
* retrieved from an instance of the uploader.
|
|
*
|
|
* @attribute fileList
|
|
* @type {Array}
|
|
* @default []
|
|
*/
|
|
fileList: {
|
|
value: [],
|
|
getter: "_getFileList",
|
|
setter: "_setFileList"
|
|
},
|
|
|
|
/**
|
|
* A Boolean indicating whether multiple file selection is enabled.
|
|
*
|
|
* @attribute multipleFiles
|
|
* @type {Boolean}
|
|
* @default false
|
|
*/
|
|
multipleFiles: {
|
|
value: false
|
|
},
|
|
|
|
/**
|
|
* An object, keyed by `fileId`, containing sets of key-value pairs
|
|
* that should be passed as POST variables along with each corresponding
|
|
* file. This attribute is only used if no POST variables are specifed
|
|
* in the upload method call.
|
|
*
|
|
* @attribute postVarsPerFile
|
|
* @type {Object}
|
|
* @default {}
|
|
*/
|
|
postVarsPerFile: {
|
|
value: {}
|
|
},
|
|
|
|
/**
|
|
* The label for the "Select Files" widget. This is the value that replaces the
|
|
* `{selectButtonLabel}` token in the `SELECT_FILES_BUTTON` template.
|
|
*
|
|
* @attribute selectButtonLabel
|
|
* @type {String}
|
|
* @default "Select Files"
|
|
*/
|
|
selectButtonLabel: {
|
|
value: "Select Files"
|
|
},
|
|
|
|
/**
|
|
* The widget that serves as the "Select Files" control for the file uploader
|
|
*
|
|
*
|
|
* @attribute selectFilesButton
|
|
* @type {Node | Widget}
|
|
* @default A standard HTML button with YUI CSS Button skin.
|
|
*/
|
|
selectFilesButton : {
|
|
valueFn: function () {
|
|
return Y.Node.create(substitute(Y.UploaderFlash.SELECT_FILES_BUTTON, {selectButtonLabel: this.get("selectButtonLabel")}));
|
|
}
|
|
},
|
|
|
|
/**
|
|
* The number of files that can be uploaded
|
|
* simultaneously if the automatic queue management
|
|
* is used. This value can be in the range between 2
|
|
* and 5.
|
|
*
|
|
* @attribute simLimit
|
|
* @type {Number}
|
|
* @default 2
|
|
*/
|
|
simLimit: {
|
|
value: 2,
|
|
validator: function (val) {
|
|
return (val >= 2 && val <= 5);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* The URL to the SWF file of the flash uploader. A copy local to
|
|
* the server that hosts the page on which the uploader appears is
|
|
* recommended.
|
|
*
|
|
* @attribute swfURL
|
|
* @type {String}
|
|
* @default "flashuploader.swf" with a
|
|
* random GET parameter for IE (to prevent buggy behavior when the SWF
|
|
* is cached).
|
|
*/
|
|
swfURL: {
|
|
valueFn: function () {
|
|
var prefix = "flashuploader.swf";
|
|
|
|
if (Y.UA.ie > 0) {
|
|
return (prefix + "?t=" + Y.guid("uploader"));
|
|
}
|
|
|
|
return prefix;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* The id's or `Node` references of the DOM elements that precede
|
|
* and follow the `Select Files` button in the tab order. Specifying
|
|
* these allows keyboard navigation to and from the Flash player
|
|
* layer of the uploader.
|
|
* The two keys corresponding to the DOM elements are:
|
|
<ul>
|
|
* <li> `from`: the id or the `Node` reference corresponding to the
|
|
* DOM element that precedes the `Select Files` button in the tab order.</li>
|
|
* <li> `to`: the id or the `Node` reference corresponding to the
|
|
* DOM element that follows the `Select Files` button in the tab order.</li>
|
|
* </ul>
|
|
* @attribute tabElements
|
|
* @type {Object}
|
|
* @default null
|
|
*/
|
|
tabElements: {
|
|
value: null
|
|
},
|
|
|
|
/**
|
|
* The URL to which file upload requested are POSTed. Only used if a different url is not passed to the upload method call.
|
|
*
|
|
* @attribute uploadURL
|
|
* @type {String}
|
|
* @default ""
|
|
*/
|
|
uploadURL: {
|
|
value: ""
|
|
},
|
|
|
|
/**
|
|
* The number of times to try re-uploading a file that failed to upload before
|
|
* cancelling its upload.
|
|
*
|
|
* @attribute retryCount
|
|
* @type {Number}
|
|
* @default 3
|
|
*/
|
|
retryCount: {
|
|
value: 3
|
|
}
|
|
}
|
|
});
|
|
|
|
Y.UploaderFlash.Queue = UploaderQueue;
|
|
|
|
|
|
}, '3.17.2', {
|
|
"requires": [
|
|
"swfdetect",
|
|
"escape",
|
|
"widget",
|
|
"base",
|
|
"cssbutton",
|
|
"node",
|
|
"event-custom",
|
|
"uploader-queue"
|
|
]
|
|
});
|
|
|