s3_swf_upload 0.3.2

data/flex_src/src/com/adobe/net/MimeTypeMap.as

@@ -0,0 +1,196 @@
+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are
+  met:
+
+  * Redistributions of source code must retain the above copyright notice, 
+    this list of conditions and the following disclaimer.
+  
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the 
+    documentation and/or other materials provided with the distribution.
+  
+  * Neither the name of Adobe Systems Incorporated nor the names of its 
+    contributors may be used to endorse or promote products derived from 
+    this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package com.adobe.net
+{
+	public class MimeTypeMap
+	{
+		private var types:Array = 
+			[["application/andrew-inset","ez"],
+			["application/atom+xml","atom"],
+			["application/mac-binhex40","hqx"],
+			["application/mac-compactpro","cpt"],
+			["application/mathml+xml","mathml"],
+			["application/msword","doc"],
+			["application/octet-stream","bin","dms","lha","lzh","exe","class","so","dll","dmg"],
+			["application/oda","oda"],
+			["application/ogg","ogg"],
+			["application/pdf","pdf"],
+			["application/postscript","ai","eps","ps"],
+			["application/rdf+xml","rdf"],
+			["application/smil","smi","smil"],
+			["application/srgs","gram"],
+			["application/srgs+xml","grxml"],
+			["application/vnd.adobe.apollo-application-installer-package+zip","air"],
+			["application/vnd.mif","mif"],
+			["application/vnd.mozilla.xul+xml","xul"],
+			["application/vnd.ms-excel","xls"],
+			["application/vnd.ms-powerpoint","ppt"],
+			["application/vnd.rn-realmedia","rm"],
+			["application/vnd.wap.wbxml","wbxml"],
+			["application/vnd.wap.wmlc","wmlc"],
+			["application/vnd.wap.wmlscriptc","wmlsc"],
+			["application/voicexml+xml","vxml"],
+			["application/x-bcpio","bcpio"],
+			["application/x-cdlink","vcd"],
+			["application/x-chess-pgn","pgn"],
+			["application/x-cpio","cpio"],
+			["application/x-csh","csh"],
+			["application/x-director","dcr","dir","dxr"],
+			["application/x-dvi","dvi"],
+			["application/x-futuresplash","spl"],
+			["application/x-gtar","gtar"],
+			["application/x-hdf","hdf"],
+			["application/x-javascript","js"],
+			["application/x-koan","skp","skd","skt","skm"],
+			["application/x-latex","latex"],
+			["application/x-netcdf","nc","cdf"],
+			["application/x-sh","sh"],
+			["application/x-shar","shar"],
+			["application/x-shockwave-flash","swf"],
+			["application/x-stuffit","sit"],
+			["application/x-sv4cpio","sv4cpio"],
+			["application/x-sv4crc","sv4crc"],
+			["application/x-tar","tar"],
+			["application/x-tcl","tcl"],
+			["application/x-tex","tex"],
+			["application/x-texinfo","texinfo","texi"],
+			["application/x-troff","t","tr","roff"],
+			["application/x-troff-man","man"],
+			["application/x-troff-me","me"],
+			["application/x-troff-ms","ms"],
+			["application/x-ustar","ustar"],
+			["application/x-wais-source","src"],
+			["application/xhtml+xml","xhtml","xht"],
+			["application/xml","xml","xsl"],
+			["application/xml-dtd","dtd"],
+			["application/xslt+xml","xslt"],
+			["application/zip","zip"],
+			["audio/basic","au","snd"],
+			["audio/midi","mid","midi","kar"],
+			["audio/mpeg","mp3","mpga","mp2"],
+			["audio/x-aiff","aif","aiff","aifc"],
+			["audio/x-mpegurl","m3u"],
+			["audio/x-pn-realaudio","ram","ra"],
+			["audio/x-wav","wav"],
+			["chemical/x-pdb","pdb"],
+			["chemical/x-xyz","xyz"],
+			["image/bmp","bmp"],
+			["image/cgm","cgm"],
+			["image/gif","gif"],
+			["image/ief","ief"],
+			["image/jpeg","jpg","jpeg","jpe"],
+			["image/png","png"],
+			["image/svg+xml","svg"],
+			["image/tiff","tiff","tif"],
+			["image/vnd.djvu","djvu","djv"],
+			["image/vnd.wap.wbmp","wbmp"],
+			["image/x-cmu-raster","ras"],
+			["image/x-icon","ico"],
+			["image/x-portable-anymap","pnm"],
+			["image/x-portable-bitmap","pbm"],
+			["image/x-portable-graymap","pgm"],
+			["image/x-portable-pixmap","ppm"],
+			["image/x-rgb","rgb"],
+			["image/x-xbitmap","xbm"],
+			["image/x-xpixmap","xpm"],
+			["image/x-xwindowdump","xwd"],
+			["model/iges","igs","iges"],
+			["model/mesh","msh","mesh","silo"],
+			["model/vrml","wrl","vrml"],
+			["text/calendar","ics","ifb"],
+			["text/css","css"],
+			["text/html","html","htm"],
+			["text/plain","txt","asc"],
+			["text/richtext","rtx"],
+			["text/rtf","rtf"],
+			["text/sgml","sgml","sgm"],
+			["text/tab-separated-values","tsv"],
+			["text/vnd.wap.wml","wml"],
+			["text/vnd.wap.wmlscript","wmls"],
+			["text/x-setext","etx"],
+			["video/mpeg","mpg","mpeg","mpe"],
+			["video/quicktime","mov","qt"],
+			["video/vnd.mpegurl","m4u","mxu"],
+			["video/x-flv","flv"],
+			["video/x-msvideo","avi"],
+			["video/x-sgi-movie","movie"],
+			["x-conference/x-cooltalk","ice"]];
+		
+		/**
+		 * Returns the mimetype for the given extension.
+		 */
+		public function getMimeType(extension:String):String
+		{
+			extension = extension.toLocaleLowerCase();
+			for each (var a:Array in types)
+			{
+				for each (var b:String in a)
+				{
+					if (b == extension)
+					{
+						return a[0];
+					}
+				}
+			}
+			return null;
+		}
+
+		/**
+		 * Returns the prefered extension for the given mimetype.
+		 */
+		public function getExtension(mimetype:String):String
+		{
+			mimetype = mimetype.toLocaleLowerCase();
+			for each (var a:Array in types)
+			{
+				if (a[0] == mimetype)
+				{
+					return a[1];
+				}
+			}
+			return null;
+		}
+
+		/**
+		 * Adds a mimetype to the map. The order of the extensions matters. The most preferred should come first.
+		 */
+		public function addMimeType(mimetype:String, extensions:Array):void
+		{
+			var newType:Array = [mimetype];
+			for each (var a:String in extensions)
+			{
+				newType.push(a);
+			}
+			types.push(newType);
+		}
+	}
+}

