libjs-swfupload_2.2.0.1+ds2/ 0002755 0001750 0001750 00000000000 12203733526 015030 5 ustar gawain gawain libjs-swfupload_2.2.0.1+ds2/swfupload license.txt 0000644 0001750 0001750 00000000762 12203733526 021203 0 ustar gawain gawain /**
* SWFUpload: http://www.swfupload.org, http://swfupload.googlecode.com
*
* mmSWFUpload 1.0: Flash upload dialog - http://profandesign.se/swfupload/, http://www.vinterwebb.se/
*
* SWFUpload is (c) 2006-2007 Lars Huring, Olov Nilzén and Mammon Media and is released under the MIT License:
* http://www.opensource.org/licenses/mit-license.php
*
* SWFUpload 2 is (c) 2007-2008 Jake Roberts and is released under the MIT License:
* http://www.opensource.org/licenses/mit-license.php
*
*/ libjs-swfupload_2.2.0.1+ds2/swfupload.js 0000644 0001750 0001750 00000113415 12203733526 017375 0 ustar gawain gawain /**
* SWFUpload: http://www.swfupload.org, http://swfupload.googlecode.com
*
* mmSWFUpload 1.0: Flash upload dialog - http://profandesign.se/swfupload/, http://www.vinterwebb.se/
*
* SWFUpload is (c) 2006-2007 Lars Huring, Olov Nilzén and Mammon Media and is released under the MIT License:
* http://www.opensource.org/licenses/mit-license.php
*
* SWFUpload 2 is (c) 2007-2008 Jake Roberts and is released under the MIT License:
* http://www.opensource.org/licenses/mit-license.php
*
*/
/* ******************* */
/* Constructor & Init */
/* ******************* */
var SWFUpload;
if (SWFUpload == undefined) {
SWFUpload = function (settings) {
this.initSWFUpload(settings);
};
}
SWFUpload.prototype.initSWFUpload = function (settings) {
try {
this.customSettings = {}; // A container where developers can place their own settings associated with this instance.
this.settings = settings;
this.eventQueue = [];
this.movieName = "SWFUpload_" + SWFUpload.movieCount++;
this.movieElement = null;
// Setup global control tracking
SWFUpload.instances[this.movieName] = this;
// Load the settings. Load the Flash movie.
this.initSettings();
this.loadFlash();
this.displayDebugInfo();
} catch (ex) {
delete SWFUpload.instances[this.movieName];
throw ex;
}
};
/* *************** */
/* Static Members */
/* *************** */
SWFUpload.instances = {};
SWFUpload.movieCount = 0;
SWFUpload.version = "2.2.0 2009-03-25";
SWFUpload.QUEUE_ERROR = {
QUEUE_LIMIT_EXCEEDED : -100,
FILE_EXCEEDS_SIZE_LIMIT : -110,
ZERO_BYTE_FILE : -120,
INVALID_FILETYPE : -130
};
SWFUpload.UPLOAD_ERROR = {
HTTP_ERROR : -200,
MISSING_UPLOAD_URL : -210,
IO_ERROR : -220,
SECURITY_ERROR : -230,
UPLOAD_LIMIT_EXCEEDED : -240,
UPLOAD_FAILED : -250,
SPECIFIED_FILE_ID_NOT_FOUND : -260,
FILE_VALIDATION_FAILED : -270,
FILE_CANCELLED : -280,
UPLOAD_STOPPED : -290
};
SWFUpload.FILE_STATUS = {
QUEUED : -1,
IN_PROGRESS : -2,
ERROR : -3,
COMPLETE : -4,
CANCELLED : -5
};
SWFUpload.BUTTON_ACTION = {
SELECT_FILE : -100,
SELECT_FILES : -110,
START_UPLOAD : -120
};
SWFUpload.CURSOR = {
ARROW : -1,
HAND : -2
};
SWFUpload.WINDOW_MODE = {
WINDOW : "window",
TRANSPARENT : "transparent",
OPAQUE : "opaque"
};
// Private: takes a URL, determines if it is relative and converts to an absolute URL
// using the current site. Only processes the URL if it can, otherwise returns the URL untouched
SWFUpload.completeURL = function(url) {
if (typeof(url) !== "string" || url.match(/^https?:\/\//i) || url.match(/^\//)) {
return url;
}
var currentURL = window.location.protocol + "//" + window.location.hostname + (window.location.port ? ":" + window.location.port : "");
var indexSlash = window.location.pathname.lastIndexOf("/");
if (indexSlash <= 0) {
path = "/";
} else {
path = window.location.pathname.substr(0, indexSlash) + "/";
}
return /*currentURL +*/ path + url;
};
/* ******************** */
/* Instance Members */
/* ******************** */
// Private: initSettings ensures that all the
// settings are set, getting a default value if one was not assigned.
SWFUpload.prototype.initSettings = function () {
this.ensureDefault = function (settingName, defaultValue) {
this.settings[settingName] = (this.settings[settingName] == undefined) ? defaultValue : this.settings[settingName];
};
// Upload backend settings
this.ensureDefault("upload_url", "");
this.ensureDefault("preserve_relative_urls", false);
this.ensureDefault("file_post_name", "Filedata");
this.ensureDefault("post_params", {});
this.ensureDefault("use_query_string", false);
this.ensureDefault("requeue_on_error", false);
this.ensureDefault("http_success", []);
this.ensureDefault("assume_success_timeout", 0);
// File Settings
this.ensureDefault("file_types", "*.*");
this.ensureDefault("file_types_description", "All Files");
this.ensureDefault("file_size_limit", 0); // Default zero means "unlimited"
this.ensureDefault("file_upload_limit", 0);
this.ensureDefault("file_queue_limit", 0);
// Flash Settings
this.ensureDefault("flash_url", "swfupload.swf");
this.ensureDefault("prevent_swf_caching", true);
// Button Settings
this.ensureDefault("button_image_url", "");
this.ensureDefault("button_width", 1);
this.ensureDefault("button_height", 1);
this.ensureDefault("button_text", "");
this.ensureDefault("button_text_style", "color: #000000; font-size: 16pt;");
this.ensureDefault("button_text_top_padding", 0);
this.ensureDefault("button_text_left_padding", 0);
this.ensureDefault("button_action", SWFUpload.BUTTON_ACTION.SELECT_FILES);
this.ensureDefault("button_disabled", false);
this.ensureDefault("button_placeholder_id", "");
this.ensureDefault("button_placeholder", null);
this.ensureDefault("button_cursor", SWFUpload.CURSOR.ARROW);
this.ensureDefault("button_window_mode", SWFUpload.WINDOW_MODE.WINDOW);
// Debug Settings
this.ensureDefault("debug", false);
this.settings.debug_enabled = this.settings.debug; // Here to maintain v2 API
// Event Handlers
this.settings.return_upload_start_handler = this.returnUploadStart;
this.ensureDefault("swfupload_loaded_handler", null);
this.ensureDefault("file_dialog_start_handler", null);
this.ensureDefault("file_queued_handler", null);
this.ensureDefault("file_queue_error_handler", null);
this.ensureDefault("file_dialog_complete_handler", null);
this.ensureDefault("upload_start_handler", null);
this.ensureDefault("upload_progress_handler", null);
this.ensureDefault("upload_error_handler", null);
this.ensureDefault("upload_success_handler", null);
this.ensureDefault("upload_complete_handler", null);
this.ensureDefault("debug_handler", this.debugMessage);
this.ensureDefault("custom_settings", {});
// Other settings
this.customSettings = this.settings.custom_settings;
// Update the flash url if needed
if (!!this.settings.prevent_swf_caching) {
this.settings.flash_url = this.settings.flash_url + (this.settings.flash_url.indexOf("?") < 0 ? "?" : "&") + "preventswfcaching=" + new Date().getTime();
}
if (!this.settings.preserve_relative_urls) {
//this.settings.flash_url = SWFUpload.completeURL(this.settings.flash_url); // Don't need to do this one since flash doesn't look at it
this.settings.upload_url = SWFUpload.completeURL(this.settings.upload_url);
this.settings.button_image_url = SWFUpload.completeURL(this.settings.button_image_url);
}
delete this.ensureDefault;
};
// Private: loadFlash replaces the button_placeholder element with the flash movie.
SWFUpload.prototype.loadFlash = function () {
var targetElement, tempParent;
// Make sure an element with the ID we are going to use doesn't already exist
if (document.getElementById(this.movieName) !== null) {
throw "ID " + this.movieName + " is already in use. The Flash Object could not be added";
}
// Get the element where we will be placing the flash movie
targetElement = document.getElementById(this.settings.button_placeholder_id) || this.settings.button_placeholder;
if (targetElement == undefined) {
throw "Could not find the placeholder element: " + this.settings.button_placeholder_id;
}
// Append the container and load the flash
tempParent = document.createElement("div");
tempParent.innerHTML = this.getFlashHTML(); // Using innerHTML is non-standard but the only sensible way to dynamically add Flash in IE (and maybe other browsers)
targetElement.parentNode.replaceChild(tempParent.firstChild, targetElement);
// Fix IE Flash/Form bug
if (window[this.movieName] == undefined) {
window[this.movieName] = this.getMovieElement();
}
};
// Private: getFlashHTML generates the object tag needed to embed the flash in to the document
SWFUpload.prototype.getFlashHTML = function () {
// Flash Satay object syntax: http://www.alistapart.com/articles/flashsatay
return [''].join("");
};
// Private: getFlashVars builds the parameter string that will be passed
// to flash in the flashvars param.
SWFUpload.prototype.getFlashVars = function () {
// Build a string from the post param object
var paramString = this.buildParamString();
var httpSuccessString = this.settings.http_success.join(",");
// Build the parameter string
return ["movieName=", encodeURIComponent(this.movieName),
"&uploadURL=", encodeURIComponent(this.settings.upload_url),
"&useQueryString=", encodeURIComponent(this.settings.use_query_string),
"&requeueOnError=", encodeURIComponent(this.settings.requeue_on_error),
"&httpSuccess=", encodeURIComponent(httpSuccessString),
"&assumeSuccessTimeout=", encodeURIComponent(this.settings.assume_success_timeout),
"¶ms=", encodeURIComponent(paramString),
"&filePostName=", encodeURIComponent(this.settings.file_post_name),
"&fileTypes=", encodeURIComponent(this.settings.file_types),
"&fileTypesDescription=", encodeURIComponent(this.settings.file_types_description),
"&fileSizeLimit=", encodeURIComponent(this.settings.file_size_limit),
"&fileUploadLimit=", encodeURIComponent(this.settings.file_upload_limit),
"&fileQueueLimit=", encodeURIComponent(this.settings.file_queue_limit),
"&debugEnabled=", encodeURIComponent(this.settings.debug_enabled),
"&buttonImageURL=", encodeURIComponent(this.settings.button_image_url),
"&buttonWidth=", encodeURIComponent(this.settings.button_width),
"&buttonHeight=", encodeURIComponent(this.settings.button_height),
"&buttonText=", encodeURIComponent(this.settings.button_text),
"&buttonTextTopPadding=", encodeURIComponent(this.settings.button_text_top_padding),
"&buttonTextLeftPadding=", encodeURIComponent(this.settings.button_text_left_padding),
"&buttonTextStyle=", encodeURIComponent(this.settings.button_text_style),
"&buttonAction=", encodeURIComponent(this.settings.button_action),
"&buttonDisabled=", encodeURIComponent(this.settings.button_disabled),
"&buttonCursor=", encodeURIComponent(this.settings.button_cursor)
].join("");
};
// Public: getMovieElement retrieves the DOM reference to the Flash element added by SWFUpload
// The element is cached after the first lookup
SWFUpload.prototype.getMovieElement = function () {
if (this.movieElement == undefined) {
this.movieElement = document.getElementById(this.movieName);
}
if (this.movieElement === null) {
throw "Could not find Flash element";
}
return this.movieElement;
};
// Private: buildParamString takes the name/value pairs in the post_params setting object
// and joins them up in to a string formatted "name=value&name=value"
SWFUpload.prototype.buildParamString = function () {
var postParams = this.settings.post_params;
var paramStringPairs = [];
if (typeof(postParams) === "object") {
for (var name in postParams) {
if (postParams.hasOwnProperty(name)) {
paramStringPairs.push(encodeURIComponent(name.toString()) + "=" + encodeURIComponent(postParams[name].toString()));
}
}
}
return paramStringPairs.join("&");
};
// Public: Used to remove a SWFUpload instance from the page. This method strives to remove
// all references to the SWF, and other objects so memory is properly freed.
// Returns true if everything was destroyed. Returns a false if a failure occurs leaving SWFUpload in an inconsistant state.
// Credits: Major improvements provided by steffen
SWFUpload.prototype.destroy = function () {
try {
// Make sure Flash is done before we try to remove it
this.cancelUpload(null, false);
// Remove the SWFUpload DOM nodes
var movieElement = null;
movieElement = this.getMovieElement();
if (movieElement && typeof(movieElement.CallFunction) === "unknown") { // We only want to do this in IE
// Loop through all the movie's properties and remove all function references (DOM/JS IE 6/7 memory leak workaround)
for (var i in movieElement) {
try {
if (typeof(movieElement[i]) === "function") {
movieElement[i] = null;
}
} catch (ex1) {}
}
// Remove the Movie Element from the page
try {
movieElement.parentNode.removeChild(movieElement);
} catch (ex) {}
}
// Remove IE form fix reference
window[this.movieName] = null;
// Destroy other references
SWFUpload.instances[this.movieName] = null;
delete SWFUpload.instances[this.movieName];
this.movieElement = null;
this.settings = null;
this.customSettings = null;
this.eventQueue = null;
this.movieName = null;
return true;
} catch (ex2) {
return false;
}
};
// Public: displayDebugInfo prints out settings and configuration
// information about this SWFUpload instance.
// This function (and any references to it) can be deleted when placing
// SWFUpload in production.
SWFUpload.prototype.displayDebugInfo = function () {
this.debug(
[
"---SWFUpload Instance Info---\n",
"Version: ", SWFUpload.version, "\n",
"Movie Name: ", this.movieName, "\n",
"Settings:\n",
"\t", "upload_url: ", this.settings.upload_url, "\n",
"\t", "flash_url: ", this.settings.flash_url, "\n",
"\t", "use_query_string: ", this.settings.use_query_string.toString(), "\n",
"\t", "requeue_on_error: ", this.settings.requeue_on_error.toString(), "\n",
"\t", "http_success: ", this.settings.http_success.join(", "), "\n",
"\t", "assume_success_timeout: ", this.settings.assume_success_timeout, "\n",
"\t", "file_post_name: ", this.settings.file_post_name, "\n",
"\t", "post_params: ", this.settings.post_params.toString(), "\n",
"\t", "file_types: ", this.settings.file_types, "\n",
"\t", "file_types_description: ", this.settings.file_types_description, "\n",
"\t", "file_size_limit: ", this.settings.file_size_limit, "\n",
"\t", "file_upload_limit: ", this.settings.file_upload_limit, "\n",
"\t", "file_queue_limit: ", this.settings.file_queue_limit, "\n",
"\t", "debug: ", this.settings.debug.toString(), "\n",
"\t", "prevent_swf_caching: ", this.settings.prevent_swf_caching.toString(), "\n",
"\t", "button_placeholder_id: ", this.settings.button_placeholder_id.toString(), "\n",
"\t", "button_placeholder: ", (this.settings.button_placeholder ? "Set" : "Not Set"), "\n",
"\t", "button_image_url: ", this.settings.button_image_url.toString(), "\n",
"\t", "button_width: ", this.settings.button_width.toString(), "\n",
"\t", "button_height: ", this.settings.button_height.toString(), "\n",
"\t", "button_text: ", this.settings.button_text.toString(), "\n",
"\t", "button_text_style: ", this.settings.button_text_style.toString(), "\n",
"\t", "button_text_top_padding: ", this.settings.button_text_top_padding.toString(), "\n",
"\t", "button_text_left_padding: ", this.settings.button_text_left_padding.toString(), "\n",
"\t", "button_action: ", this.settings.button_action.toString(), "\n",
"\t", "button_disabled: ", this.settings.button_disabled.toString(), "\n",
"\t", "custom_settings: ", this.settings.custom_settings.toString(), "\n",
"Event Handlers:\n",
"\t", "swfupload_loaded_handler assigned: ", (typeof this.settings.swfupload_loaded_handler === "function").toString(), "\n",
"\t", "file_dialog_start_handler assigned: ", (typeof this.settings.file_dialog_start_handler === "function").toString(), "\n",
"\t", "file_queued_handler assigned: ", (typeof this.settings.file_queued_handler === "function").toString(), "\n",
"\t", "file_queue_error_handler assigned: ", (typeof this.settings.file_queue_error_handler === "function").toString(), "\n",
"\t", "upload_start_handler assigned: ", (typeof this.settings.upload_start_handler === "function").toString(), "\n",
"\t", "upload_progress_handler assigned: ", (typeof this.settings.upload_progress_handler === "function").toString(), "\n",
"\t", "upload_error_handler assigned: ", (typeof this.settings.upload_error_handler === "function").toString(), "\n",
"\t", "upload_success_handler assigned: ", (typeof this.settings.upload_success_handler === "function").toString(), "\n",
"\t", "upload_complete_handler assigned: ", (typeof this.settings.upload_complete_handler === "function").toString(), "\n",
"\t", "debug_handler assigned: ", (typeof this.settings.debug_handler === "function").toString(), "\n"
].join("")
);
};
/* Note: addSetting and getSetting are no longer used by SWFUpload but are included
the maintain v2 API compatibility
*/
// Public: (Deprecated) addSetting adds a setting value. If the value given is undefined or null then the default_value is used.
SWFUpload.prototype.addSetting = function (name, value, default_value) {
if (value == undefined) {
return (this.settings[name] = default_value);
} else {
return (this.settings[name] = value);
}
};
// Public: (Deprecated) getSetting gets a setting. Returns an empty string if the setting was not found.
SWFUpload.prototype.getSetting = function (name) {
if (this.settings[name] != undefined) {
return this.settings[name];
}
return "";
};
// Private: callFlash handles function calls made to the Flash element.
// Calls are made with a setTimeout for some functions to work around
// bugs in the ExternalInterface library.
SWFUpload.prototype.callFlash = function (functionName, argumentArray) {
argumentArray = argumentArray || [];
var movieElement = this.getMovieElement();
var returnValue, returnString;
// Flash's method if calling ExternalInterface methods (code adapted from MooTools).
try {
returnString = movieElement.CallFunction('' + __flash__argumentsToXML(argumentArray, 0) + '');
returnValue = eval(returnString);
} catch (ex) {
throw "Call to " + functionName + " failed";
}
// Unescape file post param values
if (returnValue != undefined && typeof returnValue.post === "object") {
returnValue = this.unescapeFilePostParams(returnValue);
}
return returnValue;
};
/* *****************************
-- Flash control methods --
Your UI should use these
to operate SWFUpload
***************************** */
// WARNING: this function does not work in Flash Player 10
// Public: selectFile causes a File Selection Dialog window to appear. This
// dialog only allows 1 file to be selected.
SWFUpload.prototype.selectFile = function () {
this.callFlash("SelectFile");
};
// WARNING: this function does not work in Flash Player 10
// Public: selectFiles causes a File Selection Dialog window to appear/ This
// dialog allows the user to select any number of files
// Flash Bug Warning: Flash limits the number of selectable files based on the combined length of the file names.
// If the selection name length is too long the dialog will fail in an unpredictable manner. There is no work-around
// for this bug.
SWFUpload.prototype.selectFiles = function () {
this.callFlash("SelectFiles");
};
// Public: startUpload starts uploading the first file in the queue unless
// the optional parameter 'fileID' specifies the ID
SWFUpload.prototype.startUpload = function (fileID) {
this.callFlash("StartUpload", [fileID]);
};
// Public: cancelUpload cancels any queued file. The fileID parameter may be the file ID or index.
// If you do not specify a fileID the current uploading file or first file in the queue is cancelled.
// If you do not want the uploadError event to trigger you can specify false for the triggerErrorEvent parameter.
SWFUpload.prototype.cancelUpload = function (fileID, triggerErrorEvent) {
if (triggerErrorEvent !== false) {
triggerErrorEvent = true;
}
this.callFlash("CancelUpload", [fileID, triggerErrorEvent]);
};
// Public: stopUpload stops the current upload and requeues the file at the beginning of the queue.
// If nothing is currently uploading then nothing happens.
SWFUpload.prototype.stopUpload = function () {
this.callFlash("StopUpload");
};
/* ************************
* Settings methods
* These methods change the SWFUpload settings.
* SWFUpload settings should not be changed directly on the settings object
* since many of the settings need to be passed to Flash in order to take
* effect.
* *********************** */
// Public: getStats gets the file statistics object.
SWFUpload.prototype.getStats = function () {
return this.callFlash("GetStats");
};
// Public: setStats changes the SWFUpload statistics. You shouldn't need to
// change the statistics but you can. Changing the statistics does not
// affect SWFUpload accept for the successful_uploads count which is used
// by the upload_limit setting to determine how many files the user may upload.
SWFUpload.prototype.setStats = function (statsObject) {
this.callFlash("SetStats", [statsObject]);
};
// Public: getFile retrieves a File object by ID or Index. If the file is
// not found then 'null' is returned.
SWFUpload.prototype.getFile = function (fileID) {
if (typeof(fileID) === "number") {
return this.callFlash("GetFileByIndex", [fileID]);
} else {
return this.callFlash("GetFile", [fileID]);
}
};
// Public: addFileParam sets a name/value pair that will be posted with the
// file specified by the Files ID. If the name already exists then the
// exiting value will be overwritten.
SWFUpload.prototype.addFileParam = function (fileID, name, value) {
return this.callFlash("AddFileParam", [fileID, name, value]);
};
// Public: removeFileParam removes a previously set (by addFileParam) name/value
// pair from the specified file.
SWFUpload.prototype.removeFileParam = function (fileID, name) {
this.callFlash("RemoveFileParam", [fileID, name]);
};
// Public: setUploadUrl changes the upload_url setting.
SWFUpload.prototype.setUploadURL = function (url) {
this.settings.upload_url = url.toString();
this.callFlash("SetUploadURL", [url]);
};
// Public: setPostParams changes the post_params setting
SWFUpload.prototype.setPostParams = function (paramsObject) {
this.settings.post_params = paramsObject;
this.callFlash("SetPostParams", [paramsObject]);
};
// Public: addPostParam adds post name/value pair. Each name can have only one value.
SWFUpload.prototype.addPostParam = function (name, value) {
this.settings.post_params[name] = value;
this.callFlash("SetPostParams", [this.settings.post_params]);
};
// Public: removePostParam deletes post name/value pair.
SWFUpload.prototype.removePostParam = function (name) {
delete this.settings.post_params[name];
this.callFlash("SetPostParams", [this.settings.post_params]);
};
// Public: setFileTypes changes the file_types setting and the file_types_description setting
SWFUpload.prototype.setFileTypes = function (types, description) {
this.settings.file_types = types;
this.settings.file_types_description = description;
this.callFlash("SetFileTypes", [types, description]);
};
// Public: setFileSizeLimit changes the file_size_limit setting
SWFUpload.prototype.setFileSizeLimit = function (fileSizeLimit) {
this.settings.file_size_limit = fileSizeLimit;
this.callFlash("SetFileSizeLimit", [fileSizeLimit]);
};
// Public: setFileUploadLimit changes the file_upload_limit setting
SWFUpload.prototype.setFileUploadLimit = function (fileUploadLimit) {
this.settings.file_upload_limit = fileUploadLimit;
this.callFlash("SetFileUploadLimit", [fileUploadLimit]);
};
// Public: setFileQueueLimit changes the file_queue_limit setting
SWFUpload.prototype.setFileQueueLimit = function (fileQueueLimit) {
this.settings.file_queue_limit = fileQueueLimit;
this.callFlash("SetFileQueueLimit", [fileQueueLimit]);
};
// Public: setFilePostName changes the file_post_name setting
SWFUpload.prototype.setFilePostName = function (filePostName) {
this.settings.file_post_name = filePostName;
this.callFlash("SetFilePostName", [filePostName]);
};
// Public: setUseQueryString changes the use_query_string setting
SWFUpload.prototype.setUseQueryString = function (useQueryString) {
this.settings.use_query_string = useQueryString;
this.callFlash("SetUseQueryString", [useQueryString]);
};
// Public: setRequeueOnError changes the requeue_on_error setting
SWFUpload.prototype.setRequeueOnError = function (requeueOnError) {
this.settings.requeue_on_error = requeueOnError;
this.callFlash("SetRequeueOnError", [requeueOnError]);
};
// Public: setHTTPSuccess changes the http_success setting
SWFUpload.prototype.setHTTPSuccess = function (http_status_codes) {
if (typeof http_status_codes === "string") {
http_status_codes = http_status_codes.replace(" ", "").split(",");
}
this.settings.http_success = http_status_codes;
this.callFlash("SetHTTPSuccess", [http_status_codes]);
};
// Public: setHTTPSuccess changes the http_success setting
SWFUpload.prototype.setAssumeSuccessTimeout = function (timeout_seconds) {
this.settings.assume_success_timeout = timeout_seconds;
this.callFlash("SetAssumeSuccessTimeout", [timeout_seconds]);
};
// Public: setDebugEnabled changes the debug_enabled setting
SWFUpload.prototype.setDebugEnabled = function (debugEnabled) {
this.settings.debug_enabled = debugEnabled;
this.callFlash("SetDebugEnabled", [debugEnabled]);
};
// Public: setButtonImageURL loads a button image sprite
SWFUpload.prototype.setButtonImageURL = function (buttonImageURL) {
if (buttonImageURL == undefined) {
buttonImageURL = "";
}
this.settings.button_image_url = buttonImageURL;
this.callFlash("SetButtonImageURL", [buttonImageURL]);
};
// Public: setButtonDimensions resizes the Flash Movie and button
SWFUpload.prototype.setButtonDimensions = function (width, height) {
this.settings.button_width = width;
this.settings.button_height = height;
var movie = this.getMovieElement();
if (movie != undefined) {
movie.style.width = width + "px";
movie.style.height = height + "px";
}
this.callFlash("SetButtonDimensions", [width, height]);
};
// Public: setButtonText Changes the text overlaid on the button
SWFUpload.prototype.setButtonText = function (html) {
this.settings.button_text = html;
this.callFlash("SetButtonText", [html]);
};
// Public: setButtonTextPadding changes the top and left padding of the text overlay
SWFUpload.prototype.setButtonTextPadding = function (left, top) {
this.settings.button_text_top_padding = top;
this.settings.button_text_left_padding = left;
this.callFlash("SetButtonTextPadding", [left, top]);
};
// Public: setButtonTextStyle changes the CSS used to style the HTML/Text overlaid on the button
SWFUpload.prototype.setButtonTextStyle = function (css) {
this.settings.button_text_style = css;
this.callFlash("SetButtonTextStyle", [css]);
};
// Public: setButtonDisabled disables/enables the button
SWFUpload.prototype.setButtonDisabled = function (isDisabled) {
this.settings.button_disabled = isDisabled;
this.callFlash("SetButtonDisabled", [isDisabled]);
};
// Public: setButtonAction sets the action that occurs when the button is clicked
SWFUpload.prototype.setButtonAction = function (buttonAction) {
this.settings.button_action = buttonAction;
this.callFlash("SetButtonAction", [buttonAction]);
};
// Public: setButtonCursor changes the mouse cursor displayed when hovering over the button
SWFUpload.prototype.setButtonCursor = function (cursor) {
this.settings.button_cursor = cursor;
this.callFlash("SetButtonCursor", [cursor]);
};
/* *******************************
Flash Event Interfaces
These functions are used by Flash to trigger the various
events.
All these functions a Private.
Because the ExternalInterface library is buggy the event calls
are added to a queue and the queue then executed by a setTimeout.
This ensures that events are executed in a determinate order and that
the ExternalInterface bugs are avoided.
******************************* */
SWFUpload.prototype.queueEvent = function (handlerName, argumentArray) {
// Warning: Don't call this.debug inside here or you'll create an infinite loop
if (argumentArray == undefined) {
argumentArray = [];
} else if (!(argumentArray instanceof Array)) {
argumentArray = [argumentArray];
}
var self = this;
if (typeof this.settings[handlerName] === "function") {
// Queue the event
this.eventQueue.push(function () {
this.settings[handlerName].apply(this, argumentArray);
});
// Execute the next queued event
setTimeout(function () {
self.executeNextEvent();
}, 0);
} else if (this.settings[handlerName] !== null) {
throw "Event handler " + handlerName + " is unknown or is not a function";
}
};
// Private: Causes the next event in the queue to be executed. Since events are queued using a setTimeout
// we must queue them in order to garentee that they are executed in order.
SWFUpload.prototype.executeNextEvent = function () {
// Warning: Don't call this.debug inside here or you'll create an infinite loop
var f = this.eventQueue ? this.eventQueue.shift() : null;
if (typeof(f) === "function") {
f.apply(this);
}
};
// Private: unescapeFileParams is part of a workaround for a flash bug where objects passed through ExternalInterface cannot have
// properties that contain characters that are not valid for JavaScript identifiers. To work around this
// the Flash Component escapes the parameter names and we must unescape again before passing them along.
SWFUpload.prototype.unescapeFilePostParams = function (file) {
var reg = /[$]([0-9a-f]{4})/i;
var unescapedPost = {};
var uk;
if (file != undefined) {
for (var k in file.post) {
if (file.post.hasOwnProperty(k)) {
uk = k;
var match;
while ((match = reg.exec(uk)) !== null) {
uk = uk.replace(match[0], String.fromCharCode(parseInt("0x" + match[1], 16)));
}
unescapedPost[uk] = file.post[k];
}
}
file.post = unescapedPost;
}
return file;
};
// Private: Called by Flash to see if JS can call in to Flash (test if External Interface is working)
SWFUpload.prototype.testExternalInterface = function () {
try {
return this.callFlash("TestExternalInterface");
} catch (ex) {
return false;
}
};
// Private: This event is called by Flash when it has finished loading. Don't modify this.
// Use the swfupload_loaded_handler event setting to execute custom code when SWFUpload has loaded.
SWFUpload.prototype.flashReady = function () {
// Check that the movie element is loaded correctly with its ExternalInterface methods defined
var movieElement = this.getMovieElement();
if (!movieElement) {
this.debug("Flash called back ready but the flash movie can't be found.");
return;
}
this.cleanUp(movieElement);
this.queueEvent("swfupload_loaded_handler");
};
// Private: removes Flash added fuctions to the DOM node to prevent memory leaks in IE.
// This function is called by Flash each time the ExternalInterface functions are created.
SWFUpload.prototype.cleanUp = function (movieElement) {
// Pro-actively unhook all the Flash functions
try {
if (this.movieElement && typeof(movieElement.CallFunction) === "unknown") { // We only want to do this in IE
this.debug("Removing Flash functions hooks (this should only run in IE and should prevent memory leaks)");
for (var key in movieElement) {
try {
if (typeof(movieElement[key]) === "function") {
movieElement[key] = null;
}
} catch (ex) {
}
}
}
} catch (ex1) {
}
// Fix Flashes own cleanup code so if the SWFMovie was removed from the page
// it doesn't display errors.
window["__flash__removeCallback"] = function (instance, name) {
try {
if (instance) {
instance[name] = null;
}
} catch (flashEx) {
}
};
};
/* This is a chance to do something before the browse window opens */
SWFUpload.prototype.fileDialogStart = function () {
this.queueEvent("file_dialog_start_handler");
};
/* Called when a file is successfully added to the queue. */
SWFUpload.prototype.fileQueued = function (file) {
file = this.unescapeFilePostParams(file);
this.queueEvent("file_queued_handler", file);
};
/* Handle errors that occur when an attempt to queue a file fails. */
SWFUpload.prototype.fileQueueError = function (file, errorCode, message) {
file = this.unescapeFilePostParams(file);
this.queueEvent("file_queue_error_handler", [file, errorCode, message]);
};
/* Called after the file dialog has closed and the selected files have been queued.
You could call startUpload here if you want the queued files to begin uploading immediately. */
SWFUpload.prototype.fileDialogComplete = function (numFilesSelected, numFilesQueued, numFilesInQueue) {
this.queueEvent("file_dialog_complete_handler", [numFilesSelected, numFilesQueued, numFilesInQueue]);
};
SWFUpload.prototype.uploadStart = function (file) {
file = this.unescapeFilePostParams(file);
this.queueEvent("return_upload_start_handler", file);
};
SWFUpload.prototype.returnUploadStart = function (file) {
var returnValue;
if (typeof this.settings.upload_start_handler === "function") {
file = this.unescapeFilePostParams(file);
returnValue = this.settings.upload_start_handler.call(this, file);
} else if (this.settings.upload_start_handler != undefined) {
throw "upload_start_handler must be a function";
}
// Convert undefined to true so if nothing is returned from the upload_start_handler it is
// interpretted as 'true'.
if (returnValue === undefined) {
returnValue = true;
}
returnValue = !!returnValue;
this.callFlash("ReturnUploadStart", [returnValue]);
};
SWFUpload.prototype.uploadProgress = function (file, bytesComplete, bytesTotal) {
file = this.unescapeFilePostParams(file);
this.queueEvent("upload_progress_handler", [file, bytesComplete, bytesTotal]);
};
SWFUpload.prototype.uploadError = function (file, errorCode, message) {
file = this.unescapeFilePostParams(file);
this.queueEvent("upload_error_handler", [file, errorCode, message]);
};
SWFUpload.prototype.uploadSuccess = function (file, serverData, responseReceived) {
file = this.unescapeFilePostParams(file);
this.queueEvent("upload_success_handler", [file, serverData, responseReceived]);
};
SWFUpload.prototype.uploadComplete = function (file) {
file = this.unescapeFilePostParams(file);
this.queueEvent("upload_complete_handler", file);
};
/* Called by SWFUpload JavaScript and Flash functions when debug is enabled. By default it writes messages to the
internal debug console. You can override this event and have messages written where you want. */
SWFUpload.prototype.debug = function (message) {
this.queueEvent("debug_handler", message);
};
/* **********************************
Debug Console
The debug console is a self contained, in page location
for debug message to be sent. The Debug Console adds
itself to the body if necessary.
The console is automatically scrolled as messages appear.
If you are using your own debug handler or when you deploy to production and
have debug disabled you can remove these functions to reduce the file size
and complexity.
********************************** */
// Private: debugMessage is the default debug_handler. If you want to print debug messages
// call the debug() function. When overriding the function your own function should
// check to see if the debug setting is true before outputting debug information.
SWFUpload.prototype.debugMessage = function (message) {
if (this.settings.debug) {
var exceptionMessage, exceptionValues = [];
// Check for an exception object and print it nicely
if (typeof message === "object" && typeof message.name === "string" && typeof message.message === "string") {
for (var key in message) {
if (message.hasOwnProperty(key)) {
exceptionValues.push(key + ": " + message[key]);
}
}
exceptionMessage = exceptionValues.join("\n") || "";
exceptionValues = exceptionMessage.split("\n");
exceptionMessage = "EXCEPTION: " + exceptionValues.join("\nEXCEPTION: ");
SWFUpload.Console.writeLine(exceptionMessage);
} else {
SWFUpload.Console.writeLine(message);
}
}
};
SWFUpload.Console = {};
SWFUpload.Console.writeLine = function (message) {
var console, documentForm;
try {
console = document.getElementById("SWFUpload_Console");
if (!console) {
documentForm = document.createElement("form");
document.getElementsByTagName("body")[0].appendChild(documentForm);
console = document.createElement("textarea");
console.id = "SWFUpload_Console";
console.style.fontFamily = "monospace";
console.setAttribute("wrap", "off");
console.wrap = "off";
console.style.overflow = "auto";
console.style.width = "700px";
console.style.height = "350px";
console.style.margin = "5px";
documentForm.appendChild(console);
}
console.value += message + "\n";
console.scrollTop = console.scrollHeight - console.clientHeight;
} catch (ex) {
alert("Exception: " + ex.name + " Message: " + ex.message);
}
};
libjs-swfupload_2.2.0.1+ds2/Flash/ 0002755 0001750 0001750 00000000000 12750724141 016065 5 ustar gawain gawain libjs-swfupload_2.2.0.1+ds2/Flash/obj/ 0002755 0001750 0001750 00000000000 12203733526 016637 5 ustar gawain gawain libjs-swfupload_2.2.0.1+ds2/Flash/obj/SWFUpload-v2Config.old 0000644 0001750 0001750 00000001504 12203733526 022614 0 ustar gawain gawain
C:\inetpub\wwwroot\other\swfupload\core\FlashC:\Program Files (x86)\FlashDevelop\Library\AS3\classesC:\inetpub\wwwroot\other\swfupload\core\Flash\SWFUpload.as#FFFFFF15300300 libjs-swfupload_2.2.0.1+ds2/Flash/obj/SWFUpload-v2Config.xml 0000644 0001750 0001750 00000001504 12203733526 022636 0 ustar gawain gawain
C:\inetpub\wwwroot\other\swfupload\core\FlashC:\Program Files (x86)\FlashDevelop\Library\AS3\classesC:\inetpub\wwwroot\other\swfupload\core\Flash\SWFUpload.as#FFFFFF15300300 libjs-swfupload_2.2.0.1+ds2/Flash/ExternalCall.as 0000644 0001750 0001750 00000011122 12203733526 020763 0 ustar gawain gawain package {
import flash.external.ExternalInterface;
internal class ExternalCall
{
/*public function ExternalCall()
{
}
*/
public static function Simple(callback:String):void {
ExternalInterface.call(callback);
}
public static function FileQueued(callback:String, file_object:Object):void {
ExternalInterface.call(callback, EscapeMessage(file_object));
}
public static function FileQueueError(callback:String, error_code:Number, file_object:Object, message:String):void {
ExternalInterface.call(callback, EscapeMessage(file_object), EscapeMessage(error_code), EscapeMessage(message));
}
public static function FileDialogComplete(callback:String, num_files_selected:Number, num_files_queued:Number, total_num_files_queued:Number):void {
ExternalInterface.call(callback, EscapeMessage(num_files_selected), EscapeMessage(num_files_queued), EscapeMessage(total_num_files_queued));
}
public static function UploadStart(callback:String, file_object:Object):void {
ExternalInterface.call(callback, EscapeMessage(file_object));
}
public static function UploadProgress(callback:String, file_object:Object, bytes_loaded:uint, bytes_total:uint):void {
ExternalInterface.call(callback, EscapeMessage(file_object), EscapeMessage(bytes_loaded), EscapeMessage(bytes_total));
}
public static function UploadSuccess(callback:String, file_object:Object, server_data:String, responseReceived:Boolean):void {
ExternalInterface.call(callback, EscapeMessage(file_object), EscapeMessage(server_data), EscapeMessage(responseReceived));
}
public static function UploadError(callback:String, error_code:Number, file_object:Object, message:String):void {
ExternalInterface.call(callback, EscapeMessage(file_object), EscapeMessage(error_code), EscapeMessage(message));
}
public static function UploadComplete(callback:String, file_object:Object):void {
ExternalInterface.call(callback, EscapeMessage(file_object));
}
public static function Debug(callback:String, message:String):void {
ExternalInterface.call(callback, EscapeMessage(message));
}
public static function Bool(callback:String):Boolean {
return ExternalInterface.call(callback);
}
/* Escapes all the backslashes which are not translated correctly in the Flash -> JavaScript Interface
*
* These functions had to be developed because the ExternalInterface has a bug that simply places the
* value a string in quotes (except for a " which is escaped) in a JavaScript string literal which
* is executed by the browser. These often results in improperly escaped string literals if your
* input string has any backslash characters. For example the string:
* "c:\Program Files\uploadtools\"
* is placed in a string literal (with quotes escaped) and becomes:
* var __flash__temp = "\"c:\Program Files\uploadtools\\"";
* This statement will cause errors when executed by the JavaScript interpreter:
* 1) The first \" is succesfully transformed to a "
* 2) \P is translated to P and the \ is lost
* 3) \u is interpreted as a unicode character and causes an error in IE
* 4) \\ is translated to \
* 5) leaving an unescaped " which causes an error
*
* I fixed this by escaping \ characters in all outgoing strings. The above escaped string becomes:
* var __flash__temp = "\"c:\\Program Files\\uploadtools\\\"";
* which contains the correct string literal.
*
* Note: The "var __flash__temp = " portion of the example is part of the ExternalInterface not part of
* my escaping routine.
*/
private static function EscapeMessage(message:*):* {
if (message is String) {
message = EscapeString(message);
}
else if (message is Array) {
message = EscapeArray(message);
}
else if (message is Object) {
message = EscapeObject(message);
}
return message;
}
private static function EscapeString(message:String):String {
var replacePattern:RegExp = /\\/g;
return message.replace(replacePattern, "\\\\");
}
private static function EscapeArray(message_array:Array):Array {
var length:uint = message_array.length;
var i:uint = 0;
for (i; i < length; i++) {
message_array[i] = EscapeMessage(message_array[i]);
}
return message_array;
}
private static function EscapeObject(message_obj:Object):Object {
for (var name:String in message_obj) {
message_obj[name] = EscapeMessage(message_obj[name]);
}
return message_obj;
}
}
} libjs-swfupload_2.2.0.1+ds2/Flash/SWFUpload v2.as3proj 0000644 0001750 0001750 00000004764 12203733526 021515 0 ustar gawain gawain 
deploy.bat libjs-swfupload_2.2.0.1+ds2/Flash/deploy.bat 0000644 0001750 0001750 00000000161 12203733526 020045 0 ustar gawain gawain @echo off
copy ..\swfupload.js ..\..\samples\demos\swfupload
copy swfupload.swf ..\..\samples\demos\swfupload
libjs-swfupload_2.2.0.1+ds2/Flash/FileItem.as 0000644 0001750 0001750 00000007264 12203733526 020117 0 ustar gawain gawain package {
import flash.net.FileReference;
internal class FileItem
{
private static var file_id_sequence:Number = 0; // tracks the file id sequence
private var postObject:Object;
public var file_reference:FileReference;
public var id:String;
public var index:Number = -1;
public var file_status:int = 0;
private var js_object:Object;
public static var FILE_STATUS_QUEUED:int = -1;
public static var FILE_STATUS_IN_PROGRESS:int = -2;
public static var FILE_STATUS_ERROR:int = -3;
public static var FILE_STATUS_SUCCESS:int = -4;
public static var FILE_STATUS_CANCELLED:int = -5;
public static var FILE_STATUS_NEW:int = -6; // This file status should never be sent to JavaScript
public function FileItem(file_reference:FileReference, control_id:String, index:Number)
{
this.postObject = {};
this.file_reference = file_reference;
this.id = control_id + "_" + (FileItem.file_id_sequence++);
this.file_status = FileItem.FILE_STATUS_NEW;
this.index = index;
this.js_object = {
id: this.id,
index: this.index,
post: this.GetPostObject()
};
// Cleanly attempt to retrieve the FileReference info
// this can fail and so is wrapped in try..catch
try {
this.js_object.name = this.file_reference.name;
this.js_object.size = this.file_reference.size;
this.js_object.type = this.file_reference.type || "";
this.js_object.creationdate = this.file_reference.creationDate || new Date(0);
this.js_object.modificationdate = this.file_reference.modificationDate || new Date(0);
} catch (ex:Error) {
this.file_status = FileItem.FILE_STATUS_ERROR;
}
this.js_object.filestatus = this.file_status;
}
public function AddParam(name:String, value:String):void {
this.postObject[name] = value;
}
public function RemoveParam(name:String):void {
delete this.postObject[name];
}
public function GetPostObject(escape:Boolean = false):Object {
if (escape) {
var escapedPostObject:Object = { };
for (var k:String in this.postObject) {
if (this.postObject.hasOwnProperty(k)) {
var escapedName:String = FileItem.EscapeParamName(k);
escapedPostObject[escapedName] = this.postObject[k];
}
}
return escapedPostObject;
} else {
return this.postObject;
}
}
// Create the simply file object that is passed to the browser
public function ToJavaScriptObject():Object {
this.js_object.filestatus = this.file_status;
this.js_object.post = this.GetPostObject(true);
return this.js_object;
}
public function toString():String {
return "FileItem - ID: " + this.id;
}
/*
// The purpose of this function is to escape the property names so when Flash
// passes them back to javascript they can be interpretted correctly.
// ***They have to be unescaped again by JavaScript.**
//
// This works around a bug where Flash sends objects this way:
// object.parametername = "value";
// instead of
// object["parametername"] = "value";
// This can be a problem if the parameter name has characters that are not
// allowed in JavaScript identifiers:
// object.parameter.name! = "value";
// does not work but,
// object["parameter.name!"] = "value";
// would have worked.
*/
public static function EscapeParamName(name:String):String {
name = name.replace(/[^a-z0-9_]/gi, FileItem.EscapeCharacter);
name = name.replace(/^[0-9]/, FileItem.EscapeCharacter);
return name;
}
public static function EscapeCharacter():String {
return "$" + ("0000" + arguments[0].charCodeAt(0).toString(16)).substr(-4, 4);
}
}
} libjs-swfupload_2.2.0.1+ds2/Flash/SWFUpload.as 0000644 0001750 0001750 00000172425 12203733526 020227 0 ustar gawain gawain package {
import flash.display.BlendMode;
import flash.display.DisplayObjectContainer;
import flash.display.Loader;
import flash.display.Stage;
import flash.display.Sprite;
import flash.display.StageAlign;
import flash.display.StageScaleMode;
import flash.net.FileReferenceList;
import flash.net.FileReference;
import flash.net.FileFilter;
import flash.net.URLRequest;
import flash.net.URLRequestMethod;
import flash.net.URLVariables;
import flash.events.*;
import flash.external.ExternalInterface;
import flash.system.Security;
import flash.text.AntiAliasType;
import flash.text.GridFitType;
import flash.text.StaticText;
import flash.text.StyleSheet;
import flash.text.TextDisplayMode;
import flash.text.TextField;
import flash.text.TextFieldType;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormat;
import flash.ui.Mouse;
import flash.utils.Timer;
import flash.xml.XMLNode;
import flash.xml.XMLNodeType;
import FileItem;
import ExternalCall;
public class SWFUpload extends Sprite {
// Cause SWFUpload to start as soon as the movie starts
public static function main():void
{
var SWFUpload:SWFUpload = new SWFUpload();
}
private const build_number:String = "SWFUPLOAD 2.2.0";
// State tracking variables
private var fileBrowserMany:FileReferenceList = new FileReferenceList();
private var fileBrowserOne:FileReference = null; // This isn't set because it can't be reused like the FileReferenceList. It gets setup in the SelectFile method
private var file_queue:Array = new Array(); // holds a list of all items that are to be uploaded.
private var current_file_item:FileItem = null; // the item that is currently being uploaded.
private var file_index:Array = new Array();
private var successful_uploads:Number = 0; // Tracks the uploads that have been completed
private var queue_errors:Number = 0; // Tracks files rejected during queueing
private var upload_errors:Number = 0; // Tracks files that fail upload
private var upload_cancelled:Number = 0; // Tracks number of cancelled files
private var queued_uploads:Number = 0; // Tracks the FileItems that are waiting to be uploaded.
private var valid_file_extensions:Array = new Array();// Holds the parsed valid extensions.
private var serverDataTimer:Timer = null;
private var assumeSuccessTimer:Timer = null;
private var restoreExtIntTimer:Timer;
private var hasCalledFlashReady:Boolean = false;
// Callbacks
private var flashReady_Callback:String;
private var fileDialogStart_Callback:String;
private var fileQueued_Callback:String;
private var fileQueueError_Callback:String;
private var fileDialogComplete_Callback:String;
private var uploadStart_Callback:String;
private var uploadProgress_Callback:String;
private var uploadError_Callback:String;
private var uploadSuccess_Callback:String;
private var uploadComplete_Callback:String;
private var debug_Callback:String;
private var testExternalInterface_Callback:String;
private var cleanUp_Callback:String;
// Values passed in from the HTML
private var movieName:String;
private var uploadURL:String;
private var filePostName:String;
private var uploadPostObject:Object;
private var fileTypes:String;
private var fileTypesDescription:String;
private var fileSizeLimit:Number;
private var fileUploadLimit:Number = 0;
private var fileQueueLimit:Number = 0;
private var useQueryString:Boolean = false;
private var requeueOnError:Boolean = false;
private var httpSuccess:Array = [];
private var assumeSuccessTimeout:Number = 0;
private var debugEnabled:Boolean;
private var buttonLoader:Loader;
private var buttonTextField:TextField;
private var buttonCursorSprite:Sprite;
private var buttonImageURL:String;
private var buttonWidth:Number;
private var buttonHeight:Number;
private var buttonText:String;
private var buttonTextStyle:String;
private var buttonTextTopPadding:Number;
private var buttonTextLeftPadding:Number;
private var buttonAction:Number;
private var buttonCursor:Number;
private var buttonStateOver:Boolean;
private var buttonStateMouseDown:Boolean;
private var buttonStateDisabled:Boolean;
// Error code "constants"
// Size check constants
private var SIZE_TOO_BIG:Number = 1;
private var SIZE_ZERO_BYTE:Number = -1;
private var SIZE_OK:Number = 0;
// Queue errors
private var ERROR_CODE_QUEUE_LIMIT_EXCEEDED:Number = -100;
private var ERROR_CODE_FILE_EXCEEDS_SIZE_LIMIT:Number = -110;
private var ERROR_CODE_ZERO_BYTE_FILE:Number = -120;
private var ERROR_CODE_INVALID_FILETYPE:Number = -130;
// Upload Errors
private var ERROR_CODE_HTTP_ERROR:Number = -200;
private var ERROR_CODE_MISSING_UPLOAD_URL:Number = -210;
private var ERROR_CODE_IO_ERROR:Number = -220;
private var ERROR_CODE_SECURITY_ERROR:Number = -230;
private var ERROR_CODE_UPLOAD_LIMIT_EXCEEDED:Number = -240;
private var ERROR_CODE_UPLOAD_FAILED:Number = -250;
private var ERROR_CODE_SPECIFIED_FILE_ID_NOT_FOUND:Number = -260;
private var ERROR_CODE_FILE_VALIDATION_FAILED:Number = -270;
private var ERROR_CODE_FILE_CANCELLED:Number = -280;
private var ERROR_CODE_UPLOAD_STOPPED:Number = -290;
// Button Actions
private var BUTTON_ACTION_SELECT_FILE:Number = -100;
private var BUTTON_ACTION_SELECT_FILES:Number = -110;
private var BUTTON_ACTION_START_UPLOAD:Number = -120;
private var BUTTON_CURSOR_ARROW:Number = -1;
private var BUTTON_CURSOR_HAND:Number = -2;
public function SWFUpload() {
// Do the feature detection. Make sure this version of Flash supports the features we need. If not
// abort initialization.
if (!flash.net.FileReferenceList || !flash.net.FileReference || !flash.net.URLRequest || !flash.external.ExternalInterface || !flash.external.ExternalInterface.available || !DataEvent.UPLOAD_COMPLETE_DATA) {
return;
}
// Keep Flash Player busy so it doesn't show the "flash script is running slowly" error
var counter:Number = 0;
root.addEventListener(Event.ENTER_FRAME, function ():void { if (++counter > 100) counter = 0; });
// Setup file FileReferenceList events
this.fileBrowserMany.addEventListener(Event.SELECT, this.Select_Many_Handler);
this.fileBrowserMany.addEventListener(Event.CANCEL, this.DialogCancelled_Handler);
this.stage.align = StageAlign.TOP_LEFT;
this.stage.scaleMode = StageScaleMode.NO_SCALE;
// Setup the button and text label
this.buttonLoader = new Loader();
var doNothing:Function = function ():void { };
this.buttonLoader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, doNothing );
this.buttonLoader.contentLoaderInfo.addEventListener(HTTPStatusEvent.HTTP_STATUS, doNothing );
this.stage.addChild(this.buttonLoader);
var self:SWFUpload = this;
this.stage.addEventListener(MouseEvent.CLICK, function (event:MouseEvent):void {
self.UpdateButtonState();
self.ButtonClickHandler(event);
});
this.stage.addEventListener(MouseEvent.MOUSE_DOWN, function (event:MouseEvent):void {
self.buttonStateMouseDown = true;
self.UpdateButtonState();
});
this.stage.addEventListener(MouseEvent.MOUSE_UP, function (event:MouseEvent):void {
self.buttonStateMouseDown = false;
self.UpdateButtonState();
});
this.stage.addEventListener(MouseEvent.MOUSE_OVER, function (event:MouseEvent):void {
self.buttonStateMouseDown = event.buttonDown;
self.buttonStateOver = true;
self.UpdateButtonState();
});
this.stage.addEventListener(MouseEvent.MOUSE_OUT, function (event:MouseEvent):void {
self.buttonStateMouseDown = false;
self.buttonStateOver = false;
self.UpdateButtonState();
});
// Handle the mouse leaving the flash movie altogether
this.stage.addEventListener(Event.MOUSE_LEAVE, function (event:Event):void {
self.buttonStateMouseDown = false;
self.buttonStateOver = false;
self.UpdateButtonState();
});
this.buttonTextField = new TextField();
this.buttonTextField.type = TextFieldType.DYNAMIC;
this.buttonTextField.antiAliasType = AntiAliasType.ADVANCED;
this.buttonTextField.autoSize = TextFieldAutoSize.NONE;
this.buttonTextField.cacheAsBitmap = true;
this.buttonTextField.multiline = true;
this.buttonTextField.wordWrap = false;
this.buttonTextField.tabEnabled = false;
this.buttonTextField.background = false;
this.buttonTextField.border = false;
this.buttonTextField.selectable = false;
this.buttonTextField.condenseWhite = true;
this.stage.addChild(this.buttonTextField);
this.buttonCursorSprite = new Sprite();
this.buttonCursorSprite.graphics.beginFill(0xFFFFFF, 0);
this.buttonCursorSprite.graphics.drawRect(0, 0, 1, 1);
this.buttonCursorSprite.graphics.endFill();
this.buttonCursorSprite.buttonMode = true;
this.buttonCursorSprite.x = 0;
this.buttonCursorSprite.y = 0;
this.buttonCursorSprite.addEventListener(MouseEvent.CLICK, doNothing);
this.stage.addChild(this.buttonCursorSprite);
// Get the movie name
this.movieName = root.loaderInfo.parameters.movieName || '';
this.movieName = this.movieName.replace(/[^a-zA-Z0-9\_\.\-]/g, "");
// **Configure the callbacks**
// The JavaScript tracks all the instances of SWFUpload on a page. We can access the instance
// associated with this SWF file using the movieName. Each callback is accessible by making
// a call directly to it on our instance. There is no error handling for undefined callback functions.
// A developer would have to deliberately remove the default functions,set the variable to null, or remove
// it from the init function.
this.flashReady_Callback = "SWFUpload.instances[\"" + this.movieName + "\"].flashReady";
this.fileDialogStart_Callback = "SWFUpload.instances[\"" + this.movieName + "\"].fileDialogStart";
this.fileQueued_Callback = "SWFUpload.instances[\"" + this.movieName + "\"].fileQueued";
this.fileQueueError_Callback = "SWFUpload.instances[\"" + this.movieName + "\"].fileQueueError";
this.fileDialogComplete_Callback = "SWFUpload.instances[\"" + this.movieName + "\"].fileDialogComplete";
this.uploadStart_Callback = "SWFUpload.instances[\"" + this.movieName + "\"].uploadStart";
this.uploadProgress_Callback = "SWFUpload.instances[\"" + this.movieName + "\"].uploadProgress";
this.uploadError_Callback = "SWFUpload.instances[\"" + this.movieName + "\"].uploadError";
this.uploadSuccess_Callback = "SWFUpload.instances[\"" + this.movieName + "\"].uploadSuccess";
this.uploadComplete_Callback = "SWFUpload.instances[\"" + this.movieName + "\"].uploadComplete";
this.debug_Callback = "SWFUpload.instances[\"" + this.movieName + "\"].debug";
this.testExternalInterface_Callback = "SWFUpload.instances[\"" + this.movieName + "\"].testExternalInterface";
this.cleanUp_Callback = "SWFUpload.instances[\"" + this.movieName + "\"].cleanUp";
// Get the Flash Vars
this.uploadURL = root.loaderInfo.parameters.uploadURL;
this.filePostName = root.loaderInfo.parameters.filePostName;
this.fileTypes = root.loaderInfo.parameters.fileTypes;
this.fileTypesDescription = root.loaderInfo.parameters.fileTypesDescription + " (" + this.fileTypes + ")";
this.loadPostParams(root.loaderInfo.parameters.params);
if (!this.filePostName) {
this.filePostName = "Filedata";
}
if (!this.fileTypes) {
this.fileTypes = "*.*";
}
if (!this.fileTypesDescription) {
this.fileTypesDescription = "All Files";
}
this.LoadFileExensions(this.fileTypes);
try {
this.debugEnabled = root.loaderInfo.parameters.debugEnabled == "true" ? true : false;
} catch (ex:Object) {
this.debugEnabled = false;
}
try {
this.SetFileSizeLimit(String(root.loaderInfo.parameters.fileSizeLimit));
} catch (ex:Object) {
this.fileSizeLimit = 0;
}
try {
this.fileUploadLimit = Number(root.loaderInfo.parameters.fileUploadLimit);
if (this.fileUploadLimit < 0) this.fileUploadLimit = 0;
} catch (ex:Object) {
this.fileUploadLimit = 0;
}
try {
this.fileQueueLimit = Number(root.loaderInfo.parameters.fileQueueLimit);
if (this.fileQueueLimit < 0) this.fileQueueLimit = 0;
} catch (ex:Object) {
this.fileQueueLimit = 0;
}
// Set the queue limit to match the upload limit when the queue limit is bigger than the upload limit
if (this.fileQueueLimit > this.fileUploadLimit && this.fileUploadLimit != 0) this.fileQueueLimit = this.fileUploadLimit;
// The the queue limit is unlimited and the upload limit is not then set the queue limit to the upload limit
if (this.fileQueueLimit == 0 && this.fileUploadLimit != 0) this.fileQueueLimit = this.fileUploadLimit;
try {
this.useQueryString = root.loaderInfo.parameters.useQueryString == "true" ? true : false;
} catch (ex:Object) {
this.useQueryString = false;
}
try {
this.requeueOnError = root.loaderInfo.parameters.requeueOnError == "true" ? true : false;
} catch (ex:Object) {
this.requeueOnError = false;
}
try {
this.SetHTTPSuccess(String(root.loaderInfo.parameters.httpSuccess));
} catch (ex:Object) {
this.SetHTTPSuccess([]);
}
try {
this.SetAssumeSuccessTimeout(Number(root.loaderInfo.parameters.assumeSuccessTimeout));
} catch (ex:Object) {
this.SetAssumeSuccessTimeout(0);
}
try {
this.SetButtonDimensions(Number(root.loaderInfo.parameters.buttonWidth), Number(root.loaderInfo.parameters.buttonHeight));
} catch (ex:Object) {
this.SetButtonDimensions(0, 0);
}
try {
this.SetButtonImageURL(String(root.loaderInfo.parameters.buttonImageURL));
} catch (ex:Object) {
this.SetButtonImageURL("");
}
try {
// HTML-escape strings that come from the user, preventing XSS.
this.SetButtonText(htmlEscape(String(root.loaderInfo.parameters.buttonText)));
} catch (ex:Object) {
this.SetButtonText("");
}
try {
this.SetButtonTextPadding(Number(root.loaderInfo.parameters.buttonTextLeftPadding), Number(root.loaderInfo.parameters.buttonTextTopPadding));
} catch (ex:Object) {
this.SetButtonTextPadding(0, 0);
}
try {
this.SetButtonTextStyle(String(root.loaderInfo.parameters.buttonTextStyle));
} catch (ex:Object) {
this.SetButtonTextStyle("");
}
try {
this.SetButtonAction(Number(root.loaderInfo.parameters.buttonAction));
} catch (ex:Object) {
this.SetButtonAction(this.BUTTON_ACTION_SELECT_FILES);
}
try {
this.SetButtonDisabled(root.loaderInfo.parameters.buttonDisabled == "true" ? true : false);
} catch (ex:Object) {
this.SetButtonDisabled(Boolean(false));
}
try {
this.SetButtonCursor(Number(root.loaderInfo.parameters.buttonCursor));
} catch (ex:Object) {
this.SetButtonCursor(this.BUTTON_CURSOR_ARROW);
}
this.SetupExternalInterface();
this.Debug("SWFUpload Init Complete");
this.PrintDebugInfo();
if (ExternalCall.Bool(this.testExternalInterface_Callback)) {
ExternalCall.Simple(this.flashReady_Callback);
this.hasCalledFlashReady = true;
}
// Start periodically checking the external interface
var oSelf:SWFUpload = this;
this.restoreExtIntTimer = new Timer(1000, 0);
this.restoreExtIntTimer.addEventListener(TimerEvent.TIMER, function ():void { oSelf.CheckExternalInterface();} );
this.restoreExtIntTimer.start();
}
// Used to periodically check that the External Interface functions are still working
private function CheckExternalInterface():void {
if (!ExternalCall.Bool(this.testExternalInterface_Callback)) {
this.SetupExternalInterface();
this.Debug("ExternalInterface reinitialized");
if (!this.hasCalledFlashReady) {
ExternalCall.Simple(this.flashReady_Callback);
this.hasCalledFlashReady = true;
}
}
}
// Called by JS to see if it can access the external interface
private function TestExternalInterface():Boolean {
return true;
}
private function SetupExternalInterface():void {
try {
ExternalInterface.addCallback("SelectFile", this.SelectFile);
ExternalInterface.addCallback("SelectFiles", this.SelectFiles);
ExternalInterface.addCallback("StartUpload", this.StartUpload);
ExternalInterface.addCallback("ReturnUploadStart", this.ReturnUploadStart);
ExternalInterface.addCallback("StopUpload", this.StopUpload);
ExternalInterface.addCallback("CancelUpload", this.CancelUpload);
ExternalInterface.addCallback("RequeueUpload", this.RequeueUpload);
ExternalInterface.addCallback("GetStats", this.GetStats);
ExternalInterface.addCallback("SetStats", this.SetStats);
ExternalInterface.addCallback("GetFile", this.GetFile);
ExternalInterface.addCallback("GetFileByIndex", this.GetFileByIndex);
ExternalInterface.addCallback("AddFileParam", this.AddFileParam);
ExternalInterface.addCallback("RemoveFileParam", this.RemoveFileParam);
ExternalInterface.addCallback("SetUploadURL", this.SetUploadURL);
ExternalInterface.addCallback("SetPostParams", this.SetPostParams);
ExternalInterface.addCallback("SetFileTypes", this.SetFileTypes);
ExternalInterface.addCallback("SetFileSizeLimit", this.SetFileSizeLimit);
ExternalInterface.addCallback("SetFileUploadLimit", this.SetFileUploadLimit);
ExternalInterface.addCallback("SetFileQueueLimit", this.SetFileQueueLimit);
ExternalInterface.addCallback("SetFilePostName", this.SetFilePostName);
ExternalInterface.addCallback("SetUseQueryString", this.SetUseQueryString);
ExternalInterface.addCallback("SetRequeueOnError", this.SetRequeueOnError);
ExternalInterface.addCallback("SetHTTPSuccess", this.SetHTTPSuccess);
ExternalInterface.addCallback("SetAssumeSuccessTimeout", this.SetAssumeSuccessTimeout);
ExternalInterface.addCallback("SetDebugEnabled", this.SetDebugEnabled);
ExternalInterface.addCallback("SetButtonImageURL", this.SetButtonImageURL);
ExternalInterface.addCallback("SetButtonDimensions", this.SetButtonDimensions);
ExternalInterface.addCallback("SetButtonText", this.SetButtonText);
ExternalInterface.addCallback("SetButtonTextPadding", this.SetButtonTextPadding);
ExternalInterface.addCallback("SetButtonTextStyle", this.SetButtonTextStyle);
ExternalInterface.addCallback("SetButtonAction", this.SetButtonAction);
ExternalInterface.addCallback("SetButtonDisabled", this.SetButtonDisabled);
ExternalInterface.addCallback("SetButtonCursor", this.SetButtonCursor);
ExternalInterface.addCallback("TestExternalInterface", this.TestExternalInterface);
} catch (ex:Error) {
this.Debug("Callbacks where not set: " + ex.message);
return;
}
ExternalCall.Simple(this.cleanUp_Callback);
}
/* *****************************************
* FileReference Event Handlers
* *************************************** */
private function DialogCancelled_Handler(event:Event):void {
this.Debug("Event: fileDialogComplete: File Dialog window cancelled.");
ExternalCall.FileDialogComplete(this.fileDialogComplete_Callback, 0, 0, this.queued_uploads);
}
private function Open_Handler(event:Event):void {
this.Debug("Event: uploadProgress (OPEN): File ID: " + this.current_file_item.id);
ExternalCall.UploadProgress(this.uploadProgress_Callback, this.current_file_item.ToJavaScriptObject(), 0, this.current_file_item.file_reference.size);
}
private function FileProgress_Handler(event:ProgressEvent):void {
// On early than Mac OS X 10.3 bytesLoaded is always -1, convert this to zero. Do bytesTotal for good measure.
// http://livedocs.adobe.com/flex/3/langref/flash/net/FileReference.html#event:progress
var bytesLoaded:Number = event.bytesLoaded < 0 ? 0 : event.bytesLoaded;
var bytesTotal:Number = event.bytesTotal < 0 ? 0 : event.bytesTotal;
// Because Flash never fires a complete event if the server doesn't respond after 30 seconds or on Macs if there
// is no content in the response we'll set a timer and assume that the upload is successful after the defined amount of
// time. If the timeout is zero then we won't use the timer.
if (bytesLoaded === bytesTotal && bytesTotal > 0 && this.assumeSuccessTimeout > 0) {
if (this.assumeSuccessTimer !== null) {
this.assumeSuccessTimer.stop();
this.assumeSuccessTimer = null;
}
this.assumeSuccessTimer = new Timer(this.assumeSuccessTimeout * 1000, 1);
this.assumeSuccessTimer.addEventListener(TimerEvent.TIMER_COMPLETE, AssumeSuccessTimer_Handler);
this.assumeSuccessTimer.start();
}
this.Debug("Event: uploadProgress: File ID: " + this.current_file_item.id + ". Bytes: " + bytesLoaded + ". Total: " + bytesTotal);
ExternalCall.UploadProgress(this.uploadProgress_Callback, this.current_file_item.ToJavaScriptObject(), bytesLoaded, bytesTotal);
}
private function AssumeSuccessTimer_Handler(event:TimerEvent):void {
this.Debug("Event: AssumeSuccess: " + this.assumeSuccessTimeout + " passed without server response");
this.UploadSuccess(this.current_file_item, "", false);
}
private function Complete_Handler(event:Event):void {
/* Because we can't do COMPLETE or DATA events (we have to do both) we can't
* just call uploadSuccess from the complete handler, we have to wait for
* the Data event which may never come. However, testing shows it always comes
* within a couple milliseconds if it is going to come so the solution is:
*
* Set a timer in the COMPLETE event (which always fires) and if DATA is fired
* it will stop the timer and call uploadComplete
*
* If the timer expires then DATA won't be fired and we call uploadComplete
* */
// Set the timer
if (serverDataTimer != null) {
this.serverDataTimer.stop();
this.serverDataTimer = null;
}
this.serverDataTimer = new Timer(100, 1);
//var self:SWFUpload = this;
this.serverDataTimer.addEventListener(TimerEvent.TIMER, this.ServerDataTimer_Handler);
this.serverDataTimer.start();
}
private function ServerDataTimer_Handler(event:TimerEvent):void {
this.UploadSuccess(this.current_file_item, "");
}
private function ServerData_Handler(event:DataEvent):void {
this.UploadSuccess(this.current_file_item, event.data);
}
private function UploadSuccess(file:FileItem, serverData:String, responseReceived:Boolean = true):void {
if (this.serverDataTimer !== null) {
this.serverDataTimer.stop();
this.serverDataTimer = null;
}
if (this.assumeSuccessTimer !== null) {
this.assumeSuccessTimer.stop();
this.assumeSuccessTimer = null;
}
this.successful_uploads++;
file.file_status = FileItem.FILE_STATUS_SUCCESS;
this.Debug("Event: uploadSuccess: File ID: " + file.id + " Response Received: " + responseReceived.toString() + " Data: " + serverData);
ExternalCall.UploadSuccess(this.uploadSuccess_Callback, file.ToJavaScriptObject(), serverData, responseReceived);
this.UploadComplete(false);
}
private function HTTPError_Handler(event:HTTPStatusEvent):void {
var isSuccessStatus:Boolean = false;
for (var i:Number = 0; i < this.httpSuccess.length; i++) {
if (this.httpSuccess[i] === event.status) {
isSuccessStatus = true;
break;
}
}
if (isSuccessStatus) {
this.Debug("Event: httpError: Translating status code " + event.status + " to uploadSuccess");
var serverDataEvent:DataEvent = new DataEvent(DataEvent.UPLOAD_COMPLETE_DATA, event.bubbles, event.cancelable, "");
this.ServerData_Handler(serverDataEvent);
} else {
this.upload_errors++;
this.current_file_item.file_status = FileItem.FILE_STATUS_ERROR;
this.Debug("Event: uploadError: HTTP ERROR : File ID: " + this.current_file_item.id + ". HTTP Status: " + event.status + ".");
ExternalCall.UploadError(this.uploadError_Callback, this.ERROR_CODE_HTTP_ERROR, this.current_file_item.ToJavaScriptObject(), event.status.toString());
this.UploadComplete(true); // An IO Error is also called so we don't want to complete the upload yet.
}
}
// Note: Flash Player does not support Uploads that require authentication. Attempting this will trigger an
// IO Error or it will prompt for a username and password and may crash the browser (FireFox/Opera)
private function IOError_Handler(event:IOErrorEvent):void {
// Only trigger an IO Error event if we haven't already done an HTTP error
if (this.current_file_item.file_status != FileItem.FILE_STATUS_ERROR) {
this.upload_errors++;
this.current_file_item.file_status = FileItem.FILE_STATUS_ERROR;
this.Debug("Event: uploadError : IO Error : File ID: " + this.current_file_item.id + ". IO Error: " + event.text);
ExternalCall.UploadError(this.uploadError_Callback, this.ERROR_CODE_IO_ERROR, this.current_file_item.ToJavaScriptObject(), event.text);
}
this.UploadComplete(true);
}
private function SecurityError_Handler(event:SecurityErrorEvent):void {
this.upload_errors++;
this.current_file_item.file_status = FileItem.FILE_STATUS_ERROR;
this.Debug("Event: uploadError : Security Error : File Number: " + this.current_file_item.id + ". Error text: " + event.text);
ExternalCall.UploadError(this.uploadError_Callback, this.ERROR_CODE_SECURITY_ERROR, this.current_file_item.ToJavaScriptObject(), event.text);
this.UploadComplete(true);
}
private function Select_Many_Handler(event:Event):void {
this.Select_Handler(this.fileBrowserMany.fileList);
}
private function Select_One_Handler(event:Event):void {
var fileArray:Array = new Array(1);
fileArray[0] = this.fileBrowserOne;
this.Select_Handler(fileArray);
}
private function Select_Handler(file_reference_list:Array):void {
this.Debug("Select Handler: Received the files selected from the dialog. Processing the file list...");
var num_files_queued:Number = 0;
// Determine how many queue slots are remaining (check the unlimited (0) settings, successful uploads and queued uploads)
var queue_slots_remaining:Number = 0;
if (this.fileUploadLimit == 0) {
queue_slots_remaining = this.fileQueueLimit == 0 ? file_reference_list.length : (this.fileQueueLimit - this.queued_uploads); // If unlimited queue make the allowed size match however many files were selected.
} else {
var remaining_uploads:Number = this.fileUploadLimit - this.successful_uploads - this.queued_uploads;
if (remaining_uploads < 0) remaining_uploads = 0;
if (this.fileQueueLimit == 0 || this.fileQueueLimit >= remaining_uploads) {
queue_slots_remaining = remaining_uploads;
} else if (this.fileQueueLimit < remaining_uploads) {
queue_slots_remaining = this.fileQueueLimit - this.queued_uploads;
}
}
if (queue_slots_remaining < 0) queue_slots_remaining = 0;
// Check if the number of files selected is greater than the number allowed to queue up.
if (queue_slots_remaining < file_reference_list.length) {
this.Debug("Event: fileQueueError : Selected Files (" + file_reference_list.length + ") exceeds remaining Queue size (" + queue_slots_remaining + ").");
ExternalCall.FileQueueError(this.fileQueueError_Callback, this.ERROR_CODE_QUEUE_LIMIT_EXCEEDED, null, queue_slots_remaining.toString());
} else {
// Process each selected file
for (var i:Number = 0; i < file_reference_list.length; i++) {
var file_item:FileItem = new FileItem(file_reference_list[i], this.movieName, this.file_index.length);
this.file_index[file_item.index] = file_item;
// Verify that the file is accessible. Zero byte files and possibly other conditions can cause a file to be inaccessible.
var jsFileObj:Object = file_item.ToJavaScriptObject();
var is_valid_file_reference:Boolean = (jsFileObj.filestatus !== FileItem.FILE_STATUS_ERROR);
if (is_valid_file_reference) {
// Check the size, if it's within the limit add it to the upload list.
var size_result:Number = this.CheckFileSize(file_item);
var is_valid_filetype:Boolean = this.CheckFileType(file_item);
if(size_result == this.SIZE_OK && is_valid_filetype) {
file_item.file_status = FileItem.FILE_STATUS_QUEUED;
this.file_queue.push(file_item);
this.queued_uploads++;
num_files_queued++;
this.Debug("Event: fileQueued : File ID: " + file_item.id);
ExternalCall.FileQueued(this.fileQueued_Callback, file_item.ToJavaScriptObject());
}
else if (!is_valid_filetype) {
file_item.file_reference = null; // Cleanup the object
this.queue_errors++;
this.Debug("Event: fileQueueError : File not of a valid type.");
ExternalCall.FileQueueError(this.fileQueueError_Callback, this.ERROR_CODE_INVALID_FILETYPE, file_item.ToJavaScriptObject(), "File is not an allowed file type.");
}
else if (size_result == this.SIZE_TOO_BIG) {
file_item.file_reference = null; // Cleanup the object
this.queue_errors++;
this.Debug("Event: fileQueueError : File exceeds size limit.");
ExternalCall.FileQueueError(this.fileQueueError_Callback, this.ERROR_CODE_FILE_EXCEEDS_SIZE_LIMIT, file_item.ToJavaScriptObject(), "File size exceeds allowed limit.");
}
else if (size_result == this.SIZE_ZERO_BYTE) {
file_item.file_reference = null; // Cleanup the object
this.queue_errors++;
this.Debug("Event: fileQueueError : File is zero bytes.");
ExternalCall.FileQueueError(this.fileQueueError_Callback, this.ERROR_CODE_ZERO_BYTE_FILE, file_item.ToJavaScriptObject(), "File is zero bytes and cannot be uploaded.");
}
} else {
file_item.file_reference = null; // Cleanup the object
this.queue_errors++;
this.Debug("Event: fileQueueError : File is zero bytes or FileReference is invalid.");
ExternalCall.FileQueueError(this.fileQueueError_Callback, this.ERROR_CODE_ZERO_BYTE_FILE, file_item.ToJavaScriptObject(), "File is zero bytes or cannot be accessed and cannot be uploaded.");
}
}
}
this.Debug("Event: fileDialogComplete : Finished processing selected files. Files selected: " + file_reference_list.length + ". Files Queued: " + num_files_queued);
ExternalCall.FileDialogComplete(this.fileDialogComplete_Callback, file_reference_list.length, num_files_queued, this.queued_uploads);
}
/* ****************************************************************
Externally exposed functions
****************************************************************** */
// Opens a file browser dialog that allows one file to be selected.
private function SelectFile():void {
this.fileBrowserOne = new FileReference();
this.fileBrowserOne.addEventListener(Event.SELECT, this.Select_One_Handler);
this.fileBrowserOne.addEventListener(Event.CANCEL, this.DialogCancelled_Handler);
// Default file type settings
var allowed_file_types:String = "*.*";
var allowed_file_types_description:String = "All Files";
// Get the instance settings
if (this.fileTypes.length > 0) allowed_file_types = this.fileTypes;
if (this.fileTypesDescription.length > 0) allowed_file_types_description = this.fileTypesDescription;
this.Debug("Event: fileDialogStart : Browsing files. Single Select. Allowed file types: " + allowed_file_types);
ExternalCall.Simple(this.fileDialogStart_Callback);
try {
this.fileBrowserOne.browse([new FileFilter(allowed_file_types_description, allowed_file_types)]);
} catch (ex:Error) {
this.Debug("Exception: " + ex.toString());
}
}
// Opens a file browser dialog that allows multiple files to be selected.
private function SelectFiles():void {
var allowed_file_types:String = "*.*";
var allowed_file_types_description:String = "All Files";
if (this.fileTypes.length > 0) allowed_file_types = this.fileTypes;
if (this.fileTypesDescription.length > 0) allowed_file_types_description = this.fileTypesDescription;
this.Debug("Event: fileDialogStart : Browsing files. Multi Select. Allowed file types: " + allowed_file_types);
ExternalCall.Simple(this.fileDialogStart_Callback);
try {
this.fileBrowserMany.browse([new FileFilter(allowed_file_types_description, allowed_file_types)]);
} catch (ex:Error) {
this.Debug("Exception: " + ex.toString());
}
}
// Cancel the current upload and stops. Doesn't advance the upload pointer. The current file is requeued at the beginning.
private function StopUpload():void {
if (this.current_file_item != null) {
// Cancel the upload and re-queue the FileItem
this.current_file_item.file_reference.cancel();
// Remove the event handlers
this.removeFileReferenceEventListeners(this.current_file_item);
this.current_file_item.file_status = FileItem.FILE_STATUS_QUEUED;
this.file_queue.unshift(this.current_file_item);
var js_object:Object = this.current_file_item.ToJavaScriptObject();
this.current_file_item = null;
this.Debug("Event: uploadError: upload stopped. File ID: " + js_object.ID);
ExternalCall.UploadError(this.uploadError_Callback, this.ERROR_CODE_UPLOAD_STOPPED, js_object, "Upload Stopped");
this.Debug("Event: uploadComplete. File ID: " + js_object.ID);
ExternalCall.UploadComplete(this.uploadComplete_Callback, js_object);
this.Debug("StopUpload(): upload stopped.");
} else {
this.Debug("StopUpload(): No file is currently uploading. Nothing to do.");
}
}
/* Cancels the upload specified by file_id
* If the file is currently uploading it is cancelled and the uploadComplete
* event gets called.
* If the file is not currently uploading then only the uploadCancelled event is fired.
* */
private function CancelUpload(file_id:String, triggerErrorEvent:Boolean = true):void {
var file_item:FileItem = null;
// Check the current file item
if (this.current_file_item != null && (this.current_file_item.id == file_id || !file_id)) {
this.current_file_item.file_reference.cancel();
this.current_file_item.file_status = FileItem.FILE_STATUS_CANCELLED;
this.upload_cancelled++;
if (triggerErrorEvent) {
this.Debug("Event: uploadError: File ID: " + this.current_file_item.id + ". Cancelled current upload");
ExternalCall.UploadError(this.uploadError_Callback, this.ERROR_CODE_FILE_CANCELLED, this.current_file_item.ToJavaScriptObject(), "File Upload Cancelled.");
} else {
this.Debug("Event: cancelUpload: File ID: " + this.current_file_item.id + ". Cancelled current upload. Suppressed uploadError event.");
}
this.UploadComplete(false);
} else if (file_id) {
// Find the file in the queue
var file_index:Number = this.FindIndexInFileQueue(file_id);
if (file_index >= 0) {
// Remove the file from the queue
file_item = FileItem(this.file_queue[file_index]);
file_item.file_status = FileItem.FILE_STATUS_CANCELLED;
this.file_queue[file_index] = null;
this.queued_uploads--;
this.upload_cancelled++;
// Cancel the file (just for good measure) and make the callback
file_item.file_reference.cancel();
this.removeFileReferenceEventListeners(file_item);
file_item.file_reference = null;
if (triggerErrorEvent) {
this.Debug("Event: uploadError : " + file_item.id + ". Cancelled queued upload");
ExternalCall.UploadError(this.uploadError_Callback, this.ERROR_CODE_FILE_CANCELLED, file_item.ToJavaScriptObject(), "File Cancelled");
} else {
this.Debug("Event: cancelUpload: File ID: " + file_item.id + ". Cancelled current upload. Suppressed uploadError event.");
}
// Get rid of the file object
file_item = null;
}
} else {
// Get the first file and cancel it
while (this.file_queue.length > 0 && file_item == null) {
// Check that File Reference is valid (if not make sure it's deleted and get the next one on the next loop)
file_item = FileItem(this.file_queue.shift()); // Cast back to a FileItem
if (typeof(file_item) == "undefined") {
file_item = null;
continue;
}
}
if (file_item != null) {
file_item.file_status = FileItem.FILE_STATUS_CANCELLED;
this.queued_uploads--;
this.upload_cancelled++;
// Cancel the file (just for good measure) and make the callback
file_item.file_reference.cancel();
this.removeFileReferenceEventListeners(file_item);
file_item.file_reference = null;
if (triggerErrorEvent) {
this.Debug("Event: uploadError : " + file_item.id + ". Cancelled queued upload");
ExternalCall.UploadError(this.uploadError_Callback, this.ERROR_CODE_FILE_CANCELLED, file_item.ToJavaScriptObject(), "File Cancelled");
} else {
this.Debug("Event: cancelUpload: File ID: " + file_item.id + ". Cancelled current upload. Suppressed uploadError event.");
}
// Get rid of the file object
file_item = null;
}
}
}
/* Requeues the indicated file. Returns true if successful or if the file is
* already in the queue. Otherwise returns false.
* */
private function RequeueUpload(fileIdentifier:*):Boolean {
var file:FileItem = null;
if (typeof(fileIdentifier) === "number") {
var fileIndex:Number = Number(fileIdentifier);
if (fileIndex >= 0 && fileIndex < this.file_index.length) {
file = this.file_index[fileIndex];
}
} else if (typeof(fileIdentifier) === "string") {
file = FindFileInFileIndex(String(fileIdentifier));
} else {
return false;
}
if (file !== null) {
if (file.file_status === FileItem.FILE_STATUS_IN_PROGRESS || file.file_status === FileItem.FILE_STATUS_NEW) {
return false;
} else if (file.file_status !== FileItem.FILE_STATUS_QUEUED) {
file.file_status = FileItem.FILE_STATUS_QUEUED;
this.file_queue.unshift(file);
this.queued_uploads++;
}
return true;
} else {
return false;
}
}
private function GetStats():Object {
return {
in_progress : this.current_file_item == null ? 0 : 1,
files_queued : this.queued_uploads,
successful_uploads : this.successful_uploads,
upload_errors : this.upload_errors,
upload_cancelled : this.upload_cancelled,
queue_errors : this.queue_errors
};
}
private function SetStats(stats:Object):void {
this.successful_uploads = typeof(stats["successful_uploads"]) === "number" ? stats["successful_uploads"] : this.successful_uploads;
this.upload_errors = typeof(stats["upload_errors"]) === "number" ? stats["upload_errors"] : this.upload_errors;
this.upload_cancelled = typeof(stats["upload_cancelled"]) === "number" ? stats["upload_cancelled"] : this.upload_cancelled;
this.queue_errors = typeof(stats["queue_errors"]) === "number" ? stats["queue_errors"] : this.queue_errors;
}
private function GetFile(file_id:String):Object {
var file_index:Number = this.FindIndexInFileQueue(file_id);
if (file_index >= 0) {
var file:FileItem = this.file_queue[file_index];
} else {
if (this.current_file_item != null) {
file = this.current_file_item;
} else {
for (var i:Number = 0; i < this.file_queue.length; i++) {
file = this.file_queue[i];
if (file != null) break;
}
}
}
if (file == null) {
return null;
} else {
return file.ToJavaScriptObject();
}
}
private function GetFileByIndex(index:Number):Object {
if (index < 0 || index > this.file_index.length - 1) {
return null;
} else {
return this.file_index[index].ToJavaScriptObject();
}
}
private function AddFileParam(file_id:String, name:String, value:String):Boolean {
var item:FileItem = this.FindFileInFileIndex(file_id);
if (item != null) {
item.AddParam(name, value);
return true;
}
else {
return false;
}
}
private function RemoveFileParam(file_id:String, name:String):Boolean {
var item:FileItem = this.FindFileInFileIndex(file_id);
if (item != null) {
item.RemoveParam(name);
return true;
}
else {
return false;
}
}
private function SetUploadURL(url:String):void {
if (typeof(url) !== "undefined" && url !== "") {
this.uploadURL = url;
}
}
private function SetPostParams(post_object:Object):void {
if (typeof(post_object) !== "undefined" && post_object !== null) {
this.uploadPostObject = post_object;
}
}
private function SetFileTypes(types:String, description:String):void {
this.fileTypes = types;
this.fileTypesDescription = description;
this.LoadFileExensions(this.fileTypes);
}
// Sets the file size limit. Accepts size values with units: 100 b, 1KB, 23Mb, 4 Gb
// Parsing is not robust. "100 200 MB KB B GB" parses as "100 MB"
private function SetFileSizeLimit(size:String):void {
var value:Number = 0;
var unit:String = "kb";
// Trim the string
var trimPattern:RegExp = /^\s*|\s*$/;
size = size.toLowerCase();
size = size.replace(trimPattern, "");
// Get the value part
var values:Array = size.match(/^\d+/);
if (values !== null && values.length > 0) {
value = parseInt(values[0]);
}
if (isNaN(value) || value < 0) value = 0;
// Get the units part
var units:Array = size.match(/(b|kb|mb|gb)/);
if (units != null && units.length > 0) {
unit = units[0];
}
// Set the multiplier for converting the unit to bytes
var multiplier:Number = 1024;
if (unit === "b")
multiplier = 1;
else if (unit === "mb")
multiplier = 1048576;
else if (unit === "gb")
multiplier = 1073741824;
this.fileSizeLimit = value * multiplier;
}
private function SetFileUploadLimit(file_upload_limit:Number):void {
if (file_upload_limit < 0) file_upload_limit = 0;
this.fileUploadLimit = file_upload_limit;
}
private function SetFileQueueLimit(file_queue_limit:Number):void {
if (file_queue_limit < 0) file_queue_limit = 0;
this.fileQueueLimit = file_queue_limit;
}
private function SetFilePostName(file_post_name:String):void {
if (file_post_name != "") {
this.filePostName = file_post_name;
}
}
private function SetUseQueryString(use_query_string:Boolean):void {
this.useQueryString = use_query_string;
}
private function SetRequeueOnError(requeue_on_error:Boolean):void {
this.requeueOnError = requeue_on_error;
}
private function SetHTTPSuccess(http_status_codes:*):void {
this.httpSuccess = [];
if (typeof http_status_codes === "string") {
var status_code_strings:Array = http_status_codes.replace(" ", "").split(",");
for each (var http_status_string:String in status_code_strings)
{
try {
this.httpSuccess.push(Number(http_status_string));
} catch (ex:Object) {
// Ignore errors
this.Debug("Could not add HTTP Success code: " + http_status_string);
}
}
}
else if (typeof http_status_codes === "object" && typeof http_status_codes.length === "number") {
for each (var http_status:* in http_status_codes)
{
try {
this.Debug("adding: " + http_status);
this.httpSuccess.push(Number(http_status));
} catch (ex:Object) {
this.Debug("Could not add HTTP Success code: " + http_status);
}
}
}
}
private function SetAssumeSuccessTimeout(timeout_seconds:Number):void {
this.assumeSuccessTimeout = timeout_seconds < 0 ? 0 : timeout_seconds;
}
private function SetDebugEnabled(debug_enabled:Boolean):void {
this.debugEnabled = debug_enabled;
}
/* *************************************************************
Button Handling Functions
*************************************************************** */
private function SetButtonImageURL(button_image_url:String):void {
this.buttonImageURL = button_image_url;
try {
if (this.buttonImageURL !== null && this.buttonImageURL !== "") {
this.buttonLoader.load(new URLRequest(this.buttonImageURL));
}
} catch (ex:Object) {
}
}
private function ButtonClickHandler(e:MouseEvent):void {
if (!this.buttonStateDisabled) {
if (this.buttonAction === this.BUTTON_ACTION_SELECT_FILE) {
this.SelectFile();
}
else if (this.buttonAction === this.BUTTON_ACTION_START_UPLOAD) {
this.StartUpload();
}
else {
this.SelectFiles();
}
}
}
private function UpdateButtonState():void {
var xOffset:Number = 0;
var yOffset:Number = 0;
this.buttonLoader.x = xOffset;
this.buttonLoader.y = yOffset;
if (this.buttonStateDisabled) {
this.buttonLoader.y = this.buttonHeight * -3 + yOffset;
}
else if (this.buttonStateMouseDown) {
this.buttonLoader.y = this.buttonHeight * -2 + yOffset;
}
else if (this.buttonStateOver) {
this.buttonLoader.y = this.buttonHeight * -1 + yOffset;
}
else {
this.buttonLoader.y = -yOffset;
}
};
private function SetButtonDimensions(width:Number = -1, height:Number = -1):void {
if (width >= 0) {
this.buttonWidth = width;
}
if (height >= 0) {
this.buttonHeight = height;
}
this.buttonTextField.width = this.buttonWidth;
this.buttonTextField.height = this.buttonHeight;
this.buttonCursorSprite.width = this.buttonWidth;
this.buttonCursorSprite.height = this.buttonHeight;
this.UpdateButtonState();
}
private function SetButtonText(button_text:String):void {
this.buttonText = button_text;
this.SetButtonTextStyle(this.buttonTextStyle);
}
private function SetButtonTextStyle(button_text_style:String):void {
this.buttonTextStyle = button_text_style;
var style:StyleSheet = new StyleSheet();
style.parseCSS(this.buttonTextStyle);
this.buttonTextField.styleSheet = style;
this.buttonTextField.htmlText = '' + this.buttonText + '';
}
private function SetButtonTextPadding(left:Number, top:Number):void {
this.buttonTextField.x = this.buttonTextLeftPadding = left;
this.buttonTextField.y = this.buttonTextTopPadding = top;
}
private function SetButtonDisabled(disabled:Boolean):void {
this.buttonStateDisabled = disabled;
this.UpdateButtonState();
}
private function SetButtonAction(button_action:Number):void {
this.buttonAction = button_action;
}
private function SetButtonCursor(button_cursor:Number):void {
this.buttonCursor = button_cursor;
this.buttonCursorSprite.useHandCursor = (button_cursor === this.BUTTON_CURSOR_HAND);
}
/* *************************************************************
File processing and handling functions
*************************************************************** */
private function StartUpload(file_id:String = ""):void {
// Only upload a file uploads are being processed.
if (this.current_file_item != null) {
this.Debug("StartUpload(): Upload already in progress. Not starting another upload.");
return;
}
this.Debug("StartUpload: " + (file_id ? "File ID: " + file_id : "First file in queue"));
// Check the upload limit
if (this.successful_uploads >= this.fileUploadLimit && this.fileUploadLimit != 0) {
this.Debug("Event: uploadError : Upload limit reached. No more files can be uploaded.");
ExternalCall.UploadError(this.uploadError_Callback, this.ERROR_CODE_UPLOAD_LIMIT_EXCEEDED, null, "The upload limit has been reached.");
this.current_file_item = null;
return;
}
// Get the next file to upload
if (!file_id) {
while (this.file_queue.length > 0 && this.current_file_item == null) {
this.current_file_item = FileItem(this.file_queue.shift());
if (typeof(this.current_file_item) == "undefined") {
this.current_file_item = null;
}
}
} else {
var file_index:Number = this.FindIndexInFileQueue(file_id);
if (file_index >= 0) {
// Set the file as the current upload and remove it from the queue
this.current_file_item = FileItem(this.file_queue[file_index]);
this.file_queue[file_index] = null;
} else {
this.Debug("Event: uploadError : File ID not found in queue: " + file_id);
ExternalCall.UploadError(this.uploadError_Callback, this.ERROR_CODE_SPECIFIED_FILE_ID_NOT_FOUND, null, "File ID not found in the queue.");
}
}
if (this.current_file_item != null) {
// Trigger the uploadStart event which will call ReturnUploadStart to begin the actual upload
this.Debug("Event: uploadStart : File ID: " + this.current_file_item.id);
this.current_file_item.file_status = FileItem.FILE_STATUS_IN_PROGRESS;
ExternalCall.UploadStart(this.uploadStart_Callback, this.current_file_item.ToJavaScriptObject());
}
// Otherwise we've would have looped through all the FileItems. This means the queue is empty)
else {
this.Debug("StartUpload(): No files found in the queue.");
}
}
// This starts the upload when the user returns TRUE from the uploadStart event. Rather than just have the value returned from
// the function we do a return function call so we can use the setTimeout work-around for Flash/JS circular calls.
private function ReturnUploadStart(start_upload:Boolean):void {
if (this.current_file_item == null) {
this.Debug("ReturnUploadStart called but no file was prepped for uploading. The file may have been cancelled or stopped.");
return;
}
var js_object:Object;
if (start_upload) {
try {
// Set the event handlers
this.current_file_item.file_reference.addEventListener(Event.OPEN, this.Open_Handler);
this.current_file_item.file_reference.addEventListener(ProgressEvent.PROGRESS, this.FileProgress_Handler);
this.current_file_item.file_reference.addEventListener(IOErrorEvent.IO_ERROR, this.IOError_Handler);
this.current_file_item.file_reference.addEventListener(SecurityErrorEvent.SECURITY_ERROR, this.SecurityError_Handler);
this.current_file_item.file_reference.addEventListener(HTTPStatusEvent.HTTP_STATUS, this.HTTPError_Handler);
this.current_file_item.file_reference.addEventListener(Event.COMPLETE, this.Complete_Handler);
this.current_file_item.file_reference.addEventListener(DataEvent.UPLOAD_COMPLETE_DATA, this.ServerData_Handler);
// Get the request (post values, etc)
var request:URLRequest = this.BuildRequest();
if (this.uploadURL.length == 0) {
this.Debug("Event: uploadError : IO Error : File ID: " + this.current_file_item.id + ". Upload URL string is empty.");
// Remove the event handlers
this.removeFileReferenceEventListeners(this.current_file_item);
this.current_file_item.file_status = FileItem.FILE_STATUS_QUEUED;
this.file_queue.unshift(this.current_file_item);
js_object = this.current_file_item.ToJavaScriptObject();
this.current_file_item = null;
ExternalCall.UploadError(this.uploadError_Callback, this.ERROR_CODE_MISSING_UPLOAD_URL, js_object, "Upload URL string is empty.");
} else {
this.Debug("ReturnUploadStart(): File accepted by startUpload event and readied for upload. Starting upload to " + request.url + " for File ID: " + this.current_file_item.id);
this.current_file_item.file_status = FileItem.FILE_STATUS_IN_PROGRESS;
this.current_file_item.file_reference.upload(request, this.filePostName, false);
}
} catch (ex:Error) {
this.Debug("ReturnUploadStart: Exception occurred: " + message);
this.upload_errors++;
this.current_file_item.file_status = FileItem.FILE_STATUS_ERROR;
var message:String = ex.errorID + "\n" + ex.name + "\n" + ex.message + "\n" + ex.getStackTrace();
this.Debug("Event: uploadError(): Upload Failed. Exception occurred: " + message);
ExternalCall.UploadError(this.uploadError_Callback, this.ERROR_CODE_UPLOAD_FAILED, this.current_file_item.ToJavaScriptObject(), message);
this.UploadComplete(true);
}
} else {
// Remove the event handlers
this.removeFileReferenceEventListeners(this.current_file_item);
// Re-queue the FileItem
this.current_file_item.file_status = FileItem.FILE_STATUS_QUEUED;
js_object = this.current_file_item.ToJavaScriptObject();
this.file_queue.unshift(this.current_file_item);
this.current_file_item = null;
this.Debug("Event: uploadError : Call to uploadStart returned false. Not uploading the file.");
ExternalCall.UploadError(this.uploadError_Callback, this.ERROR_CODE_FILE_VALIDATION_FAILED, js_object, "Call to uploadStart return false. Not uploading file.");
this.Debug("Event: uploadComplete : Call to uploadStart returned false. Not uploading the file.");
ExternalCall.UploadComplete(this.uploadComplete_Callback, js_object);
}
}
// Completes the file upload by deleting it's reference, advancing the pointer.
// Once this event fires a new upload can be started.
private function UploadComplete(eligible_for_requeue:Boolean):void {
var jsFileObj:Object = this.current_file_item.ToJavaScriptObject();
this.removeFileReferenceEventListeners(this.current_file_item);
if (!eligible_for_requeue || this.requeueOnError == false) {
this.current_file_item.file_reference = null;
this.queued_uploads--;
} else if (this.requeueOnError == true) {
this.current_file_item.file_status = FileItem.FILE_STATUS_QUEUED;
this.file_queue.unshift(this.current_file_item);
}
this.current_file_item = null;
this.Debug("Event: uploadComplete : Upload cycle complete.");
ExternalCall.UploadComplete(this.uploadComplete_Callback, jsFileObj);
}
/* *************************************************************
Utility Functions
*************************************************************** */
// Check the size of the file against the allowed file size. If it is less the return TRUE. If it is too large return FALSE
private function CheckFileSize(file_item:FileItem):Number {
if (file_item.file_reference.size == 0) {
return this.SIZE_ZERO_BYTE;
} else if (this.fileSizeLimit != 0 && file_item.file_reference.size > this.fileSizeLimit) {
return this.SIZE_TOO_BIG;
} else {
return this.SIZE_OK;
}
}
private function CheckFileType(file_item:FileItem):Boolean {
// If no extensions are defined then a *.* was passed and the check is unnecessary
if (this.valid_file_extensions.length == 0) {
return true;
}
var fileRef:FileReference = file_item.file_reference;
var last_dot_index:Number = fileRef.name.lastIndexOf(".");
var extension:String = "";
if (last_dot_index >= 0) {
extension = fileRef.name.substr(last_dot_index + 1).toLowerCase();
}
var is_valid_filetype:Boolean = false;
for (var i:Number=0; i < this.valid_file_extensions.length; i++) {
if (String(this.valid_file_extensions[i]) == extension) {
is_valid_filetype = true;
break;
}
}
return is_valid_filetype;
}
private function BuildRequest():URLRequest {
// Create the request object
var request:URLRequest = new URLRequest();
request.method = URLRequestMethod.POST;
var file_post:Object = this.current_file_item.GetPostObject();
if (this.useQueryString) {
var pairs:Array = new Array();
for (key in this.uploadPostObject) {
this.Debug("Global URL Item: " + key + "=" + this.uploadPostObject[key]);
if (this.uploadPostObject.hasOwnProperty(key)) {
pairs.push(escape(key) + "=" + escape(this.uploadPostObject[key]));
}
}
for (key in file_post) {
this.Debug("File Post Item: " + key + "=" + file_post[key]);
if (file_post.hasOwnProperty(key)) {
pairs.push(escape(key) + "=" + escape(file_post[key]));
}
}
request.url = this.uploadURL + (this.uploadURL.indexOf("?") > -1 ? "&" : "?") + pairs.join("&");
} else {
var key:String;
var post:URLVariables = new URLVariables();
for (key in this.uploadPostObject) {
this.Debug("Global Post Item: " + key + "=" + this.uploadPostObject[key]);
if (this.uploadPostObject.hasOwnProperty(key)) {
post[key] = this.uploadPostObject[key];
}
}
for (key in file_post) {
this.Debug("File Post Item: " + key + "=" + file_post[key]);
if (file_post.hasOwnProperty(key)) {
post[key] = file_post[key];
}
}
request.url = this.uploadURL;
request.data = post;
}
return request;
}
private function Debug(msg:String):void {
try {
if (this.debugEnabled) {
var lines:Array = msg.split("\n");
for (var i:Number=0; i < lines.length; i++) {
lines[i] = "SWF DEBUG: " + lines[i];
}
ExternalCall.Debug(this.debug_Callback, lines.join("\n"));
}
} catch (ex:Error) {
// pretend nothing happened
trace(ex);
}
}
private function PrintDebugInfo():void {
var debug_info:String = "\n----- SWF DEBUG OUTPUT ----\n";
debug_info += "Build Number: " + this.build_number + "\n";
debug_info += "movieName: " + this.movieName + "\n";
debug_info += "Upload URL: " + this.uploadURL + "\n";
debug_info += "File Types String: " + this.fileTypes + "\n";
debug_info += "Parsed File Types: " + this.valid_file_extensions.toString() + "\n";
debug_info += "HTTP Success: " + this.httpSuccess.join(", ") + "\n";
debug_info += "File Types Description: " + this.fileTypesDescription + "\n";
debug_info += "File Size Limit: " + this.fileSizeLimit + " bytes\n";
debug_info += "File Upload Limit: " + this.fileUploadLimit + "\n";
debug_info += "File Queue Limit: " + this.fileQueueLimit + "\n";
debug_info += "Post Params:\n";
for (var key:String in this.uploadPostObject) {
if (this.uploadPostObject.hasOwnProperty(key)) {
debug_info += " " + key + "=" + this.uploadPostObject[key] + "\n";
}
}
debug_info += "----- END SWF DEBUG OUTPUT ----\n";
this.Debug(debug_info);
}
private function FindIndexInFileQueue(file_id:String):Number {
for (var i:Number = 0; i < this.file_queue.length; i++) {
var item:FileItem = this.file_queue[i];
if (item != null && item.id == file_id) return i;
}
return -1;
}
private function FindFileInFileIndex(file_id:String):FileItem {
for (var i:Number = 0; i < this.file_index.length; i++) {
var item:FileItem = this.file_index[i];
if (item != null && item.id == file_id) return item;
}
return null;
}
// Parse the file extensions in to an array so we can validate them agains
// the files selected later.
private function LoadFileExensions(filetypes:String):void {
var extensions:Array = filetypes.split(";");
this.valid_file_extensions = new Array();
for (var i:Number=0; i < extensions.length; i++) {
var extension:String = String(extensions[i]);
var dot_index:Number = extension.lastIndexOf(".");
if (dot_index >= 0) {
extension = extension.substr(dot_index + 1).toLowerCase();
} else {
extension = extension.toLowerCase();
}
// If one of the extensions is * then we allow all files
if (extension == "*") {
this.valid_file_extensions = new Array();
break;
}
this.valid_file_extensions.push(extension);
}
}
private function loadPostParams(param_string:String):void {
var post_object:Object = {};
if (param_string != null) {
var name_value_pairs:Array = param_string.split("&");
for (var i:Number = 0; i < name_value_pairs.length; i++) {
var name_value:String = String(name_value_pairs[i]);
var index_of_equals:Number = name_value.indexOf("=");
if (index_of_equals > 0) {
post_object[decodeURIComponent(name_value.substring(0, index_of_equals))] = decodeURIComponent(name_value.substr(index_of_equals + 1));
}
}
}
this.uploadPostObject = post_object;
}
private function removeFileReferenceEventListeners(file_item:FileItem):void {
if (file_item != null && file_item.file_reference != null) {
file_item.file_reference.removeEventListener(Event.OPEN, this.Open_Handler);
file_item.file_reference.removeEventListener(ProgressEvent.PROGRESS, this.FileProgress_Handler);
file_item.file_reference.removeEventListener(IOErrorEvent.IO_ERROR, this.IOError_Handler);
file_item.file_reference.removeEventListener(SecurityErrorEvent.SECURITY_ERROR, this.SecurityError_Handler);
file_item.file_reference.removeEventListener(HTTPStatusEvent.HTTP_STATUS, this.HTTPError_Handler);
file_item.file_reference.removeEventListener(DataEvent.UPLOAD_COMPLETE_DATA, this.ServerData_Handler);
}
}
public function htmlEscape(str:String):String {
return XML( new XMLNode( XMLNodeType.TEXT_NODE, str ) ).toXMLString();
}
}
}
libjs-swfupload_2.2.0.1+ds2/Documentation/ 0002755 0001750 0001750 00000000000 12203733526 017641 5 ustar gawain gawain libjs-swfupload_2.2.0.1+ds2/Documentation/index.html 0000644 0001750 0001750 00000206152 12203733526 021642 0 ustar gawain gawain
SWFUpload v2 Documentation
SWFUpload is a client-side file upload tool originally developed by Vinterwebb.se. It uses a combination of Flash and JavaScript to
provide file upload functionality beyond what the basic browser provides with the <input type="file" /> tag.
The main features that SWFUpload provides are:
The ability to select multiple files in the file browser dialog.
AJAX-style uploading without a page refresh.
Upload progress events.
Namespaced classes compatible with other JavaScript libraries (i.e., jQuery, Prototype, etc.).
Flash 9 and Flash 10 support. (Flash 8 support dropped in version 2.2.0)
SWFUpload is different from other Flash based upload tools because of the philosophy
behind its design. SWFUpload gives developers control by leaving the UI in the browser (as much as possible).
Developers can use XHTML, CSS, and JavaScript to tailor the upload UI to the needs and
style of their site. Upload status updates are made through a set of simple JavaScript events.
The developer uses these events to update the webpage as the file upload progresses.
Unfortunately Flash Player 10 has forced us have one button in a flash movie in order to trigger the file browser dialog window. SWFUpload
still empowers the devloper by provding the ability the button and overlay text from JavaScript.
SWFUpload v2
SWFUpload v2 includes new advanced features, improved stability, Flash Player
bug work-arounds and a helpful set of Plug-ins. New features include:
Flash Player 10 security compatibility.
The ability to send additional POST values with the uploads.
Sending per file POST values.
Complete set of events.
All settings dynamically updateable.
Retrieve result data from the server.
Stop an upload without cancelling.
Upload files in any order.
Multi- & Single-file selection dialogs.
Queue size, files uploaded and file size limits.
Properly handling of zero-byte files.
Pre-upload validation event.
Work-arounds for bugs in Flash and Browser.
Overview
HTML Upload
The standard HTML upload input box provides a box and a button to the user for selecting a file.
The file is submitted with the form. The entire file must be uploaded before the next
page is displayed. No pre-upload validation can be made on the file (e.g., file size limits or valid extensions).
Very little feedback is given to the user while the file uploads.
The usage pattern for standard HTML uploads is simple, straight forward, and supported by nearly all browser.
SWFUpload
SWFUpload uses a Flash movie to handle file selection and upload. A customizable button is displayed by the
Flash movie that activates Flashes advanced file selection dialog window.
The file selection dialog is configured to allow the user select to a single file or multiple files.
The file types can be restricted so users only select the appropriate files (e.g., *.jpg;*.gif).
Once selected each file is validated and queued. As the file is uploaded by Flash
several JavaScript events are fired which the developer handles in order to update the page's UI allowing you to provide
upload status and error messages in real-time.
The uploaded file is submitted separately from the rest of the page and form. Each file is uploaded
individually keeping the server-side upload handling script simple. Since Flash is providing the upload
service the page does not have to be submitted or reloaded. The usage pattern for SWFUpload is more
like that of an AJAX application than that of a standard HTML form. The page's form will be processed
separately from the file upload.
Getting Started
SWFUpload is not a drag & drop upload control. It requires knowledge of JavaScript and the DOM. Several demos are available that
show some of the things SWFUpload is capable of and how to accomplish common tasks.
SWFUpload consists of 4 pieces:
Initialization and Settings (JavaScript)
JavaScript library: SWFUpload.js
Flash Control: swfupload.swf
The Event Handlers (JavaScript)
Most problems implementing SWFUpload are caused by incorrect settings, poorly built event handlers, Flash/Browser Bugs, or server configuration.
Initialization and Settings
SWFUpload must be initialized on the page. This is commonly done in the window.onload event. The SWFUpload constructor takes a settings object.
The settings object can be passed directly to the constructor as an object literal.
A reference to the initialized SWFUpload object should be kept as it is needed to start uploads and to control other aspects of SWFUpload.
Example: Initializing SWFUpload with an object literal
var swfu;
window.onload = function () {
swfu = new SWFUpload({
upload_url : "http://www.swfupload.org/upload.php",
flash_url : "http://www.swfupload.org/swfupload.swf",
file_size_limit : "20 MB"
});
};
Example: Initializing SWFUpload with a settings object stored in a variable
var swfu;
window.onload = function () {
var settings_object = {
upload_url : "http://www.swfupload.org/upload.php",
flash_url : "http://www.swfupload.org/swfupload.swf",
file_size_limit : "20 MB"
};
swfu = new SWFUpload(settings_object);
};
JavaScript library
The JavaScript library file (swfupload.js) must be included on the page where the user will upload files.
Once a SWFUpload object has been created access to several functions become available which allow the developer to control SWFUpload.
Example: Initializing SWFUpload with the required settings.
var swfu = new SWFUpload({
upload_url : "http://www.swfupload.org/upload.php",
flash_url : "http://www.swfupload.org/swfupload_f9.swf",
button_placeholder_id : "spanSWFUploadButton"
});
Flash Control
The SWFUpload JavaScript library dynamically loads the Flash Control (swfupload.swf).
The location of the Flash Control file must be provided in the SWFUpload settings object during setup.
The Flash Control is a small Flash Movie that handles file browsing, validation and upload. It appears on the page as
a button and communicates with JavaScript to notify the browser of upload status and other events.
The Event Handlers
Developers must create a set of JavaScript functions that handle SWFUpload events. These functions are called as different important events occur.
By handling the SWFUpload events developers can provide feedback regarding the upload progress, error messages, and upload completion. Developers should not
overwrite functions stored in SWFUpload.prototype. Instead create your own set of functions and pass references to them in the settings object.
Example: SWFUpload event handlers and initialization.
// The uploadStart event handler. This function variable is assigned to upload_start_handler in the settings object
var myCustomUploadStartEventHandler = function (file) {
var continue_with_upload;
if (file.name === "the sky is blue") {
continue_with_upload = true;
} else {
continue_with_upload = false;
}
return continue_with_upload;
};
// The uploadSuccess event handler. This function variable is assigned to upload_success_handler in the settings object
var myCustomUploadSuccessEventHandler = function (file, server_data, receivedResponse) {
alert("The file " + file.name + " has been delivered to the server. The server responded with " + server_data);
};
// Create the SWFUpload Object
var swfu = new SWFUpload({
upload_url : "http://www.swfupload.org/upload.php",
flash_url : "http://www.swfupload.org/swfupload.swf",
file_size_limit : "200 MB",
upload_start_handler : myCustomUploadStartEventHandler,
upload_success_handler : myCustomUploadSuccessEventHandler
});
SWFUpload JavaScript Object
Constructor
SWFUpload(settings object)
Returns: A SWFUpload instance
var swfupload_instance = new SWFUpload(settings_object);
Globals and Constants
Several globals and constants are associated with the SWFUpload object. These are useful for
advanced SWFUpload applications and for handling errors. These are considered read-only.
SWFUpload.instances
SWFUpload.instances is an object containing a reference to each SWFUpload instance loaded on a page. The Flash Player
relies on this object in order to call the correct event handlers. SWFUpload.instances indexes by the movieName property.
SWFUpload.movieCount
SWFUpload.movieCount is a global that tracks the number on SWFUpload instances that have been created and helps to ensure each movie is
given a unique movieName.
SWFUpload.QUEUE_ERROR
SWFUpload.QUEUE_ERROR is a simple object that contains Queue Error code constants. It is generally used to determine which error code was sent
in the fileQueueError event.
QUEUE_LIMIT_EXCEEDED - indicates that the user has attempted to queue more files that is allowed by the settings. Once files have been updated and removed from the queue the user is again allowed to queue additional files.
FILE_EXCEEDS_SIZE_LIMIT - indicates the selected file is larger than is allwed by the file_size_limit.
ZERO_BYTE_FILE - indicates that the selected file is empty. The Flash Player cannot handle empty files and the file is rejected. Windows Shortcut files may also trigger this error.
INVALID_FILETYPE - The selected file's extension does not match a valid extension from the file_types setting. User's can circumvent the file_types restriction by manually entering a file name.
SWFUpload.UPLOAD_ERROR
SWFUpload.UPLOAD_ERROR is a simple object that contains Upload Error code constants. It is generally used to determine which error code was sent
in the uploadError event.
HTTP_ERROR - The file upload was attempted but the server did not return a 200 status code.
MISSING_UPLOAD_URL - The upload_url setting was not set.
IO_ERROR - Some kind of error occurred while reading or transmitting the file. This most commonly occurs when the server unexpectedly terminates the connection.
SECURITY_ERROR - The upload violates a security restriction. This error is rare.
UPLOAD_LIMIT_EXCEEDED - The user has attempted to upload more files than is allowed by the file_upload_limit setting.
UPLOAD_FAILED - The attempt to initiate the upload caused an error. This error is rare.
SPECIFIED_FILE_ID_NOT_FOUND - A file ID was passed to startUpload but that file ID could not be found.
FILE_VALIDATION_FAILED - False was returned from the uploadStart event
FILE_CANCELLED - cancelUpload was called
UPLOAD_STOPPED - stopUpload was called.
SWFUpload.FILE_STATUS
SWFUpload.FILE_STATUS is a simple object that contains File Status code constants. It can be used to check the file status property on the File object.
QUEUED - indicates the this file is waiting in the queue.
IN_PROGRESS - indicates that this file is currently being uploaded.
ERROR - indicates that this file caused a queue or upload error.
COMPLETE - indicates that this file was successfully transmitted to the server.
CANCELLED - indicates that this file was cancelled by a call to cancelUpload.
SWFUpload.BUTTON_ACTION
SWFUpload.BUTTON_ACTION is a simple object that contains button action code constants. It is used with the button_action setting to set the behavior of the Flash based file dialog button.
SELECT_FILE - when the Flash button is clicked the file dialog will only allow a single file to be selected.
SELECT_FILES - when the Flash button is clicked the file dialog allows multiple files to be selected.
START_UPLOAD - while the Flash button is clicked the first queued file will be uploaded.
SWFUpload.CURSOR
SWFUpload.CURSOR is a simple object that contains button cursor code constants. It is used with the button_cursor setting to set the mouse cursor when hovering over the Flash button.
ARROW - the cursor will display as an arrow pointer
HAND - the cursor will display has a finger/hand pointer
SWFUpload.WINDOW_MODE
SWFUpload.WINDOW_MODE is a simple object that contains button movie wmode parameter constants. It is used to tell the browser how to display the Flash Movie.
The some WINDOW_MODE/WMODE settings can cause problems in some browsers. See the Known Issues.
WINDOW is the default mode. The movie is drawn over the top of all other elements on the page.
OPAQUE causes the movie to be rendered in the page allowing other elements to cover up the button.
TRANSPARENT the button background is rendered transparent allowing html elements under the button to show through.
Properties
The following list of properties is intended for your use as described below. Using other properties or
writing to read-only properties can cause SWFUpload to malfunction.
customSettings (read/write)
The customSettings property is an empty JavaScript object that can be used to store data associated with
an instance of SWFUpload. The customSettings object contents can be initialized using the custom_settings setting.
Example:
// Initialize SWFUpload with some custom settings
var swfu = new SWFUpload({
custom_settings : {
custom_setting_1 : "custom_setting_value_1",
custom_setting_2 : "custom_setting_value_2",
custom_setting_n : "custom_setting_value_n",
}
});
swfu.customSettings.custom_setting_1 = "custom_setting_value_1"; // Change an existing custom setting
swfu.customSettings.myNewCustomSetting = "new custom setting value"; // Add a new custom setting
// Overwrite the customSettings with a completely new object
swfu.customSettings = {
custom_setting_A : "custom_setting_value_A",
custom_setting_B : "custom_setting_value_B"
};
The values stored in the customSettings object can then be easily accessed in the event handlers:
function uploadSuccess(file, serverData, receivedResponse) {
if (this.customSettings.custom_setting_A === true) {
alert("Checked the custom setting!");
}
}
movieName
Contains the unique movie name of the SWFUpload instance. This value is passed to Flash and is used to facilitate Flash-to-JavaScript communication.
This value is used to index the instance in the SWFUpload.instances array. You should not change the movieName value.
Methods
The following methods are used to operate SWFUpload. Some are bound to DOM element click event handlers and others are used inside
SWFUpload event handlers.
Deprecated The addSetting function sets a setting value. If the value is undefined then the default_value is used. The function is used by SWFUpload
during initialization. Using addSetting to update a setting will not change the setting in the Flash Control.
addSetting returns the value that was stored in the setting.
object getSetting(setting_name)
Deprecated The getSetting function retrieves the value of a setting. If the setting is not found an empty string is returned.
Removed in v2.1.0 The retrieveSetting function is similar to the addSetting function except it does not modify the internal settings object. retrieveSetting
returns the setting_value unless it is undefined in which case it returns the default_value
This is a utility function.
bool destroy()
Added in v2.1.0
Removes the SWF DOM elements and then destroys SWFUpload internal references. Used for removing a SWFUpload instance from a page. It also attempts to prevent memory leaks in IE.
Returns true if the elements were removed successfully. Returns false if any error occurs leaving the SWFUpload instance in an inconsistent state.
void displayDebugInfo()
The displayDebugInfo outputs SWFUpload settings using the debug event. This function is automatically called after initialization if the debug setting is 'true'
void selectFile()
Deprecated. Not compatible with Flash Player 10.
selectFile causes the Flash Control to display a File Selection Dialog window. A single file may be selected from the Dialog window.
Calling selectFile begins the File Event Chain.
void selectFiles()
Deprecated. Not compatible with Flash Player 10.
selectFiles causes the Flash Control to display a File Selection Dialog window. A multiple files may be selected from the Dialog window.
Calling selectFiles begins the File Event Chain.
void startUpload(file_id)
startUpload causes the file specified by the file_id parameter to start the upload process. If the file_id parameter is omitted or undefined then the first file in the queue is uploaded.
Calling startUpload begins the Upload Event Chain.
void cancelUpload(file_id, trigger_error_event)
cancelUpload cancels the file specified by the file_id parameter. The file is then removed from the queue.
If the file_id parameter is omitted or undefined then the first file in the queue is cancelled.
The trigger_error_event is optional. If set to false the uploadError event is suppressed.
void stopUpload()
stopUpload stops and re-queues the file currently being uploaded.
After the uploading file is stopped the uploadError event is fired. If no file is being uploaded then nothing happens and no event is fired.
object getStats()
Retrieves the stats object.
void setStats(stats_object)
The Stats Object may be modified. This is useful if you wish to change the number of successful uploads or upload errors after an upload
has completed.
object getFile(file_id|index)
getFile is used to retrieve a File Object from the queue. The file retrieved by passing in a file id (the id property from a file object) or a file index (the index property from a file object).
When getting a file by file_id only files in the queue are available. If the file is not found null is returned.
When getting a file by index all queued (or files that generated a queue error) are available. If the index is out of range then null is returned
void addPostParam(name, value)
The addPostParam function adds a name/value pair that will be sent in the POST for all files uploaded.
The name/value pair will also appear in the post_params setting.
void removePostParam(name)
The removePostParam function removes a name/value pair from the values sent with the POST for file uploads.
The name/value pair is also be removed from the post_params setting.
bool addFileParam(file_id, name, value)
The addFileParam function adds a name/value pair that will be sent in the POST with the file specified by the file_id parameter.
The name/value pair will only be sent with the file it is added to. To send name/value pairs with all uploads use the post_param setting.
bool removeFileParam(file_id, name)
The removeFileParam function removes a name/value pair from a file upload that was added using addFileParam.
If the name/value pair was not found then 'false' is returned.
void setUploadURL(url)
Dynamically modifies the upload_url setting.
void setPostParams(param_object)
Dynamically modifies the post_params setting. Any previous values are over-written. The param_object should be a simple JavaScript object. All names and values must be strings.
void setFileTypes(types, description)
Dynamically updates the file_types and file_types_description settings. Both parameters are required.
void setFileSizeLimit(file_size_limit)
Dynamically modifies the file_size_limit setting. This applies to all future files that are queued. The file_size_limit parameter will accept a unit. Valid units are B, KB, MB, and GB. The default unit is KB.
Dynamically modifies the file_upload_limit setting. The special value zero (0) indicates "no limit".
void setFileQueueLimit(file_queue_limit)
Dynamically modifies the file_queue_limit setting. The special value zero (0) indicates "no limit".
void setFilePostName(file_post_name)
Dynamically modifies the file_post_name setting. The Linux Flash Player ignores this setting.
void setUseQueryString(use_query_string)
Dynamically modifies the use_query_string setting. When true this forces SWFUpload to send post parameters on the query string rather than in the post. The use_query_string parameter should be a boolean true or false.
void setDebugEnabled(debug_enabled)
Dynamically enables or disables debug output. The debug_enabled parameter should be a boolean true or false.
void setButtonImageURL(url)
Dynamically change the image used in the Flash Button. The image url must be relative to the swfupload.swf file, an absolute path (e.g., starting with a /), or
a fully qualified url (e.g., http://www.swfupload.org/buttonImage.png). Any image format supported by Flash can be loaded. The most notable formats are jpg, gif, and png.
The button image is expected to be a button sprite (or a single image file with several images stacked together). The image will be used to represent
all the button states by moving the image up or down to only display the needed portion. These states include: normal, hover, click, disabled. See the sample button images.
void setButtonDimensions(width, height)
Dynamically change the Flash button's width and height. The values should be numeric and should not include any units. The height value should
be 1/4th of the total button image height so the button state sprite images can be displayed correctly
void setButtonText(text)
Sets the text that should be displayed over the Flash button. Text that is too large and overflows the button size will be clipped.
The text can be styled using HTML supported by the Flash Player (Adobe Documentation)
void setButtonTextStyle(css_style_text)
Sets the CSS styles used to style the Flash Button Text. CSS should be formatted according to the Flash Player documentation (Adobe Documentation)
Style classes defined here can then be referenced by HTML in the button_text setting.
void setButtonTextPadding(left, top)
Sets the top and left padding of the Flash button text. The values may be negative.
void setButtonDisabled(isDisabled)
When 'true' changes the Flash Button state to disabled and ignores any clicks.
void setButtonAction(buttonAction)
Sets the action taken when the Flash button is clicked. Valid action values are taken from the BUTTON_ACTION constants.
void setButtonCursor(buttonCursor)
Sets the mouse cursor shown when hovering over the Flash button. Valid cursor values are taken from the CURSOR constants.
Events
SWFUpload fires various events during its operation. These events can be handled by the developer to update the UI, change behavior, or report errors.
All SWFUpload events are called in the context of a SWFUpload instance. This means that the 'this' object refers to the SWFUpload instance that
fired the event.
SWFUpload events should be set only by assigning the event handler function in the settings object during object initialization. You should not override the
internal functions belonging to the SWFUpload.prototype object.
During a file upload events are usually called in this order (the Upload Event Chain):
uploadStart
uploadProgress (called over and over again as the file uploads)
uploadError (called if some kind of error occurs, the file is canceled or stopped)
uploadSuccess (the upload finished successfully, data returned from the server is available)
uploadComplete (the upload is complete and SWFUpload is ready to start the next file)
flashReady()
flashReady is an internal event that should not be overwritten. It is called by the Flash Control to notify SWFUpload that the Flash
movie has loaded and is ready to accept commands.
swfUploadLoaded()
The swfUploadLoaded event is fired by flashReady. It is settable. swfUploadLoaded is called to let you know that it is safe to call SWFUpload methods.
fileDialogStart()
fileDialogStart is fired after selectFile for selectFiles is called. This event is fired immediately before the File Selection Dialog
window is displayed. However, the event may not execute until after the Dialog window is closed.
fileQueued(file object)
The fileQueued event is fired for each file that is queued after the File Selection Dialog window is closed.
fileQueueError(file object, error code, message)
The fileQueueError event is fired for each file that was not queued after the File Selection Dialog window is closed. A file may not be queued
for several reasons such as, the file exceeds the file size, the file is empty or a file or queue limit has been exceeded.
The reason for the queue error is specified by the error code parameter. The error code corresponds to a SWFUpload.QUEUE_ERROR constant.
fileDialogComplete(number of files selected, number of files queued, total number of files in the queued)
The fileDialogComplete event fires after the File Selection Dialog window has been closed and all the selected files have been processed. The 'number of files queued' argument indicates the number of files that were queued from the dialog selection (as opposed to the number of files in the queue).
If you want file uploading to begin automatically this is a good place to call 'this.startUpload()'
uploadStart(file object)
uploadStart is called immediately before the file is uploaded. This event provides an opportunity to perform any last minute validation, add post
params or do any other work before the file is uploaded.
The upload can be cancelled by returning 'false' from uploadStart. If you return 'true' or do not return any value then the upload proceeds. Returning
'false' will cause an uploadError event to fired.
uploadProgress(file object, bytes complete, total bytes)
The uploadProgress event is fired periodically by the Flash Control. This event is useful for providing UI updates on the page.
Note: The Linux Flash Player fires a single uploadProgress event after the entire file has been uploaded. This is a bug in
the Linux Flash Player that we cannot work around.
uploadError(file object, error code, message)
The uploadError event is fired any time an upload is interrupted or does not complete successfully. The error code parameter indicates the type of error
that occurred. The error code parameter specifies a constant in SWFUpload.UPLOAD_ERROR.
Stopping, Cancelling or returning 'false' from uploadStart will cause uploadError to fire. Upload error will not fire for files that are cancelled
but still waiting in the queue.
uploadSuccess(file object, server data, received response)
uploadSuccess is fired when the entire upload has been transmitted and the server returns a HTTP 200 status code. Any data outputted by the server is available
in the server data parameter.
Due to some bugs in the Flash Player the server response may not be acknowledged and no uploadSuccess event is fired by Flash. In this case the
assume_success_timeout setting is checked to see if enough time has passed to fire uploadSuccess anyway. In this case the received response parameter will be false.
The http_success setting allows uploadSuccess to be fired for HTTP status codes other than 200. In this case no server data is available from the Flash Player.
At this point the upload is not yet complete. Another upload cannot be started from uploadSuccess.
uploadComplete(file object)
uploadComplete is always fired at the end of an upload cycle (after uploadError or uploadSuccess). At this point the upload is complete and
another upload can be started.
If you want the next upload to start automatically this is a good place to call this.uploadStart(). Use caution when calling uploadStart inside
the uploadComplete event if you also have code that cancels all the uploads in a queue.
debug(message)
The debug event is called by the SWFUpload library and the Flash Control when the debug setting is set to 'true'. If the debug
event is not overridden then SWFUpload writes debug messages to the SWFUpload console (a text box dynamically added to the end of the page body).
SWFUpload Utility Objects
Settings object
The settings object is a JavaScript object that provides the settings for the SWFUpload instance. Each setting should only appear once. Many settings
are optional and provide suitable default values if omitted. See the setting details for required and optional settings.
The upload_url setting accepts a full, absolute, or relative target URL for the uploaded file. Relative URLs should be relative to document. The upload_url should be in the same domain as the Flash Control for best compatibility.
If the preserve_relative_urls setting is false SWFUpload will convert the relative URL to an absolute URL to avoid the URL being interpreted differently by the Flash Player on different platforms. If you disable SWFUploads conversion of the URL relative URLs should be relative to the swfupload.swf file.
file_post_name
The file_post_name allows you to set the value name used to post the file. This is not related to the file name.
The default value is 'Filedata'. For maximum compatibility it is recommended that the default value is used.
post_params
The post_params setting defines the name/value pairs that will be posted with each uploaded file. This setting accepts a simple JavaScript object.
Multiple post name/value pairs should be defined as demonstrated in the sample settings object. Values must be either strings or numbers (as interpreted by the JavaScript typeof function).
Note: Flash Player 8 does not support sending additional post parameters. SWFUpload will automatically send the post_params as part of the query string.
use_query_string
The use_query_string setting may be true or false. This value indicates whether SWFUpload should send the post_params and file params on the query string or the post. This setting was introduced in SWFUpload v2.1.0.
preserve_relative_urls
A boolean value that indicates whether SWFUpload should attempt to convert relative URLs used by the Flash Player to absolute URLs. If set to true SWFUpload will not modify any URLs. The default value is false.
requeue_on_error
The requeue_on_error setting may be true or false. When this setting is true any files that has an
uploadError (excluding fileQueue errors and the FILE_CANCELLED uploadError) is returned to the front of
the queue rather than being discarded. The file can be uploaded again if needed. To remove the file from the
queue the cancelUpload method must be called.
All the events associated with a failed upload are still called and so the requeuing the failed upload can conflict
with the Queue Plugin (or custom code that uploads the entire queue). Code that automatically uploads the next file
in the queue will upload the failed file over and over again if care is not taken to allow the failing upload to be
cancelled.
This setting was introduced in SWFUpload v2.1.0.
http_success
An array that defines the HTTP Status Codes that will trigger success. 200 is always a success. Also, only the 200 status code provides the serverData.
When returning and accepting an HTTP Status Code other than 200 it is not necessary for the server to return content.
assume_success_timeout
The number of seconds SWFUpload should wait for Flash to detect the server's response after the file has finished uploading. This setting allows you to
work around the Flash Player bugs where long running server side scripts causes Flash to ignore the server response or the Mac Flash Player bug that ignores
server responses with no content.
Testing has shown that Flash will ignore server responses that take longer than 30 seconds after the last uploadProgress event.
A timeout of zero (0) seconds disables this feature and is the default value. SWFUpload will wait indefinitely for the Flash Player to trigger the uploadSuccess event.
file_types
The file_types setting accepts a semi-colon separated list of file extensions that are allowed to be selected by the user. Use '*.*' to allow all file types.
file_types_description
A text description that is displayed to the user in the File Browser dialog.
file_size_limit
The file_size_limit setting defines the maximum allowed size of a file to be uploaded. This setting accepts a value and unit.
Valid units are B, KB, MB and GB. If the unit is omitted default is KB. A value of 0 (zero) is interpreted as unlimited.
Note: This setting only applies to the user's browser. It does not affect any settings or limits on the web server.
file_upload_limit
Defines the number of files allowed to be uploaded by SWFUpload. This setting also sets the upper bound of the file_queue_limit
setting. Once the user has uploaded or queued the maximum number of files she will no longer be able to queue additional files. The
value of 0 (zero) is interpreted as unlimited. Only successful uploads (uploads the trigger the uploadSuccess event) are counted
toward the upload limit. The setStats function can be used to modify the number of successful uploads.
Note: This value is not tracked across pages and is reset when a page is refreshed. File quotas should be managed by the web server.
file_queue_limit
Defines the number of unprocessed files allowed to be simultaneously queued. Once a file is uploaded, errored, or cancelled a new
files can be queued in its place until the queue limit has been reached. If the upload limit (or remaining uploads allowed) is less
than the queue limit then the lower number is used.
flash_url
The full, absolute, or relative URL to the Flash Control swf file. This setting cannot be changed once the SWFUpload has been
instantiated. Relative URLs are relative to the page URL.
flash_width
(Removed in v2.1.0) Defines the width of the HTML element that contains the flash. Some browsers do not function correctly if this setting is less than 1 px.
This setting is optional and has a default value of 1px.
flash_height
(Removed in v2.1.0) Defines the height of the HTML element that contains the flash. Some browsers do not function correctly if this setting is less than 1 px.
This setting is optional and has a default value of 1px.
flash_color
Removed in v2.2.0 This setting sets the background color of the HTML element that contains the flash. The default value is '#FFFFFF'.
Note: This setting may not be effective in "skinning" 1px flash element in all browsers.
prevent_swf_caching
Added in v2.2.0 This boolean setting indicates whether a random value should be added to the Flash URL in an attempt to
prevent the browser from caching the SWF movie. This works around a bug in some IE-engine based browsers.
Note: The algorithm for adding the random number to the URL is dumb and cannot handle URLs that already have some parameters.
debug
A boolean value that defines whether the debug event handler should be fired.
button_placeholder_id
(Added in v2.2.0) This required setting sets the ID of DOM element that will be replaced by the Flash Button. This setting overrides the button_placeholder setting. The Flash button can be styled using the CSS class 'swfupload'.
button_placeholder
(Added in v2.2.0) This required setting sets the DOM element that will be replaced by the Flash Button. This setting is only applied if the button_placeholder_id is not set. The Flash button can be styled using the CSS class 'swfupload'.
button_image_url
(Added in v2.2.0) Fully qualified, absolute or relative URL to the image file to be used as the Flash button. Any Flash supported image file format can be used (another SWF file or gif, jpg, or png).
This URL is affected by the preserve_relative_urls setting and should follow the same rules as the upload_url setting.
The button image is treated as a sprite. There are 4 button states that must be represented by the button image. Each button state image
should be stacked above the other in this order: normal, hover, down/click, disabled.
button_width
(Added in v2.2.0) A number defining the width of the Flash button.
button_height
(Added in v2.2.0) A number defining the height of the Flash button. This value should be 1/4th of the height or
the button image.
button_text
(Added in v2.2.0) Plain or HTML text that is displayed over the Flash button. HTML text can be further styled using CSS
classes and the button_text_style setting. See Adobe's Flash documentation for details.
button_text_style
(Added in v2.2.0) CSS style string that defines how the button_text is displayed.
See Adobe's Flash documentation for details.
button_text_top_padding
(Added in v2.2.0) Used to vertically position the Flash button text. Negative values may be used.
button_text_left_padding
(Added in v2.2.0) Used to horizontally position the Flash button text. Negative values may be used.
button_action
(Added in v2.2.0) Defines the action taken when the Flash button is clicked. Valid action values can be found in the swfupload.js file under the BUTTON_ACTION object.
button_disabled
(Added in v2.2.0) A boolean value that sets whether the Flash button is in the disabled state. When in the disabled state the button will not execute any actions.
button_cursor
(Added in v2.2.0) Used to define what type of mouse cursor is displayed when hovering over the Flash button.
button_window_mode
(Added in v2.2.0) Sets the WMODE property of the Flash Movie. Valid values are available in the SWFUpload.WINDOW_MODE constants.
custom_settings
The custom_settings setting allows developers to safely attach additional information to a SWFUpload instance without
worrying about affecting internal SWFUpload values or changes in new SWFUpload versions. This setting accepts a JavaScript
object.
Once instantiated the custom settings are accessed in the 'customSettings' property of the SWFUpload instance.
var swfu = new SWFUpload({
custom_settings : {
"My Setting" : "This is my setting",
myothersetting : "This is my other setting",
integer_setting : 100,
a_dom_setting : document.getElementById("some_element_id")
}
});
var my_setting = swfu.customSettings["My Setting"]);
swfu.customSettings["My Setting"] = "This is my new setting";
swfu.customSetting.myothersetting = "another new value";
swfu.customSetting.integer_setting += 25;
swfu.customSetting["a_dom_setting"].style.visibility = "hidden";
Event Handlers
The remaining settings define the event handlers called by SWFUpload during its operation. JavaScript functions should
be defined to handle these events as needed.
File Object
The file object is passed to several event handlers. It contains information about the file. Some operating systems do not fill in all the values (this
is especially true for the createdate and modificationdate values).
{
id : string, // SWFUpload file id, used for starting or cancelling and upload
index : number, // The index of this file for use in getFile(i)
name : string, // The file name. The path is not included.
size : number, // The file size in bytes
type : string, // The file type as reported by the client operating system
creationdate : Date, // The date the file was created
modificationdate : Date, // The date the file was last modified
filestatus : number, // The file's current status. Use SWFUpload.FILE_STATUS to interpret the value.
}
Stats Object
The Stats object provides information about the upload queue.
That stats object contains the following properties:
{
in_progress : number // 1 or 0 indicating if a file upload is currently in progress
files_queued : number // The number of files currently in the queue
successful_uploads : number // The number of files that have uploaded successfully (caused uploadSuccess to be fired)
upload_errors : number // The number of files that have had errors (excluding cancelled files)
upload_cancelled : number // The number of files that have been cancelled
queue_errors : number // The number of files that caused fileQueueError to be fired
}
All these values can be updated using setStats() except the in_progress and files_queued values.
SWFUpload Plug-ins
With SWFUpload v2.0 several plugins have been introduced. They are provided to help with common tasks associated with implementing SWFUpload.
Currently most of the documentation for using the plugins is contained in the plugin JavaScript file.
SWFObject
The SWFObject plugin uses the SWFObject library to handle the embedding
of the SWFUpload Flash Component into the page.
This plugin also provides support for Document Ready loading and Flash Version Detection. Usage details are documented
in the plugin file itself. You should not use the SWFObject's Document Ready loading mixed with another libraries DOMReady. Use
one or the other but not both.
Flash Player 10: Because Flash Player 10 requires the SWFUpload swf to act is a button the movie must be visible in order
for it to load. If the button_placeholder_id is set to an element that is hidden (visibility set to hidden or display set to none) SWFUpload will
fail to load.
Cookies
In response to the Flash Cookie Bug the Cookies Plugin automatically retrieves your browser's cookies and sends them
with the upload. The are sent as POST or GET variables to the upload url.
Note that this plugin sends the cookies name/values in the POST or GET. On the server side they will not be accessible as cookies. Some frameworks that
automatically check cookies for session or authentication values still will not be able to find the values.
Queue Handling
This plugin provides Queue Handling features such as entire queue uploading, entire queue cancelling and automatic starting of uploads after being queued.
Speed
This Plugin extends the 'file' object with several properties that describe the current upload. This includes current speed, average speed, elapsed time, remaining time and more.
Known Issues
The Flash Player and many Browsers have bugs that have a direct impact on the performance of SWFUpload. While we have worked
hard to get around many issues but there are some things that we cannot fix.
Cancelling in Linux
Older Flash 9 Players for Linux cause the browser to crash if an upload is cancelled. Newer Flash 9 Players behave better.
Upload Progress in Linux
The Flash Player in Linux sends a single uploadProgress event after the file has finished uploading.
In some distributions the entire browser locks up while the upload is in progress.
Upload Progress in OS X
There have been some reports that uploadProgress events are not fired in MAC Flash Players. The specifics haven't been pinned down but be aware of the possible issue.
MIME Type
The Flash Player uploads all files with a mime type of application/octet-stream regardless of the file's actual mime type.
Maximum number of selected files
The Flash Player does not impose a maximum number of selected files. However, it builds a selected files string which does have a maximum length.
The string is built using the file's name and the separator [quote][space][quote]. The total number of files selected is determined by the sum
of the lengths of the file names and a prefixed and postfixed [quote] character (2 characters) and the number of files selected minus one times 3 (for the separator string)
This limitation may vary from system to system. If a use selects too many files they will be receive a Flash Player generated warning message and will
be left at the File Selection Dialog.
Proxies
The Flash Player may not properly use proxies. It does not handle authenticating proxies well (if at all) and will some-times crash.
Some anti-virus software uses a proxy to scan uploads and cause SWFUpload to believe the entire file has been uploaded. SWFUpload will fire uploadProgress events very quickly
until it reaches 100% and will then seem to pause until the proxy completes uploading the file to the server.
Apache mod_security
Apache's mod_security validates POST to the server. Flash Player has implemented an edge case (there is argument as to whether it is invalid or note)
POST for file uploads and so servers implementing
mod_security will reject the upload. mod_security can be disabled using your .htaccess file
SSL
There have been some reports that the Flash Player cannot upload through SSL.
The issue has not been pinned down but uploading over SSL may be unreliable. There especially seems to be an issue with
using self-signed certificates.
Also, SSL tickets from untrusted Certificate Authorities (CA) do not work as Flash does not provide a method for accepting the certificate. It has been noted that, like the cookie bug,
that Flash Player on Windows obtains its trusted CA list from Internet Explorer regardless of the browser in use.
Authentication
HTTP Authentication is not well supported by the Flash Player. Later versions of Flash Player behave better. Old version of Flash Player would crash the browser.
Prematurely terminated connections
Prematurely ending the response (such as a Response.end() in ASP.Net) can sometimes cause successful uploads to be reported as failed.
Filedata in Linux
Changing the Filedata value (file_post_name setting) is ignored in Linux Flash Players.
Cookie issue
On Windows the Non-IE Flash Player plugin (FireFox, Opera, Safari, etc) will send the IE cookies regardless of the browser used. This breaks authentication and sessions for many server-side scripting technologies.
Developers should manually pass Session and Authentication cookie information and manually restore Sessions on the Server Side if they wish to use Sessions
The SWFUpload package contains work-around sample code for PHP and ASP.Net
ExternalInterface bugs
Flash Player does not properly escape data when communication with the browser/JavaScript. SWFUpload goes to great lengths to work-around this issue. If this
bug is fixed in future Flash Players/Browsers then SWFUpload will send extra escaped data.
Server Data length bugs
Very long server data is corrupted on Mac and Linux Flash Players. Server data will be truncated, garbled, and/or repeated. We recommend
keeping data returned from the server short and concise.
Avant Browser
For some users the Avant Browser does not work with SWFUpload after the Flash Control has been cached. This has been reproduced by the
SWFUpload developers but the Avant Browser developers did not experience any problems.
When the page is reloaded SWFUpload loads and fires the swfupload_loaded event. However, none of the ExternalInterface callback functions are defined
on the movie element. SWFUpload v2.0.2 has added checks which prevent swfupload_loaded from firing if the callback functions are not detected.
SWFUpload v2.2.0 added the prevent_swf_caching setting that attempts to work around this issue.
File Dialog & Page Changing
Leaving or reloading the current page while the File Browser Dialog window is open will cause the browser to crash (all browsers, all OSs). Most commonly this is caused by failing to
cancel a click event on an <a> tag where the onclick event calls the selectFile or selectFiles function.
Long Running Upload Scripts
After Flash has uploaded the file to the webserver the upload script is executed. This script handles the file whether that means saving it, creating a thumbnail, scanning for viruses, etc.
If the upload script does not return any data within 30 seconds Flash will disconnect and return an IO Error. You can prevent this by returning characters or data while
the script runs (if possible). For PHP, the script continues to run and complete successfully even though Flash has terminated the connection. Any data returned
by the script after Flash has disconnected is lost.
WMODE / BUTTON_WINDOW_MODE
In some browsers the selected WMODE (which is set using the BUTTON_WINDOW_MODE) can prevent the Flash Control from loading
if the control is not on screen. The control will finally load once the user scrolls the page so the control becomes visible.
This behavior can adversely affect the SWFObject plugin. No SWFUpload events will be fire and the button image will not be
loaded until the control becomes visible.
Memory Leaks
Some browsers (especially IE) cannot recover memory used by the Flash Player when JavaScript communication via the ExternalInterface classes is used (like in SWFUpload).
Creating many SWFUpload instances and/or reloading the page several times will cause the browser to consume more and more memory until it crashes or otherwise harms the
system.
In v2.2.0 SWFUpload we gave implemented some preventative measures. Some of these measures are pro-active but it is still recommended that you
call the destroy method when the page unloads. If you are using hundreds of SWFUpload instances on a page you should use caution and test
carefully for memory leaks.
Other Mac Issues
Users have reported that uploading to subdomains does not work with the Mac Flash Player.
Users have reported that pages that redirect (HTTP Status 302) are not handled by the Mac Flash Player. Windows
clients seem to handle this issue.
The flash documentation states that on OS early than OS X 10.3 the bytes loaded is always reported as -1. SWFUpload converts
this to 0 but the total bytes will never be sent and 100% won't be reached. The UI should be updated to display 100% complete in
uploadSuccess or uploadComplete events to maintain a consistent UI.
Some users have reported issues if there is a space character in the upload_url for the Mac Flash Player. Avoid spaces or try replacing them with + or %20.
Users have reported that the Flash Player for Mac adds the PORT to the HTTP_HOST server variable (e.g., http://www.example.com:80). If you are
checking this variable in your server-side script be aware of the possible issue.
libjs-swfupload_2.2.0.1+ds2/plugins/ 0002755 0001750 0001750 00000000000 12203733526 016511 5 ustar gawain gawain libjs-swfupload_2.2.0.1+ds2/plugins/swfupload.queue.js 0000644 0001750 0001750 00000006627 12203733526 022207 0 ustar gawain gawain /*
Queue Plug-in
Features:
*Adds a cancelQueue() method for cancelling the entire queue.
*All queued files are uploaded when startUpload() is called.
*If false is returned from uploadComplete then the queue upload is stopped.
If false is not returned (strict comparison) then the queue upload is continued.
*Adds a QueueComplete event that is fired when all the queued files have finished uploading.
Set the event handler with the queue_complete_handler setting.
*/
var SWFUpload;
if (typeof(SWFUpload) === "function") {
SWFUpload.queue = {};
SWFUpload.prototype.initSettings = (function (oldInitSettings) {
return function () {
if (typeof(oldInitSettings) === "function") {
oldInitSettings.call(this);
}
this.queueSettings = {};
this.queueSettings.queue_cancelled_flag = false;
this.queueSettings.queue_upload_count = 0;
this.queueSettings.user_upload_complete_handler = this.settings.upload_complete_handler;
this.queueSettings.user_upload_start_handler = this.settings.upload_start_handler;
this.settings.upload_complete_handler = SWFUpload.queue.uploadCompleteHandler;
this.settings.upload_start_handler = SWFUpload.queue.uploadStartHandler;
this.settings.queue_complete_handler = this.settings.queue_complete_handler || null;
};
})(SWFUpload.prototype.initSettings);
SWFUpload.prototype.startUpload = function (fileID) {
this.queueSettings.queue_cancelled_flag = false;
this.callFlash("StartUpload", [fileID]);
};
SWFUpload.prototype.cancelQueue = function () {
this.queueSettings.queue_cancelled_flag = true;
this.stopUpload();
var stats = this.getStats();
while (stats.files_queued > 0) {
this.cancelUpload();
stats = this.getStats();
}
};
SWFUpload.queue.uploadStartHandler = function (file) {
var returnValue;
if (typeof(this.queueSettings.user_upload_start_handler) === "function") {
returnValue = this.queueSettings.user_upload_start_handler.call(this, file);
}
// To prevent upload a real "FALSE" value must be returned, otherwise default to a real "TRUE" value.
returnValue = (returnValue === false) ? false : true;
this.queueSettings.queue_cancelled_flag = !returnValue;
return returnValue;
};
SWFUpload.queue.uploadCompleteHandler = function (file) {
var user_upload_complete_handler = this.queueSettings.user_upload_complete_handler;
var continueUpload;
if (file.filestatus === SWFUpload.FILE_STATUS.COMPLETE) {
this.queueSettings.queue_upload_count++;
}
if (typeof(user_upload_complete_handler) === "function") {
continueUpload = (user_upload_complete_handler.call(this, file) === false) ? false : true;
} else if (file.filestatus === SWFUpload.FILE_STATUS.QUEUED) {
// If the file was stopped and re-queued don't restart the upload
continueUpload = false;
} else {
continueUpload = true;
}
if (continueUpload) {
var stats = this.getStats();
if (stats.files_queued > 0 && this.queueSettings.queue_cancelled_flag === false) {
this.startUpload();
} else if (this.queueSettings.queue_cancelled_flag === false) {
this.queueEvent("queue_complete_handler", [this.queueSettings.queue_upload_count]);
this.queueSettings.queue_upload_count = 0;
} else {
this.queueSettings.queue_cancelled_flag = false;
this.queueSettings.queue_upload_count = 0;
}
}
};
} libjs-swfupload_2.2.0.1+ds2/plugins/swfupload.swfobject.js 0000644 0001750 0001750 00000032652 12203733526 023046 0 ustar gawain gawain /*
SWFUpload.SWFObject Plugin
Summary:
This plugin uses SWFObject to embed SWFUpload dynamically in the page. SWFObject provides accurate Flash Player detection and DOM Ready loading.
This plugin replaces the Graceful Degradation plugin.
Features:
* swfupload_load_failed_hander event
* swfupload_pre_load_handler event
* minimum_flash_version setting (default: "9.0.28")
* SWFUpload.onload event for early loading
Usage:
Provide handlers and settings as needed. When using the SWFUpload.SWFObject plugin you should initialize SWFUploading
in SWFUpload.onload rather than in window.onload. When initialized this way SWFUpload can load earlier preventing the UI flicker
that was seen using the Graceful Degradation plugin.
Notes:
You must provide set minimum_flash_version setting to "8" if you are using SWFUpload for Flash Player 8.
The swfuploadLoadFailed event is only fired if the minimum version of Flash Player is not met. Other issues such as missing SWF files, browser bugs
or corrupt Flash Player installations will not trigger this event.
The swfuploadPreLoad event is fired as soon as the minimum version of Flash Player is found. It does not wait for SWFUpload to load and can
be used to prepare the SWFUploadUI and hide alternate content.
swfobject's onDomReady event is cross-browser safe but will default to the window.onload event when DOMReady is not supported by the browser.
Early DOM Loading is supported in major modern browsers but cannot be guaranteed for every browser ever made.
*/
/* SWFObject v2.1
Copyright (c) 2007-2008 Geoff Stearns, Michael Williams, and Bobby van der Sluis
This software is released under the MIT License
*/
var swfobject=function(){var b="undefined",Q="object",n="Shockwave Flash",p="ShockwaveFlash.ShockwaveFlash",P="application/x-shockwave-flash",m="SWFObjectExprInst",j=window,K=document,T=navigator,o=[],N=[],i=[],d=[],J,Z=null,M=null,l=null,e=false,A=false;var h=function(){var v=typeof K.getElementById!=b&&typeof K.getElementsByTagName!=b&&typeof K.createElement!=b,AC=[0,0,0],x=null;if(typeof T.plugins!=b&&typeof T.plugins[n]==Q){x=T.plugins[n].description;if(x&&!(typeof T.mimeTypes!=b&&T.mimeTypes[P]&&!T.mimeTypes[P].enabledPlugin)){x=x.replace(/^.*\s+(\S+\s+\S+$)/,"$1");AC[0]=parseInt(x.replace(/^(.*)\..*$/,"$1"),10);AC[1]=parseInt(x.replace(/^.*\.(.*)\s.*$/,"$1"),10);AC[2]=/r/.test(x)?parseInt(x.replace(/^.*r(.*)$/,"$1"),10):0}}else{if(typeof j.ActiveXObject!=b){var y=null,AB=false;try{y=new ActiveXObject(p+".7")}catch(t){try{y=new ActiveXObject(p+".6");AC=[6,0,21];y.AllowScriptAccess="always"}catch(t){if(AC[0]==6){AB=true}}if(!AB){try{y=new ActiveXObject(p)}catch(t){}}}if(!AB&&y){try{x=y.GetVariable("$version");if(x){x=x.split(" ")[1].split(",");AC=[parseInt(x[0],10),parseInt(x[1],10),parseInt(x[2],10)]}}catch(t){}}}}var AD=T.userAgent.toLowerCase(),r=T.platform.toLowerCase(),AA=/webkit/.test(AD)?parseFloat(AD.replace(/^.*webkit\/(\d+(\.\d+)?).*$/,"$1")):false,q=false,z=r?/win/.test(r):/win/.test(AD),w=r?/mac/.test(r):/mac/.test(AD);/*@cc_on q=true;@if(@_win32)z=true;@elif(@_mac)w=true;@end@*/return{w3cdom:v,pv:AC,webkit:AA,ie:q,win:z,mac:w}}();var L=function(){if(!h.w3cdom){return }f(H);if(h.ie&&h.win){try{K.write("