/tags/1.3b/j/swfupload-2.1.0b2/swfupload.js

/**

 * SWFUpload v2.1.0 by Jacob Roberts, Feb 2008, http://www.swfupload.org, http://swfupload.googlecode.com, http://www.swfupload.org

 * -------- -------- -------- -------- -------- -------- -------- --------

 * SWFUpload is (c) 2006 Lars Huring, Olov Nilzén and Mammon Media and is released under the MIT License:

 * http://www.opensource.org/licenses/mit-license.php

 *

 * See Changelog.txt for version history

 *

 */





/* *********** */

/* Constructor */

/* *********** */



var 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.1.0 beta 1";

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

};





/* ******************** */

/* 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("file_post_name", "Filedata");

	this.ensureDefault("post_params", {});

	this.ensureDefault("use_query_string", false);

	this.ensureDefault("requeue_on_error", false);

	

	// 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_f9.swf");

	this.ensureDefault("flash_color", "#FFFFFF");



	// 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;

	

	delete this.ensureDefault;

};



// Private: loadFlash generates the HTML tag for the Flash

// It then adds the flash to the body

SWFUpload.prototype.loadFlash = function () {

	var targetElement, container;



	// 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 body tag where we will be adding the flash movie

	targetElement = document.getElementsByTagName("body")[0];



	if (targetElement == undefined) {

		throw "Could not find the 'body' element.";

	}



	// Append the container and load the flash

	container = document.createElement("div");

	container.style.width = "1px";

	container.style.height = "1px";



	targetElement.appendChild(container);

	container.innerHTML = this.getFlashHTML();	// Using innerHTML is non-standard but the only sensible way to dynamically add Flash in IE (and maybe other browsers)

};



// 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 ['<object id="', this.movieName, '" type="application/x-shockwave-flash" data="', this.settings.flash_url, '" width="1" height="1" style="-moz-user-focus: ignore;">',

				'<param name="movie" value="', this.settings.flash_url, '" />',

				'<param name="bgcolor" value="', this.settings.flash_color, '" />',

				'<param name="quality" value="high" />',

				'<param name="menu" value="false" />',

				'<param name="allowScriptAccess" value="always" />',

				'<param name="flashvars" value="' + this.getFlashVars() + '" />',

				'</object>'].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();



	// Build the parameter string

	return ["movieName=", encodeURIComponent(this.movieName),

			"&amp;uploadURL=", encodeURIComponent(this.settings.upload_url),

			"&amp;useQueryString=", encodeURIComponent(this.settings.use_query_string),

			"&amp;requeueOnError=", encodeURIComponent(this.settings.requeue_on_error),

			"&amp;params=", encodeURIComponent(paramString),

			"&amp;filePostName=", encodeURIComponent(this.settings.file_post_name),

			"&amp;fileTypes=", encodeURIComponent(this.settings.file_types),

			"&amp;fileTypesDescription=", encodeURIComponent(this.settings.file_types_description),

			"&amp;fileSizeLimit=", encodeURIComponent(this.settings.file_size_limit),

			"&amp;fileUploadLimit=", encodeURIComponent(this.settings.file_upload_limit),

			"&amp;fileQueueLimit=", encodeURIComponent(this.settings.file_queue_limit),

			"&amp;debugEnabled=", encodeURIComponent(this.settings.debug_enabled)].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&amp;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("&amp;");

};



// 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", "use_query_string:       ", this.settings.use_query_string.toString(), "\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", "flash_url:              ", this.settings.flash_url, "\n",

			"\t", "flash_color:            ", this.settings.flash_color, "\n",

			"\t", "debug:                  ", this.settings.debug.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.



// NOTE: if we don't need to call StartUpload with a timeout anymore then we can simplify this

// function and remove all the withTimeout stuff

SWFUpload.prototype.callFlash = function (functionName, withTimeout, argumentArray) {

	withTimeout = !!withTimeout || false;

	argumentArray = argumentArray || [];

	

	var self = this;

	var callFunction = function () {

		var movieElement = self.getMovieElement();

		var returnValue;

		if (typeof(movieElement[functionName]) === "function") {

			// We have to go through all this if/else stuff because the Flash functions don't have apply() and only accept the exact number of arguments.

			if (argumentArray.length === 0) {

				returnValue = movieElement[functionName]();

			} else if (argumentArray.length === 1) {

				returnValue = movieElement[functionName](argumentArray[0]);

			} else if (argumentArray.length === 2) {

				returnValue = movieElement[functionName](argumentArray[0], argumentArray[1]);

			} else if (argumentArray.length === 3) {

				returnValue = movieElement[functionName](argumentArray[0], argumentArray[1], argumentArray[2]);

			} else {

				throw "Too many arguments";

			}

			

			// Unescape file post param values

			if (returnValue != undefined && typeof(returnValue.post) === "object") {

				returnValue = self.unescapeFilePostParams(returnValue);

			}

			

			return returnValue;

		} else {

			throw "Invalid function name";

		}

	};

	

	if (withTimeout) {

		setTimeout(callFunction, 0);

	} else {

		return callFunction();

	}

};





/* *****************************

	-- Flash control methods --

	Your UI should use these

	to operate SWFUpload

   ***************************** */