data/flex_src/src/com/elctech/S3UploadOptions.as

@@ -0,0 +1,32 @@
+package com.elctech {
+    public class S3UploadOptions {
+    	/**
+         * Options specified at:
+         * http://docs.amazonwebservices.com/AmazonS3/2006-03-01/HTTPPOSTForms.html
+       	 */
+        public var AWSAccessKeyId:String;
+        public var acl:String;
+        public var bucket:String;
+        public var CacheControl:String;
+        public var ContentType:String;
+        public var ContentDisposition:String;
+        public var ContentEncoding:String;
+        public var Expires:String;
+        public var key:String;
+        public var newKey:String;
+        public var policy:String;
+        public var successactionredirect:String;
+        public var redirect:String;
+        public var successactionstatus:String;
+        public var signature:String;
+        public var xamzsecuritytoken:String;
+        public var file:String;
+        
+        /**
+         * Addition field
+         */
+        public var Secure:String;           /* A flag indicating whether HTTPS should be used. */
+        public var FileName:String;
+        public var FileSize:String;
+    }
+}

data/flex_src/src/com/elctech/S3UploadRequest.as

@@ -0,0 +1,259 @@
+package com.elctech {
+
+	// import flash.events.*;
+	import flash.events.EventDispatcher;
+	import flash.events.ProgressEvent;
+	import flash.events.Event;
+	import flash.events.IOErrorEvent;
+	import flash.events.SecurityErrorEvent;
+	import flash.events.HTTPStatusEvent;
+	import flash.events.DataEvent;
+	
+	// import flash.net.*;
+  import flash.net.FileReference;
+	import flash.net.URLVariables;
+  import flash.net.URLRequest;
+	import flash.net.URLRequestMethod;
+
+	import flash.system.Security;
+	import flash.xml.XMLDocument;
+	import flash.xml.XMLNode;
+	// import mx.controls.Alert;
+	
+	/**
+     * This class encapsulates a POST request to S3.
+     * 
+     * After you create an S3PostRequest, invoke S3PostRequest::upload(fileReference:FileReference).
+     * 
+     */
+	public class S3UploadRequest extends EventDispatcher {
+
+		[Event(name="open", type="flash.events.Event.OPEN")]
+        [Event(name="uploadCompleteData", type="flash.events.DataEvent.UPLOAD_COMPLETE_DATA")]        
+        [Event(name="ioError", type="flash.events.IOErrorEvent.IO_ERROR")]
+        [Event(name="securityError", type="flash.events.SecurityErrorEvent.SECURITY_ERROR")]
+        [Event(name="progress", type="flash.events.ProgressEvent.PROGRESS")]
+        
+        private var _accessKeyId:String;
+        private var _bucket:String;
+        private var _key:String;
+        private var _options:S3UploadOptions;
+        private var _httpStatusErrorReceived:Boolean;
+        private var _uploadStarted:Boolean;
+        private var fileReference:FileReference;
+        
+        private const ENDPOINT:String = "s3.amazonaws.com";
+        private const MIN_BUCKET_LENGTH:int = 3;
+        private const MAX_BUCKET_LENGTH:int = 63;
+		
+		
+		/**
+         * Creates and initializes a new S3PostRequest object.
+         * @param    accessKeyId The AWS access key id to authenticate the request
+         * @param    bucket The bucket to POST into
+         * @param    key The key to create
+         * @param    options Options for this request
+         */
+		public function S3UploadRequest(options:S3UploadOptions) {
+			
+            _accessKeyId = options.AWSAccessKeyId;
+            _bucket      = options.bucket;
+            _key         = options.key;
+            _options     = options;
+            
+            if (options.newKey) {  //NOTE that we stop caring about the specified prefix if we have a newkey.
+              _key = options.newKey;
+              options.key = options.newKey; //so we output the right value in callbacks, etc.
+            }
+		}
+
+		private function buildUrl():String {
+
+            var canUseVanityStyle:Boolean = canUseVanityStyle(_bucket);
+            
+            if(_options.Secure!="false" && canUseVanityStyle && _bucket.match(/\./)) {
+                // We cannot use SSL for bucket names containing "."
+                // The certificate won't match "my.bucket.s3.amazonaws.com"
+                throw new SecurityError("Cannot use SSL with bucket name containing '.': " + _bucket);
+            }
+            
+            var postUrl:String = "http" + ((_options.Secure == 'true') ? "s" : "") + "://";
+            
+            if(canUseVanityStyle) {
+                postUrl += _bucket + "." + ENDPOINT;
+            } else {
+                postUrl += ENDPOINT + "/" + _bucket;
+            }
+            
+            return postUrl;
+        }
+        
+        private function canUseVanityStyle(bucket:String):Boolean {
+            if( bucket.length < MIN_BUCKET_LENGTH ||
+                bucket.length > MAX_BUCKET_LENGTH ||
+                bucket.match(/^\./) ||
+                bucket.match(/\.$/) ) {
+                return false;
+            }
+            
+            // must be lower case
+            if(bucket.toLowerCase() != bucket) {
+                return false;
+            }
+            
+            // Check not IPv4-like
+            if (bucket.match(/^[0-9]|+\.[0-9]|+\.[0-9]|+\.[0-9]|+$/)) {
+                return false;
+            }
+            
+                // Check each label
+            if(bucket.match(/\./)) {
+                var labels:Array = bucket.split(/\./);
+                for (var i:int = 0;i < labels.length; i++) {
+                    if(!labels[i].match(/^[a-z0-9]([a-z0-9\-]*[a-z0-9])?$/)) {
+                        return false;
+                    }
+                }
+            }
+            
+            return true;
+        }
+        
+        private function loadPolicyFile(postUrl:String):void {
+            /*
+             * Due to the restrictions imposed by the Adobe Flash security sandbox,
+             * the bucket being uploaded to must contain a public-readable crossdomain.xml
+             * file that allows access from the domain that served the SWF hosting this code.
+             * 
+             * Read Adobe's documentation on the Flash security sandbox for more information.
+             * 
+             */
+            
+            Security.loadPolicyFile(postUrl + "/crossdomain.xml");
+        }
+		
+				
+				public function removeListeners():void {
+						trace('removeListeners');
+            fileReference.removeEventListener(Event.OPEN, onOpen);
+            fileReference.removeEventListener(ProgressEvent.PROGRESS, onProgress);
+            fileReference.removeEventListener(IOErrorEvent.IO_ERROR, onIOError);
+            fileReference.removeEventListener(SecurityErrorEvent.SECURITY_ERROR, onSecurityError);
+            fileReference.removeEventListener(DataEvent.UPLOAD_COMPLETE_DATA, onUploadCompleteData);
+            fileReference.removeEventListener(HTTPStatusEvent.HTTP_STATUS, onHttpStatus);
+				}
+		/**
+         * Initiates a POST upload request to S3
+         * @param    fileReference A FileReference object referencing the file to upload to S3.
+         */
+        public function upload(_fileReference:FileReference):void {
+            
+            if(_uploadStarted) {
+                throw new Error("S3PostRequest object cannot be reused.  Create another S3PostRequest object to send another request to Amazon S3.");
+            }
+            _uploadStarted = true;
+
+            // Save the FileReference object so that it doesn't get GCed.
+            // If this happens, we can lose events that should be dispatched.
+            fileReference = _fileReference;
+
+            var postUrl:String = buildUrl();
+            loadPolicyFile(postUrl);
+            var urlRequest:URLRequest = new URLRequest(postUrl);
+            urlRequest.method = URLRequestMethod.POST;
+            urlRequest.data = buildPostVariables();
+            
+            // set up event handlers *****************************************************
+            fileReference.addEventListener(Event.OPEN, onOpen);
+            fileReference.addEventListener(ProgressEvent.PROGRESS, onProgress);
+            fileReference.addEventListener(IOErrorEvent.IO_ERROR, onIOError);
+            fileReference.addEventListener(SecurityErrorEvent.SECURITY_ERROR, onSecurityError);
+            fileReference.addEventListener(DataEvent.UPLOAD_COMPLETE_DATA, onUploadCompleteData);
+            fileReference.addEventListener(HTTPStatusEvent.HTTP_STATUS, onHttpStatus);
+            // *****************************************************************************
+            
+            // send the request
+            fileReference.upload(urlRequest, "file", false);
+        }
+        
+        private function buildPostVariables():URLVariables {
+            
+            var postVariables:URLVariables = new URLVariables();
+            
+            postVariables.key                     = _key;
+            postVariables.acl                     = _options.acl;
+            postVariables.AWSAccessKeyId          = _accessKeyId;
+            postVariables.signature               = _options.signature;
+            postVariables["Content-Type"]         = _options.ContentType;
+            postVariables["Content-Disposition"]  = "attachment";
+            postVariables.policy                  = _options.policy;
+            
+            /**
+             * Certain combinations of Flash player version and platform don't handle
+             * HTTP responses with the header 'Content-Length: 0'.  These clients do not
+             * dispatch completion or error events when such a response is received.
+             * Therefore it is impossible to tell when the upload has completed or failed.
+             * 
+             * Flash clients should always set the success_action_status parameter to 201
+             * so that Amazon S3 returns a response with Content-Length being non-zero.
+             * 
+             */
+            postVariables.success_action_status = "201";
+            
+            return postVariables;
+        }
+        
+        private function onOpen(event:Event):void {
+						trace('onOpen: '+this._key);
+            this.dispatchEvent(event);
+        }
+        private function onIOError(event:IOErrorEvent):void {
+            /*
+             * FileReference.upload likes to send cryptic IOErrors when it doesn't get a status code that it likes.
+             * If we already got an error HTTP status code, don't propagate this event since the HTTPStatusEvent
+             * event handler dispatches an IOErrorEvent.
+             */
+            if(!_httpStatusErrorReceived) {
+                this.dispatchEvent(event);
+            }
+        }
+        private function onSecurityError(event:SecurityErrorEvent):void {
+            this.dispatchEvent(event);
+        }
+        private function onProgress(event:ProgressEvent):void {
+            this.dispatchEvent(event);
+        }
+        private function onUploadCompleteData(event:DataEvent):void {
+            var data:String = event.data;
+            if(isError(data)) {
+                this.dispatchEvent(
+                    new IOErrorEvent(IOErrorEvent.IO_ERROR, event.bubbles, event.cancelable, "Amazon S3 returned an error: " + data + ".")
+                );
+            } else {
+                this.dispatchEvent(new DataEvent(DataEvent.UPLOAD_COMPLETE_DATA, event.bubbles, event.cancelable, data));
+            }
+        }
+        private function onHttpStatus(event:HTTPStatusEvent):void {
+            _httpStatusErrorReceived = true;
+            if(Math.floor(event.status/100) == 2) {
+                this.dispatchEvent(new DataEvent(DataEvent.UPLOAD_COMPLETE_DATA, event.bubbles, event.cancelable, "Amazon S3 returned HTTP status " + event.status.toString() + "."));
+            } else {
+                this.dispatchEvent(new IOErrorEvent(IOErrorEvent.IO_ERROR, event.bubbles, event.cancelable, "Amazon S3 returned an error: HTTP status " + event.status.toString() + "."));
+            }
+        }
+		
+		private function isError(responseText:String):Boolean {
+            var xml:XMLDocument = new XMLDocument();
+            xml.ignoreWhite = true;
+            xml.parseXML(responseText);
+            var root:XMLNode = xml.firstChild;
+            if( root == null || root.nodeName != "Error" )
+            {
+                return false;
+            }
+            return true;
+        }
+
+	}
+	
+}

