text: /*
  	SWFUpload v1.0.2 Plug-in
  	
  	This plug in creates API compatibility with SWFUpload v1.0.2.  Many SWFUpload v1.0.2 behaviors are emulated as well.
  */
  
  var SWFUpload;
  if (typeof(SWFUpload) === "function") {
  	SWFUpload.v102 = {};
  	
  	SWFUpload.prototype.initSWFUpload = function (init_settings) {
  		try {
  			this.customSettings = {};	// A container where developers can place their own settings associated with this instance.
  			this.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(init_settings);
  			this.loadFlash();
  
  			this.displayDebugInfo();
  
  		} catch (ex2) {
  			this.debug(ex2);
  		}	
  	};
  	
  	SWFUpload.prototype.initSettings = function (init_settings) {
  		// Store v1.0.2 settings
  		this.customSettings["target"] 					= this.retrieveSetting(init_settings["target"], "");
  		this.customSettings["create_ui"] 				= this.retrieveSetting(init_settings["create_ui"], false);
  		this.customSettings["browse_link_class"] 		= this.retrieveSetting(init_settings["browse_link_class"], "SWFBrowseLink");
  		this.customSettings["upload_link_class"] 		= this.retrieveSetting(init_settings["upload_link_class"], "SWFUploadLink");
  		this.customSettings["browse_link_innerhtml"] 	= this.retrieveSetting(init_settings["browse_link_innerhtml"], "<span>Browse...</span>");
  		this.customSettings["upload_link_innerhtml"] 	= this.retrieveSetting(init_settings["upload_link_innerhtml"], "<span>Upload</span>");
  		this.customSettings["auto_upload"] 				= this.retrieveSetting(init_settings["auto_upload"], false);
  		
  		// Store v1.0.2 events
  		this.customSettings["upload_file_queued_callback"] 		= this.retrieveSetting(init_settings["upload_file_queued_callback"], null);
  		this.customSettings["upload_file_start_callback"] 		= this.retrieveSetting(init_settings["upload_file_start_callback"], null);
  		this.customSettings["upload_file_complete_callback"] 	= this.retrieveSetting(init_settings["upload_file_complete_callback"], null);
  		this.customSettings["upload_queue_complete_callback"] 	= this.retrieveSetting(init_settings["upload_queue_complete_callback"], null);
  		this.customSettings["upload_progress_callback"] 		= this.retrieveSetting(init_settings["upload_progress_callback"], null);
  		this.customSettings["upload_dialog_cancel_callback"] 	= this.retrieveSetting(init_settings["upload_dialog_cancel_callback"], null);
  		this.customSettings["upload_file_error_callback"] 		= this.retrieveSetting(init_settings["upload_file_error_callback"], null);
  		this.customSettings["upload_file_cancel_callback"] 		= this.retrieveSetting(init_settings["upload_file_cancel_callback"], null);
  		this.customSettings["upload_queue_cancel_callback"] 	= this.retrieveSetting(init_settings["upload_queue_cancel_callback"], null);
  		this.customSettings["queue_cancelled_flag"]				= false;
  
  		// Upload backend settings
  		this.addSetting("upload_url",		 		init_settings["upload_script"],		  			"");
  		this.addSetting("file_post_name",	 		"Filedata");
  		this.addSetting("post_params",		 		{});
  
  		// File Settings
  		this.addSetting("file_types",			  	init_settings["allowed_filetypes"],				"*.*");
  		this.addSetting("file_types_description", 	init_settings["allowed_filetypes_description"], "All Files");
  		this.addSetting("file_size_limit",		  	init_settings["allowed_filesize"],				"1024");
  		this.addSetting("file_upload_limit",	  	"0");
  		this.addSetting("file_queue_limit",		  	"0");
  
  		// Flash Settings
  		this.addSetting("flash_url",		  		init_settings["flash_path"],					"swfupload.swf");
  		this.addSetting("flash_width",		  		init_settings["flash_width"],					"1px");
  		this.addSetting("flash_height",		  		init_settings["flash_height"],					"1px");
  		this.addSetting("flash_color",		  		init_settings["flash_color"],					"#000000");
  
  		// Debug Settings
  		this.addSetting("debug_enabled", init_settings.debug,  false);
  
  		// Event Handlers
  		this.flashReady_handler         = SWFUpload.flashReady;	// This is a non-overrideable event handler
  
  		this.swfUploadLoaded_handler    = SWFUpload.v102.swfUploadLoaded;
  		this.fileDialogStart_handler	= SWFUpload.fileDialogStart;
  		this.fileQueued_handler			= SWFUpload.v102.fileQueued;
  		this.fileQueueError_handler		= SWFUpload.v102.uploadError;
  		this.fileDialogComplete_handler	= SWFUpload.v102.fileDialogComplete;
  		
  		this.uploadStart_handler		= SWFUpload.v102.uploadStart;
  		this.uploadProgress_handler		= SWFUpload.v102.uploadProgress;
  		this.uploadError_handler		= SWFUpload.v102.uploadError;
  		this.uploadSuccess_handler		= SWFUpload.v102.uploadSuccess;
  		this.uploadComplete_handler		= SWFUpload.v102.uploadComplete;
  
  		this.debug_handler				= SWFUpload.v102.debug;
  		
  		// Hook up the v1.0.2 methods
  		this.browse = SWFUpload.v102.browse;
  		this.upload = SWFUpload.v102.upload;
  		this.cancelFile = SWFUpload.v102.cancelFile;
  		this.cancelQueue = SWFUpload.v102.cancelQueue;
  		this.debugSettings = SWFUpload.v102.debugSettings;
  	}
  
  	// Emulate the v1.0.2 events
  	SWFUpload.v102.swfUploadLoaded = function() {
  		try {
  			var target_id = this.customSettings["target"];
  			if(target_id !== "" && target_id !== "fileinputs") {
  				var self = this;
  				var target = document.getElementById(target_id);
  				
  				if (target != null) {
  					// Create the link for uploading
  					var browselink = document.createElement("a");
  					browselink.className = this.customSettings["browse_link_class"];
  					browselink.id = this.movieName + "BrowseBtn";
  					browselink.href = "javascript:void(0);";
  					browselink.onclick = function() { self.browse(); return false; }
  					browselink.innerHTML = this.customSettings["browse_link_innerhtml"];
  				
  					target.innerHTML = "";
  					target.appendChild(browselink);
  						
  					// Add upload btn if auto upload not used
  					if(this.customSettings["auto_upload"] === false) {
  
  						// Create the link for uploading
  						var uploadlink = document.createElement("a");
  						uploadlink.className = this.customSettings["upload_link_class"];
  						uploadlink.id = this.movieName + "UploadBtn";
  						uploadlink.href = "#";
  						uploadlink.onclick = function() { self.upload(); return false; }
  						uploadlink.innerHTML = this.customSettings["upload_link_innerhtml"];
  						target.appendChild(uploadlink);
  					}
  				}
  			}
  		}
  		catch (ex) {
  			this.debug("Exception in swfUploadLoaded");
  			this.debug(ex);
  		}
  	}
  
  	SWFUpload.v102.fileQueued = function(file) {
  		var stats = this.getStats();
  		var total_files = stats.successful_uploads + stats.upload_errors + stats.files_queued;
  
  		var v102fileQueued = this.customSettings["upload_file_queued_callback"];
  		if (typeof(v102fileQueued) === "function")  {
  			v102fileQueued.call(this, file, total_files);
  		}
  	}
  	
  	SWFUpload.v102.fileDialogComplete = function(num_selected) {
  		if (!!this.customSettings["auto_upload"]) {
  			this.startUpload();
  		}
  	};
  	
  	SWFUpload.v102.uploadStart = function (file) {
  		var callback = this.customSettings["upload_file_start_callback"];
  		var stats = this.getStats();
  		var current_file_number = stats.successful_uploads + stats.upload_errors + 1;
  		var total_files = stats.successful_uploads + stats.upload_errors + stats.files_queued;
  		if (typeof(callback) === "function") {
  			callback.call(this, file, current_file_number, total_files);
  		}
  		
  		return true;
  	};
  	
  	SWFUpload.v102.uploadProgress = function (file, bytes_complete, bytes_total) {
  		var callback = this.customSettings["upload_progress_callback"];
  		if (typeof(callback) === "function") {
  			callback.call(this, file, bytes_complete, bytes_total);
  		}
  	};
  	
  	SWFUpload.v102.uploadSuccess = function (file, server_data) {
  		var callback = this.customSettings["upload_file_complete_callback"];
  		if (typeof(callback) === "function") {
  			callback.call(this, file, server_data);
  		}
  	};
  	
  	SWFUpload.v102.uploadComplete = function (file) {
  		var stats = this.getStats();
  		
  		if (stats.files_queued > 0 && !this.customSettings["queue_cancelled_flag"]) {
  			// Automatically start the next upload (if the queue wasn't cancelled)
  			this.startUpload();
  		} else if (stats.files_queued === 0 && !this.customSettings["queue_cancelled_flag"]) {
  			// Call Queue Complete if there are no more files queued and the queue wasn't cancelled
  			var callback = this.customSettings["upload_queue_complete_callback"];
  			if (typeof(callback) === "function") {
  				callback.call(this, file);
  			}
  		} else {
  			// Don't do anything. Remove the queue cancelled flag (if the queue was cancelled it will be set again)
  			this.customSettings["queue_cancelled_flag"] = false;
  		}
  	}
  	
  	
  	SWFUpload.v102.uploadError = function (file, error_code, msg) {
  		var translated_error_code = SWFUpload.v102.translateErrorCode(error_code);
  		switch (error_code) {
  			case SWFUpload.UPLOAD_ERROR.FILE_CANCELLED:
  				var stats = this.getStats();
  				var total_files = stats.successful_uploads + stats.upload_errors + stats.files_queued;
  				var callback = this.customSettings["upload_file_cancel_callback"];
  				if (typeof(callback) === "function") {
  					callback.call(this, file, total_files);
  				}
  				break;
  			defaut:
  				var error_callback = this.customSettings["upload_file_error_callback"];
  				if (error_callback === null || typeof(error_callback) !== "function") {
  					SWFUpload.v102.defaultHandleErrors.call(this, translated_error_code, file, msg);
  				} else {
  					error_callback.call(this, translated_error_code, file, msg);
  				}
  		}		
  	};
  	
  	SWFUpload.v102.translateErrorCode = function (error_code) {
  		var translated_error_code = 0;
  		switch (error_code) {
  			case SWFUpload.QUEUE_ERROR.QUEUE_LIMIT_EXCEEDED:
  				translated_error_code = -40;
  				break;
  			case SWFUpload.QUEUE_ERROR.FILE_EXCEEDS_SIZE_LIMIT:
  				translated_error_code = -50;
  				break;
  			case SWFUpload.QUEUE_ERROR.ZERO_BYTE_FILE:
  				translated_error_code = -30;
  				break;
  			case SWFUpload.QUEUE_ERROR.INVALID_FILETYPE:
  				translated_error_code = -30;
  				break;
  			case SWFUpload.UPLOAD_ERROR.HTTP_ERROR:
  				translated_error_code = -10;
  				break;
  			case SWFUpload.UPLOAD_ERROR.MISSING_UPLOAD_URL:
  				translated_error_code = -20;
  				break;
  			case SWFUpload.UPLOAD_ERROR.IO_ERROR:
  				translated_error_code = -30;
  				break;
  			case SWFUpload.UPLOAD_ERROR.SECURITY_ERROR:
  				translated_error_code = -40;
  				break;
  			case SWFUpload.UPLOAD_ERROR.SPECIFIED_FILE_ID_NOT_FOUND:
  				translated_error_code = -30;
  				break;
  			case SWFUpload.UPLOAD_ERROR.FILE_VALIDATION_FAILED:
  				translated_error_code = -30;
  				break;
  			case SWFUpload.UPLOAD_ERROR.FILE_CANCELLED:
  				translated_error_code = -10;
  				// FIX ME - call the upload_cancelled_callback
  				break;
  			case SWFUpload.UPLOAD_ERROR.UPLOAD_STOPPED:
  				translated_error_code = -30;
  				break;
  		}
  		
  		return translated_error_code;
  	}
  	
  	// Default error handling.
  	SWFUpload.v102.defaultHandleErrors = function(errcode, file, msg) {
  		
  		switch(errcode) {
  			
  			case -10:	// HTTP error
  				alert("Error Code: HTTP Error, File name: " + file.name + ", Message: " + msg);
  				break;
  			
  			case -20:	// No upload script specified
  				alert("Error Code: No upload script, File name: " + file.name + ", Message: " + msg);
  				break;
  			
  			case -30:	// IOError
  				alert("Error Code: IO Error, File name: " + file.name + ", Message: " + msg);
  				break;
  			
  			case -40:	// Security error
  				alert("Error Code: Security Error, File name: " + file.name + ", Message: " + msg);
  				break;
  
  			case -50:	// Filesize too big
  				alert("Error Code: Filesize exceeds limit, File name: " + file.name + ", File size: " + file.size + ", Message: " + msg);
  				break;
  			default:
  				alert("Error Code: " + errcode + ". File name: " + file.name + ", Message: " + msg);
  		}
  		
  	};
  	
  	SWFUpload.v102.debug = function (message) {
  		if (this.getSetting("debug_enabled")) {
  			if (window.console) {
  				window.console.log(message);
  			} else {
  				alert(message);
  			}
  		}
  	};
  	
  	
  	// Emulate the v1.0.2 function calls
  	SWFUpload.v102.browse = function() {
  		this.selectFiles();
  	};
  	SWFUpload.v102.upload = function () {
  		this.startUpload();
  	};
  	SWFUpload.v102.cancelFile = function (file_id) {
  		this.cancelUpload(file_id);
  	};
  	SWFUpload.v102.cancelQueue = function () {
  		var stats = this.getStats();
  		while (stats["files_queued"] > 0) {
  			this.customSettings["queue_cancelled_flag"] = true;
  			this.cancelUpload();
  			stats = this.getStats();
  		}
  		
  		if (status.in_progress === 0) {
  			this.customSettings["queue_cancelled_flag"] = false;
  		}
  	};
  }