vertical-s3_swf_upload 0.3.2.1

data/flex_src/compile

@@ -0,0 +1,2 @@
+#!/bin/bash
+mxmlc -load-config ./bin-release/flex-config.xml ./src/S3Uploader.as -output ../lib/s3_swf_upload/railties/generators/uploader/templates/s3_upload.swf

data/flex_src/src/Globals.as

@@ -0,0 +1,15 @@
+package  {
+	
+	import com.nathancolgate.s3_swf_upload.S3Queue;
+	
+	public dynamic class Globals extends Object{
+		
+		public static var queue:S3Queue;
+		
+		public function Globals(){
+			super();
+			return;
+		}
+
+	}
+}

data/flex_src/src/S3Uploader.as

@@ -0,0 +1,204 @@
+package  {
+
+	import flash.events.*;
+	import flash.external.*;
+	import flash.net.*;
+	import flash.display.*;
+	import flash.system.Security;
+	import com.nathancolgate.s3_swf_upload.*;
+	
+	public class S3Uploader extends Sprite {
+		
+		//File Reference Vars
+		public var queue:S3Queue;
+		public var file:FileReference;
+		
+		private var _multipleFileDialogBox:FileReferenceList;
+		private var _singleFileDialogBox:FileReference;
+		private var _fileFilter:FileFilter;
+		
+		//config vars
+		private var _fileSizeLimit:Number; //bytes
+		private var _queueSizeLimit:Number;
+		private var _selectMultipleFiles:Boolean;
+		
+		private var cssLoader:URLLoader;
+		public static var s3_swf_obj:String;
+		
+		public function S3Uploader() {
+			super();
+			S3Uploader.s3_swf_obj = LoaderInfo(root.loaderInfo).parameters.s3_swf_obj;
+			registerCallbacks();
+		}
+
+		private function registerCallbacks():void {
+			if (ExternalInterface.available) {
+				ExternalInterface.addCallback("init", init);
+				ExternalInterface.call(S3Uploader.s3_swf_obj+'.init');
+			}
+		}
+
+		private function init(signatureUrl:String,  
+		                      prefixPath:String, 
+		                      fileSizeLimit:Number,
+													queueSizeLimit:Number,
+		                      fileTypes:String,
+		                      fileTypeDescs:String,
+													selectMultipleFiles:Boolean,
+													buttonWidth:Number,
+													buttonHeight:Number,
+													buttonUpUrl:String,
+													buttonDownUrl:String,
+													buttonOverUrl:String
+													):void {
+			// ExternalInterface.call('s3_swf.jsLog','Initializing...');
+			
+			flash.system.Security.allowDomain("*");
+			
+			// UI
+			var browseButton:BrowseButton = new BrowseButton(buttonWidth,buttonHeight,buttonUpUrl,buttonDownUrl,buttonOverUrl);
+		  addChild(browseButton);
+
+
+      stage.showDefaultContextMenu = false;
+      stage.scaleMode = flash.display.StageScaleMode.NO_SCALE;
+      stage.align = flash.display.StageAlign.TOP_LEFT;
+
+			this.addEventListener(MouseEvent.CLICK, clickHandler);
+
+			// file dialog boxes
+			// We do two, so that we have the option to pick one or many
+			_fileSizeLimit 					= fileSizeLimit;
+			_fileFilter 						= new FileFilter(fileTypeDescs, fileTypes);
+			_queueSizeLimit 				= queueSizeLimit;
+			_selectMultipleFiles		= selectMultipleFiles;
+			_multipleFileDialogBox	= new FileReferenceList;
+			_singleFileDialogBox 		= new FileReference;
+			_multipleFileDialogBox.addEventListener(Event.SELECT, selectFileHandler);
+			_singleFileDialogBox.addEventListener(Event.SELECT, selectFileHandler);
+
+			
+
+			// Setup Queue, File
+			this.queue 						= new S3Queue(signatureUrl,prefixPath);
+			Globals.queue					= this.queue;
+			
+			ExternalInterface.addCallback("removeFileFromQueue", removeFileHandler);
+			// ExternalInterface.call('s3_swf.jsLog','Initialized');
+			
+		}
+		
+		// called when the browse button is clicked
+		// Browse for files
+		private function clickHandler(event:Event):void{
+			// ExternalInterface.call('s3_swf.jsLog','clickHandler');
+			if(_selectMultipleFiles == true){
+				// ExternalInterface.call('s3_swf.jsLog','Opening Multiple File Dialog box...');
+				_multipleFileDialogBox.browse([_fileFilter]);
+				// ExternalInterface.call('s3_swf.jsLog','Multiple File Dialog box Opened');
+			} else {
+				// ExternalInterface.call('s3_swf.jsLog','Opening Single File Dialog box...');
+				_singleFileDialogBox.browse([_fileFilter]);
+				// ExternalInterface.call('s3_swf.jsLog','Single File Dialog box Opened');
+			}
+		}
+
+		//  called after user selected files form the browse dialouge box.
+		private function selectFileHandler(event:Event):void {
+			// ExternalInterface.call('s3_swf.jsLog','selectFileHandler');
+			var remainingSpots:int = _queueSizeLimit - this.queue.length;
+			var tooMany:Boolean = false;
+			
+			if(_selectMultipleFiles == true){
+				// Adding multiple files to the queue array
+				// ExternalInterface.call('s3_swf.jsLog','Adding multiple files to the queue array...');
+				if(event.currentTarget.fileList.length > remainingSpots) { tooMany = true; }
+				var i:int;
+				for (i=0;i < remainingSpots; i ++){
+					// ExternalInterface.call('s3_swf.jsLog','Adding '+(i+1)+' of '+(remainingSpots)+' files to the queue array...');
+					addFile(event.currentTarget.fileList[i]);
+					// ExternalInterface.call('s3_swf.jsLog',(i+1)+' of '+(remainingSpots)+' files added to the queue array');
+				}
+				// ExternalInterface.call('s3_swf.jsLog','Multiple files added to the queue array');
+			} else {
+				// Adding one single file to the queue array
+				// ExternalInterface.call('s3_swf.jsLog','Adding single file to the queue array...');
+				if(remainingSpots > 0) {
+					addFile(FileReference(event.target));
+				} else {
+					tooMany = true;
+				}
+				// ExternalInterface.call('s3_swf.jsLog','Single file added to the queue array');
+			}
+			
+			if(tooMany == true) {
+				// ExternalInterface.call('s3_swf.jsLog','Calling onQueueSizeLimitReached...');
+				ExternalInterface.call(S3Uploader.s3_swf_obj+'.onQueueSizeLimitReached',this.queue.toJavascript());
+				// ExternalInterface.call('s3_swf.jsLog','onQueueSizeLimitReached called');
+			}
+
+		}
+		
+		// Add Selected File to Queue from file browser dialog box
+		private function addFile(file:FileReference):void{
+			// ExternalInterface.call('s3_swf.jsLog','addFile');
+			if(!file) return;
+			if (checkFileSize(file.size)){
+				// ExternalInterface.call('s3_swf.jsLog','Adding file to queue...');
+				this.queue.addItem(file);
+				// ExternalInterface.call('s3_swf.jsLog','File added to queue');
+				// ExternalInterface.call('s3_swf.jsLog','Calling onFileAdd...');
+				ExternalInterface.call(S3Uploader.s3_swf_obj+'.onFileAdd',toJavascript(file));
+				// ExternalInterface.call('s3_swf.jsLog','onFileAdd called');
+			}  else {
+				// ExternalInterface.call('s3_swf.jsLog','Calling onFileSizeLimitReached...');
+				ExternalInterface.call(S3Uploader.s3_swf_obj+'.onFileSizeLimitReached',toJavascript(file));
+				// ExternalInterface.call('s3_swf.jsLog','onFileSizeLimitReached called');
+			}
+		}
+		
+		
+		// Remove File From Queue by index number
+		private function removeFileHandler(index:Number):void{
+			try {
+				var del_file:FileReference = FileReference(this.queue.getItemAt(index));
+				this.queue.removeItemAt(index);
+				// ExternalInterface.call('s3_swf.jsLog','Calling onFileRemove...');
+				ExternalInterface.call(S3Uploader.s3_swf_obj+'.onFileRemove',del_file);
+				// ExternalInterface.call('s3_swf.jsLog','onFileRemove called');
+			} catch(e:Error) {	
+				// ExternalInterface.call('s3_swf.jsLog','Calling onFileNotInQueue...');
+				ExternalInterface.call(S3Uploader.s3_swf_obj+'.onFileNotInQueue');
+				// ExternalInterface.call('s3_swf.jsLog','onFileNotInQueue called');
+			}
+		}
+
+
+		/* MISC */
+
+		// Checks the files do not exceed maxFileSize | if maxFileSize == 0 No File Limit Set
+		private function checkFileSize(filesize:Number):Boolean{
+			var r:Boolean = false;
+			//if  filesize greater then maxFileSize
+			if (filesize > _fileSizeLimit){
+				r = false;
+			} else if (filesize <= _fileSizeLimit){
+				r = true;
+			}
+			if (_fileSizeLimit == 0){
+				r = true;
+			}
+			return r;
+		}
+		
+		// Turns a FileReference into an Object so that ExternalInterface doesn't choke
+		private function toJavascript(file:FileReference):Object{
+			var javascriptable_file:Object = new Object();
+			javascriptable_file.name = file.name;
+			javascriptable_file.size = file.size;
+			javascriptable_file.type = file.type;
+			return javascriptable_file;
+		}
+		
+	}
+}

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;
+    }
+}