data/flex_src/src/com/nathancolgate/s3_swf_upload/BrowseButton.as

@@ -0,0 +1,55 @@
+package com.nathancolgate.s3_swf_upload {
+	
+	import flash.display.*;
+	import flash.events.MouseEvent;
+	import flash.events.Event;
+	import flash.net.*;
+
+	public dynamic class BrowseButton extends Sprite {
+
+		private var _playButton:flash.display.SimpleButton;
+		
+		public function BrowseButton(width:Number,
+																	height:Number,
+																	buttonUpUrl:String,
+																	buttonDownUrl:String,
+																	buttonOverUrl:String)
+		{
+			super();
+			
+			_playButton = new flash.display.SimpleButton();
+			_playButton.useHandCursor = true;
+			addChild(_playButton);
+			
+			// Hit Test
+      var hit_test:Shape = new flash.display.Shape();            
+			hit_test.graphics.beginFill(0xFFCC00);
+      hit_test.graphics.drawRect(0, 0, width, height);            
+			hit_test.graphics.endFill();
+			_playButton.hitTestState = hit_test;
+			
+			// Up
+			var upLoader:Loader = new Loader();
+			upLoader.contentLoaderInfo.addEventListener(Event.COMPLETE,function(e:Event):void{ 
+				_playButton.upState = new Bitmap(e.target.content.bitmapData);
+			});
+			upLoader.load(new URLRequest(buttonUpUrl));
+
+			// Down
+			var downLoader:Loader = new Loader();
+			downLoader.contentLoaderInfo.addEventListener(Event.COMPLETE,function(e:Event):void{ 
+				_playButton.downState = new Bitmap(e.target.content.bitmapData);
+			});
+			downLoader.load(new URLRequest(buttonDownUrl));
+			
+			// Over
+			var overLoader:Loader = new Loader();
+			overLoader.contentLoaderInfo.addEventListener(Event.COMPLETE,function(e:Event):void{ 
+				_playButton.overState = new Bitmap(e.target.content.bitmapData);
+			});
+			overLoader.load(new URLRequest(buttonOverUrl));
+		}
+
+
+	}
+}