// 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");

};



// 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) {

	// NOTE: Testing this without using a setTimeout. Since StartUpload was reworked to use ReturnUploadStart

	// it might not be necessary anymore

	this.callFlash("StartUpload", false, [fileID]);

};



/* Cancels a the file upload.  You must specify a file_id */

// Public: cancelUpload cancels any queued file.  The fileID parameter

// must be specified.

SWFUpload.prototype.cancelUpload = function (fileID) {

	this.callFlash("CancelUpload", false, [fileID]);

};



// 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.  It looks like this (where n is a number):

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", false, [statsObject]);

};



// Public: setCredentials that will be used to authenticate to the upload_url.

// Note: This feature does not work.  It has been added in anticipation of

// the Flex 3 SDK which has not been released yet.

SWFUpload.prototype.setCredentials = function (name, password) {

	this.callFlash("SetCrednetials", false, [name, password]);

};



// 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", false, [fileID]);

	} else {

		return this.callFlash("GetFile", false, [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", false, [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", false, [fileID, name]);

};



// Public: setUploadUrl changes the upload_url setting.

SWFUpload.prototype.setUploadURL = function (url) {

	this.settings.upload_url = url.toString();

	this.callFlash("SetUploadURL", false, [url]);

};



// Public: setPostParams changes the post_params setting

SWFUpload.prototype.setPostParams = function (paramsObject) {

	this.settings.post_params = paramsObject;

	this.callFlash("SetPostParams", false, [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", false, [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", false, [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", false, [types, description]);

};



// Public: setFileSizeLimit changes the file_size_limit setting

SWFUpload.prototype.setFileSizeLimit = function (fileSizeLimit) {

	this.settings.file_size_limit = fileSizeLimit;

	this.callFlash("SetFileSizeLimit", false, [fileSizeLimit]);

};



// Public: setFileUploadLimit changes the file_upload_limit setting

SWFUpload.prototype.setFileUploadLimit = function (fileUploadLimit) {

	this.settings.file_upload_limit = fileUploadLimit;

	this.callFlash("SetFileUploadLimit", false, [fileUploadLimit]);

};



// Public: setFileQueueLimit changes the file_queue_limit setting

SWFUpload.prototype.setFileQueueLimit = function (fileQueueLimit) {

	this.settings.file_queue_limit = fileQueueLimit;

	this.callFlash("SetFileQueueLimit", false, [fileQueueLimit]);

};



// Public: setFilePostName changes the file_post_name setting

SWFUpload.prototype.setFilePostName = function (filePostName) {

	this.settings.file_post_name = filePostName;

	this.callFlash("SetFilePostName", false, [filePostName]);

};



// Public: setUseQueryString changes the use_query_string setting

SWFUpload.prototype.setUseQueryString = function (useQueryString) {

	this.settings.use_query_string = useQueryString;

	this.callFlash("SetUseQueryString", false, [useQueryString]);

};



// Public: setRequeueOnError changes the requeue_on_error setting

SWFUpload.prototype.setRequeueOnError = function (requeueOnError) {

	this.settings.requeue_on_error = requeueOnError;

	this.callFlash("SetRequeueOnError", false, [requeueOnError]);

};



// Public: setDebugEnabled changes the debug_enabled setting

SWFUpload.prototype.setDebugEnabled = function (debugEnabled) {

	this.settings.debug_enabled = debugEnabled;

	this.callFlash("SetDebugEnabled", false, [debugEnabled]);

};





/* *******************************

	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";

	}

};



SWFUpload.prototype.executeNextEvent = function () {

	// Warning: Don't call this.debug inside here or you'll create an infinite loop



	var  f = this.eventQueue.shift();

	f.apply(this);

	

};



// Private: unescapeFileParams is part of a workaround for a flash bug where objects passed through ExternalInterfance 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;



	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;

};



SWFUpload.prototype.flashReady = function () {

	// Check that the movie element is loaded correctly with its ExternalInterface methods defined

	var movieElement = this.getMovieElement();

	if (typeof(movieElement.StartUpload) !== "function") {

		throw "ExternalInterface methods failed to initialize.";

	}

	

	this.queueEvent("swfupload_loaded_handler");

};





/* 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) {

	this.queueEvent("file_dialog_complete_handler", [numFilesSelected, numFilesQueued]);

};



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", false, [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) {

	file = this.unescapeFilePostParams(file);

	this.queueEvent("upload_success_handler", [file, serverData]);

};



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);

	}

};