data/flex_src/src/com/nathancolgate/s3_swf_upload/S3Queue.as

@@ -0,0 +1,117 @@
+package com.nathancolgate.s3_swf_upload {
+	
+	import mx.collections.ArrayCollection;
+	import mx.events.CollectionEvent;
+  import flash.external.ExternalInterface;
+	import flash.net.FileReference;
+	import com.nathancolgate.s3_swf_upload.*;
+	
+  public class S3Queue extends ArrayCollection {
+	
+		// S3 Interaction Vars
+		private var _signatureUrl:String;
+		private var _prefixPath:String;
+
+		public var currentSignature:S3Signature;		
+
+		public function S3Queue(signatureUrl:String,
+														prefixPath:String,
+														source:Array = null) {
+															
+			_signatureUrl = signatureUrl;
+			_prefixPath	  = prefixPath;
+			super(source);
+
+			// Outgoing calls
+			this.addEventListener(CollectionEvent.COLLECTION_CHANGE, changeHandler);
+			// Incoming calls
+			ExternalInterface.addCallback("startUploading", startUploadingHandler);
+			ExternalInterface.addCallback("clearQueue", clearHandler);
+			ExternalInterface.addCallback("stopUploading", stopUploadingHandler);
+		}
+		
+		public function uploadNextFile():void{
+			// ExternalInterface.call('s3_swf.jsLog','uploadNextFile');
+			// ExternalInterface.call('s3_swf.jsLog','Start uploadNextFile...');
+			var next_file:FileReference = FileReference(this.getItemAt(0));
+			currentSignature = new S3Signature(next_file,_signatureUrl,_prefixPath);
+			// ExternalInterface.call('s3_swf.jsLog','End uploadNextFile');
+		}
+		
+		// whenever the queue changes this function is called 
+		private function changeHandler(event:CollectionEvent):void{
+			// ExternalInterface.call('s3_swf.jsLog','changeHandler');
+			// ExternalInterface.call('s3_swf.jsLog','Calling onQueueChange...');
+			ExternalInterface.call(S3Uploader.s3_swf_obj+'.onQueueChange',this.toJavascript());
+			// ExternalInterface.call('s3_swf.jsLog','onQueueChange called');      
+		}
+		
+		// Remove all files from the upload queue;
+		private function clearHandler():void{
+			// ExternalInterface.call('s3_swf.jsLog','clearHandler');
+			// ExternalInterface.call('s3_swf.jsLog','Removing All...');
+			this.removeAll();
+			// ExternalInterface.call('s3_swf.jsLog','All removed');
+			// ExternalInterface.call('s3_swf.jsLog','Calling onQueueClear...');
+			ExternalInterface.call(S3Uploader.s3_swf_obj+'.onQueueClear',this.toJavascript());
+			// ExternalInterface.call('s3_swf.jsLog','onQueueClear called');
+		}
+
+		// Start uploading the files from the queue
+		private function startUploadingHandler():void{
+			// ExternalInterface.call('s3_swf.jsLog','startUploadingHandler');
+			if (this.length > 0){
+				// ExternalInterface.call('s3_swf.jsLog','Calling onUploadingStart...');
+				ExternalInterface.call(S3Uploader.s3_swf_obj+'.onUploadingStart');
+				// ExternalInterface.call('s3_swf.jsLog','onUploadingStart called');
+	      // ExternalInterface.call('s3_swf.jsLog','Uploading next file...');
+				uploadNextFile();
+				// ExternalInterface.call('s3_swf.jsLog','Next file uploaded');
+			} else {
+				// ExternalInterface.call('s3_swf.jsLog','Calling onQueueEmpty...');
+				ExternalInterface.call(S3Uploader.s3_swf_obj+'.onQueueEmpty',this);
+				// ExternalInterface.call('s3_swf.jsLog','onQueueEmpty called');
+			}
+		}
+		
+		// Cancel Current File Upload
+		// Which stops all future uploads as well
+		private function stopUploadingHandler():void{
+			// ExternalInterface.call('s3_swf.jsLog','stopUploadingHandler');
+			if (this.length > 0){
+				var current_file:FileReference = FileReference(this.getItemAt(0));
+				// ExternalInterface.call('s3_swf.jsLog','Cancelling current file...');
+				current_file.cancel();
+
+				currentSignature.s3upload.removeListeners();
+
+				// ExternalInterface.call('s3_swf.jsLog','Current file cancelled');
+				// ExternalInterface.call('s3_swf.jsLog','Calling onUploadingStop...');
+				ExternalInterface.call(S3Uploader.s3_swf_obj+'.onUploadingStop');
+				// ExternalInterface.call('s3_swf.jsLog','onUploadingStop called');
+	    } else {
+				// ExternalInterface.call('s3_swf.jsLog','Calling onQueueEmpty...');
+				ExternalInterface.call(S3Uploader.s3_swf_obj+'.onQueueEmpty',this.toJavascript());
+				// ExternalInterface.call('s3_swf.jsLog','onQueueEmpty called');
+			}
+		}
+		
+		// This is a rather silly function to need, especially since it worked at one point
+		// In flash player 10.1, you could no longer send files over external reference
+		// This is the hack to get around the problem.  Essentially: turn all those 
+		// Files into objects
+		// August 27, 2010 - NCC@BNB
+		public function toJavascript():Object {
+			var faux_queue:Object = new Object();
+      faux_queue.files = new Array();
+			for (var i:int = 0;i < source.length; i++) {
+				faux_queue.files[i] = new Object();
+				faux_queue.files[i].name = source[i].name;
+	      faux_queue.files[i].size = source[i].size;
+	      faux_queue.files[i].type = source[i].type;
+      }
+			return faux_queue;
+		}
+
+	}
+}