plupload-rails 1.1.0 → 1.2.0

data/vendor/assets/javascripts/plupload.dev.js

@@ -1,6 +1,6 @@
 /**
  * Plupload - multi-runtime File Uploader
- * v2.0.0beta
+ * v2.1.1
  *
  * Copyright 2013, Moxiecode Systems AB
  * Released under GPL License.
@@ -8,7 +8,7 @@
  * License: http://www.plupload.com/license
  * Contributing: http://www.plupload.com/contributing
  *
- * Date: 2012-11-30
+ * Date: 2014-01-16
  */
 /**
  * Plupload.js
@@ -36,12 +36,10 @@ function normalizeCaps(settings) {
 		// Feature notation is deprecated, use caps (this thing here is required for backward compatibility)
 		var map = { 
 			chunks: 'slice_blob',
-			resize: 'send_binary_string',
 			jpgresize: 'send_binary_string',
 			pngresize: 'send_binary_string',
 			progress: 'report_upload_progress',
 			multi_selection: 'select_multiple',
-			max_file_size: 'access_binary',
 			dragdrop: 'drag_and_drop',
 			drop_element: 'drag_and_drop',
 			headers: 'send_custom_headers',
@@ -73,6 +71,10 @@ function normalizeCaps(settings) {
 		if (settings.chunk_size > 0) {
 			caps.slice_blob = true;
 		}
+
+		if (settings.resize.enabled) {
+			caps.send_binary_string = true;
+		}
 		
 		plupload.each(settings, function(value, feature) {
 			resolve(feature, !!value, true); // strict check
@@ -95,7 +97,7 @@ var plupload = {
 	 * @static
 	 * @final
 	 */
-	VERSION : '2.0.0beta',
+	VERSION : '2.1.1',
 
 	/**
 	 * Inital state of the queue and also the state ones it's finished all it's uploads.
@@ -301,6 +303,32 @@ var plupload = {
 	 */
 	guid : o.guid,
 
+	/**
+	 * Get array of DOM Elements by their ids.
+	 * 
+	 * @method get
+	 * @for Utils
+	 * @param {String} id Identifier of the DOM Element
+	 * @return {Array}
+	*/
+	get : function get(ids) {
+		var els = [], el;
+
+		if (o.typeOf(ids) !== 'array') {
+			ids = [ids];
+		}
+
+		var i = ids.length;
+		while (i--) {
+			el = o.get(ids[i]);
+			if (el) {
+				els.push(el);
+			}
+		}
+
+		return els.length ? els : null;
+	},
+
 	/**
 	 * Executes the callback function for each item in array/object. If you return false in the
 	 * callback it will break the loop.
@@ -542,28 +570,35 @@ var plupload = {
 	 * @return {String} Formatted size string.
 	 */
 	formatSize : function(size) {
+
 		if (size === undef || /\D/.test(size)) {
 			return plupload.translate('N/A');
 		}
 
+		function round(num, precision) {
+			return Math.round(num * Math.pow(10, precision)) / Math.pow(10, precision);
+		}
+
+		var boundary = Math.pow(1024, 4);
+
 		// TB
-		if (size > 1099511627776) {
-			return Math.round(size / 1099511627776, 1) + " " + plupload.translate('tb');
+		if (size > boundary) {
+			return round(size / boundary, 1) + " " + plupload.translate('tb');
 		}
 
 		// GB
-		if (size > 1073741824) {
-			return Math.round(size / 1073741824, 1) + " " + plupload.translate('gb');
+		if (size > (boundary/=1024)) {
+			return round(size / boundary, 1) + " " + plupload.translate('gb');
 		}
 
 		// MB
-		if (size > 1048576) {
-			return Math.round(size / 1048576, 1) + " " + plupload.translate('mb');
+		if (size > (boundary/=1024)) {
+			return round(size / boundary, 1) + " " + plupload.translate('mb');
 		}
 
 		// KB
 		if (size > 1024) {
-			return Math.round(size / 1024, 1) + " " + plupload.translate('kb');
+			return Math.round(size / 1024) + " " + plupload.translate('kb');
 		}
 
 		return size + " " + plupload.translate('b');
@@ -592,12 +627,10 @@ var plupload = {
 	 * @return {String} Type of compatible runtime
 	 */
 	predictRuntime : function(config, runtimes) {
-		var up, runtime; 
-		if (runtimes) {
-			config.runtimes = runtimes;
-		}
+		var up, runtime;
+
 		up = new plupload.Uploader(config);
-		runtime = up.runtime;
+		runtime = o.Runtime.thatCan(up.getOption().required_features, runtimes || config.runtimes);
 		up.destroy();
 		return runtime;
 	},
@@ -620,49 +653,25 @@ var plupload = {
 };
 
 
-plupload.addFileFilter('mime_types', (function() {
-	var _filters, _extRegExp;
-
-	// Convert extensions to regexp
-	function getExtRegExp(filters) {
-		var extensionsRegExp = [];
-
-		plupload.each(filters, function(filter) {
-			plupload.each(filter.extensions.split(/,/), function(ext) {
-				if (/^\s*\*\s*$/.test(ext)) {
-					extensionsRegExp.push('\\.*');
-				} else {
-					extensionsRegExp.push('\\.' + ext.replace(new RegExp('[' + ('/^$.*+?|()[]{}\\'.replace(/./g, '\\$&')) + ']', 'g'), '\\$&'));
-				}
-			});
+plupload.addFileFilter('mime_types', function(filters, file, cb) {
+	if (filters.length && !filters.regexp.test(file.name)) {
+		this.trigger('Error', {
+			code : plupload.FILE_EXTENSION_ERROR,
+			message : plupload.translate('File extension error.'),
+			file : file
 		});
-
-		return new RegExp('(' + extensionsRegExp.join('|') + ')$', 'i');
+		cb(false);
+	} else {
+		cb(true);
 	}
-
-	return function(filters, file, cb) {
-		if (!_extRegExp || filters != _filters) { // make sure we do it only once, unless filters got changed
-			_extRegExp = getExtRegExp(filters);
-			_filters = [].slice.call(filters);
-		}
-
-		if (!_extRegExp.test(file.name)) {
-			this.trigger('Error', {
-				code : plupload.FILE_EXTENSION_ERROR,
-				message : plupload.translate('File extension error.'),
-				file : file
-			});
-			cb(false);
-		} else {
-			cb(true);
-		}
-	};
-}()));
+});
 
 
 plupload.addFileFilter('max_file_size', function(maxSize, file, cb) {
 	var undef;
 
+	maxSize = plupload.parseSize(maxSize);
+
 	// Invalid file size
 	if (file.size !== undef && maxSize && file.size > maxSize) {
 		this.trigger('Error', {
@@ -728,7 +737,7 @@ plupload.addFileFilter('prevent_duplicates', function(value, file, cb) {
 	@param {String} [settings.silverlight_xap_url] URL of the Silverlight xap.
 	@param {Boolean} [settings.unique_names=false] If true will generate unique filenames for uploaded files.
 */
-plupload.Uploader = function(settings) {
+plupload.Uploader = function(options) {
 	/**
 	 * Fires when the current RunTime has been initialized.
 	 *
@@ -743,6 +752,17 @@ plupload.Uploader = function(settings) {
 	 * @param {plupload.Uploader} uploader Uploader instance sending the event.
 	 */
 
+	/**
+	 * Fires when the option is changed in via uploader.setOption().
+	 *
+	 * @event OptionChanged
+	 * @since 2.1
+	 * @param {plupload.Uploader} uploader Uploader instance sending the event.
+	 * @param {String} name Name of the option that was changed
+	 * @param {Mixed} value New value for the specified option
+	 * @param {Mixed} oldValue Previous value of the option
+	 */
+
 	/**
 	 * Fires when the silverlight/flash or other shim needs to move.
 	 *
@@ -790,13 +810,22 @@ plupload.Uploader = function(settings) {
 	 */
 
 	/**
-	 * Fires while a file was removed from queue.
+	 * Fires when file is removed from the queue.
 	 *
 	 * @event FilesRemoved
 	 * @param {plupload.Uploader} uploader Uploader instance sending the event.
 	 * @param {Array} files Array of files that got removed.
 	 */
 
+	/**
+	 * Fires for every filtered file before it is added to the queue.
+	 * 
+	 * @event FileFiltered
+	 * @since 2.1
+	 * @param {plupload.Uploader} uploader Uploader instance sending the event.
+	 * @param {plupload.File} file Another file that has to be added to the queue.
+	 */
+
 	/**
 	 * Fires after files were filtered and added to the queue.
 	 *
@@ -845,9 +874,17 @@ plupload.Uploader = function(settings) {
 	 * @event Destroy
 	 * @param {plupload.Uploader} uploader Uploader instance sending the event.
 	 */
-	var files = [], events = {}, required_caps = {},
-		startTime, total, disabled = false,
-		fileInput, fileDrop, xhr;
+	var uid = plupload.guid()
+	, settings
+	, files = []
+	, preferred_caps = {}
+	, fileInputs = []
+	, fileDrops = []
+	, startTime
+	, total
+	, disabled = false
+	, xhr
+	;
 
 
 	// Private methods
@@ -879,11 +916,13 @@ plupload.Uploader = function(settings) {
 		}
 	}
 
+
 	function calcFile(file) {
 		file.percent = file.size > 0 ? Math.ceil(file.loaded / file.size * 100) : 100;
 		calc();
 	}
 
+
 	function calc() {
 		var i, file;
 
@@ -923,14 +962,59 @@ plupload.Uploader = function(settings) {
 		}
 	}
 
-	function initControls() {
-		var self = this, initialized = 0;
+
+	function getRUID() {
+		var ctrl = fileInputs[0] || fileDrops[0];
+		if (ctrl) {
+			return ctrl.getRuntime().uid;
+		}
+		return false;
+	}
+
+
+	function runtimeCan(file, cap) {
+		if (file.ruid) {
+			var info = o.Runtime.getInfo(file.ruid);
+			if (info) {
+				return info.can(cap);
+			}
+		}
+		return false;
+	}
+
+
+	function bindEventListeners() {
+		this.bind('FilesAdded', onFilesAdded);
+
+		this.bind('CancelUpload', onCancelUpload);
+		
+		this.bind('BeforeUpload', onBeforeUpload);
+
+		this.bind('UploadFile', onUploadFile);
+
+		this.bind('UploadProgress', onUploadProgress);
+
+		this.bind('StateChanged', onStateChanged);
+
+		this.bind('QueueChanged', calc);
+
+		this.bind('Error', onError);
+
+		this.bind('FileUploaded', onFileUploaded);
+
+		this.bind('Destroy', onDestroy);
+	}
+
+
+	function initControls(settings, cb) {
+		var self = this, inited = 0, queue = [];
 
 		// common settings
 		var options = {
 			accept: settings.filters.mime_types,
 			runtime_order: settings.runtimes,
-			required_caps: required_caps,
+			required_caps: settings.required_features,
+			preferred_caps: preferred_caps,
 			swf_url: settings.flash_swf_url,
 			xap_url: settings.silverlight_xap_url
 		};
@@ -942,15 +1026,15 @@ plupload.Uploader = function(settings) {
 			}
 		});
 
-		o.inSeries([
-			function(cb) {
-				// Initialize file dialog trigger
-				if (settings.browse_button) {
-					fileInput = new o.FileInput(plupload.extend({}, options, {
+		// initialize file pickers - there can be many
+		if (settings.browse_button) {
+			plupload.each(settings.browse_button, function(el) {
+				queue.push(function(cb) {
+					var fileInput = new o.FileInput(plupload.extend({}, options, {
 						name: settings.file_data_name,
 						multiple: settings.multi_selection,
 						container: settings.container,
-						browse_button: settings.browse_button
+						browse_button: el
 					}));
 
 					fileInput.onready = function() {
@@ -963,7 +1047,8 @@ plupload.Uploader = function(settings) {
 							multi_selection: info.can('select_multiple')
 						});
 
-						initialized++;
+						inited++;
+						fileInputs.push(this);
 						cb();
 					};
 
@@ -973,24 +1058,20 @@ plupload.Uploader = function(settings) {
 
 					fileInput.bind('mouseenter mouseleave mousedown mouseup', function(e) {
 						if (!disabled) {
-							var bButton = o.get(settings.browse_button);
-							if (bButton) {
-								if (settings.browse_button_hover) {
-									if ('mouseenter' === e.type) {
-										o.addClass(bButton, settings.browse_button_hover);
-									} else if ('mouseleave' === e.type) {
-										o.removeClass(bButton, settings.browse_button_hover);
-									}
+							if (settings.browse_button_hover) {
+								if ('mouseenter' === e.type) {
+									o.addClass(el, settings.browse_button_hover);
+								} else if ('mouseleave' === e.type) {
+									o.removeClass(el, settings.browse_button_hover);
 								}
+							}
 
-								if (settings.browse_button_active) {
-									if ('mousedown' === e.type) {
-										o.addClass(bButton, settings.browse_button_active);
-									} else if ('mouseup' === e.type) {
-										o.removeClass(bButton, settings.browse_button_active);
-									}
+							if (settings.browse_button_active) {
+								if ('mousedown' === e.type) {
+									o.addClass(el, settings.browse_button_active);
+								} else if ('mouseup' === e.type) {
+									o.removeClass(el, settings.browse_button_active);
 								}
-								bButton = null;
 							}
 						}
 					});
@@ -1001,24 +1082,25 @@ plupload.Uploader = function(settings) {
 					});
 
 					fileInput.init();
-				} else {
-					cb();
-				}
-			},
+				});
+			});
+		}
 
-			function(cb) {
-				// Initialize drag/drop interface if requested
-				if (settings.drop_element) {
-					fileDrop = new o.FileDrop(plupload.extend({}, options, {
-						drop_zone: settings.drop_element
+		// initialize drop zones
+		if (settings.drop_element) {
+			plupload.each(settings.drop_element, function(el) {
+				queue.push(function(cb) {
+					var fileDrop = new o.FileDrop(plupload.extend({}, options, {
+						drop_zone: el
 					}));
 
 					fileDrop.onready = function() {
 						var info = o.Runtime.getInfo(this.ruid);
 
-						self.features.dragdrop = info.can('drag_and_drop');
+						self.features.dragdrop = info.can('drag_and_drop'); // for backward compatibility
 
-						initialized++;
+						inited++;
+						fileDrops.push(this);
 						cb();
 					};
 
@@ -1032,40 +1114,18 @@ plupload.Uploader = function(settings) {
 					});
 
 					fileDrop.init();
-				} else {
-					cb();
-				}
-			}
-		],
-		function() {
-			if (typeof(settings.init) == "function") {
-				settings.init(self);
-			} else {
-				plupload.each(settings.init, function(func, name) {
-					self.bind(name, func);
 				});
-			}
+			});
+		}
 
-			if (initialized) {
-				self.trigger('PostInit');
-			} else {
-				self.trigger('Error', {
-					code : plupload.INIT_ERROR,
-					message : plupload.translate('Init error.')
-				});
+
+		o.inSeries(queue, function() {
+			if (typeof(cb) === 'function') {
+				cb(inited);
 			}
 		});
 	}
 
-	function runtimeCan(file, cap) {
-		if (file.ruid) {
-			var info = o.Runtime.getInfo(file.ruid);
-			if (info) {
-				return info.can(cap);
-			}
-		}
-		return false;
-	}
 
 	function resizeImage(blob, params, cb) {
 		var img = new o.Image();
@@ -1091,50 +1151,476 @@ plupload.Uploader = function(settings) {
 	}
 
 
-	// Inital total state
-	total = new plupload.QueueProgress();
+	function setOption(option, value, init) {
+		var self = this, reinitRequired = false;
 
-	// Default settings
-	settings = plupload.extend({
-		runtimes: o.Runtime.order,
-		max_retries: 0,
-		multipart : true,
-		multi_selection : true,
-		file_data_name : 'file',
-		flash_swf_url : 'js/Moxie.swf',
-		silverlight_xap_url : 'js/Moxie.xap',
-		send_chunk_number: true // whether to send chunks and chunk numbers, or total and offset bytes
-	}, settings);
+		function _setOption(option, value, init) {
+			var oldValue = settings[option];
 
-	// Resize defaults
-	if (settings.resize) {
-		settings.resize = plupload.extend({
-			preserve_headers: true,
-			crop: false
-		}, settings.resize);
+			switch (option) {
+				case 'max_file_size':
+					if (option === 'max_file_size') {
+						settings.max_file_size = settings.filters.max_file_size = value;
+					}
+					break;
+
+				case 'chunk_size':
+					if (value = plupload.parseSize(value)) {
+						settings[option] = value;
+					}
+					break;
+
+				case 'filters':
+					// for sake of backward compatibility
+					if (plupload.typeOf(value) === 'array') {
+						value = {
+							mime_types: value
+						};
+					}
+
+					if (init) {
+						plupload.extend(settings.filters, value);
+					} else {
+						settings.filters = value;
+					}
+
+					// if file format filters are being updated, regenerate the matching expressions
+					if (value.mime_types) {
+						settings.filters.mime_types.regexp = (function(filters) {
+							var extensionsRegExp = [];
+
+							plupload.each(filters, function(filter) {
+								plupload.each(filter.extensions.split(/,/), function(ext) {
+									if (/^\s*\*\s*$/.test(ext)) {
+										extensionsRegExp.push('\\.*');
+									} else {
+										extensionsRegExp.push('\\.' + ext.replace(new RegExp('[' + ('/^$.*+?|()[]{}\\'.replace(/./g, '\\$&')) + ']', 'g'), '\\$&'));
+									}
+								});
+							});
+
+							return new RegExp('(' + extensionsRegExp.join('|') + ')$', 'i');
+						}(settings.filters.mime_types));
+					}
+					break;
+	
+				case 'resize':
+					if (init) {
+						plupload.extend(settings.resize, value, {
+							enabled: true
+						});
+					} else {
+						settings.resize = value;
+					}
+					break;
+
+				case 'prevent_duplicates':
+					settings.prevent_duplicates = settings.filters.prevent_duplicates = !!value;
+					break;
+
+				case 'browse_button':
+				case 'drop_element':
+						value = plupload.get(value);
+
+				case 'container':
+				case 'runtimes':
+				case 'multi_selection':
+				case 'flash_swf_url':
+				case 'silverlight_xap_url':
+					settings[option] = value;
+					if (!init) {
+						reinitRequired = true;
+					}
+					break;
+
+				default:
+					settings[option] = value;
+			}
+
+			if (!init) {
+				self.trigger('OptionChanged', option, value, oldValue);
+			}
+		}
+
+		if (typeof(option) === 'object') {
+			plupload.each(option, function(value, option) {
+				_setOption(option, value, init);
+			});
+		} else {
+			_setOption(option, value, init);
+		}
+
+		if (init) {
+			// Normalize the list of required capabilities
+			settings.required_features = normalizeCaps(plupload.extend({}, settings));
+
+			// Come up with the list of capabilities that can affect default mode in a multi-mode runtimes
+			preferred_caps = normalizeCaps(plupload.extend({}, settings, {
+				required_features: true
+			}));
+		} else if (reinitRequired) {
+			self.trigger('Destroy');
+			
+			initControls.call(self, settings, function(inited) {
+				if (inited) {
+					self.runtime = o.Runtime.getInfo(getRUID()).type;
+					self.trigger('Init', { runtime: self.runtime });
+					self.trigger('PostInit');
+				} else {
+					self.trigger('Error', {
+						code : plupload.INIT_ERROR,
+						message : plupload.translate('Init error.')
+					});
+				}
+			});
+		}
 	}
 
-	// Set file filters
-	if (plupload.typeOf(settings.filters) === 'array') {
-		settings.filters = {
-			mime_types: settings.filters
-		};
+
+	// Internal event handlers
+	function onFilesAdded(up, filteredFiles) {
+		// Add files to queue				
+		[].push.apply(files, filteredFiles);
+
+		up.trigger('QueueChanged');
+		up.refresh();
+	}
+
+
+	function onBeforeUpload(up, file) {
+		// Generate unique target filenames
+		if (settings.unique_names) {
+			var matches = file.name.match(/\.([^.]+)$/), ext = "part";
+			if (matches) {
+				ext = matches[1];
+			}
+			file.target_name = file.id + '.' + ext;
+		}
+	}
+
+
+	function onUploadFile(up, file) {
+		var url = up.settings.url
+		, chunkSize = up.settings.chunk_size
+		, retries = up.settings.max_retries
+		, features = up.features
+		, offset = 0
+		, blob
+		;
+
+		// make sure we start at a predictable offset
+		if (file.loaded) {
+			offset = file.loaded = chunkSize * Math.floor(file.loaded / chunkSize);
+		}
+
+		function handleError() {
+			if (retries-- > 0) {
+				delay(uploadNextChunk, 1000);
+			} else {
+				file.loaded = offset; // reset all progress
+
+				up.trigger('Error', {
+					code : plupload.HTTP_ERROR,
+					message : plupload.translate('HTTP Error.'),
+					file : file,
+					response : xhr.responseText,
+					status : xhr.status,
+					responseHeaders: xhr.getAllResponseHeaders()
+				});
+			}
+		}
+
+		function uploadNextChunk() {
+			var chunkBlob, formData, args, curChunkSize;
+
+			// File upload finished
+			if (file.status == plupload.DONE || file.status == plupload.FAILED || up.state == plupload.STOPPED) {
+				return;
+			}
+
+			// Standard arguments
+			args = {name : file.target_name || file.name};
+
+			if (chunkSize && features.chunks && blob.size > chunkSize) { // blob will be of type string if it was loaded in memory 
+				curChunkSize = Math.min(chunkSize, blob.size - offset);
+				chunkBlob = blob.slice(offset, offset + curChunkSize);
+			} else {
+				curChunkSize = blob.size;
+				chunkBlob = blob;
+			}
+
+			// If chunking is enabled add corresponding args, no matter if file is bigger than chunk or smaller
+			if (chunkSize && features.chunks) {
+				// Setup query string arguments
+				if (up.settings.send_chunk_number) {
+					args.chunk = Math.ceil(offset / chunkSize);
+					args.chunks = Math.ceil(blob.size / chunkSize);
+				} else { // keep support for experimental chunk format, just in case
+					args.offset = offset;
+					args.total = blob.size;
+				}
+			}
+
+			xhr = new o.XMLHttpRequest();
+
+			// Do we have upload progress support
+			if (xhr.upload) {
+				xhr.upload.onprogress = function(e) {
+					file.loaded = Math.min(file.size, offset + e.loaded);
+					up.trigger('UploadProgress', file);
+				};
+			}
+
+			xhr.onload = function() {
+				// check if upload made itself through
+				if (xhr.status >= 400) {
+					handleError();
+					return;
+				}
+
+				retries = up.settings.max_retries; // reset the counter
+
+				// Handle chunk response
+				if (curChunkSize < blob.size) {
+					chunkBlob.destroy();
+
+					offset += curChunkSize;
+					file.loaded = Math.min(offset, blob.size);
+
+					up.trigger('ChunkUploaded', file, {
+						offset : file.loaded,
+						total : blob.size,
+						response : xhr.responseText,
+						status : xhr.status,
+						responseHeaders: xhr.getAllResponseHeaders()
+					});
+
+					// stock Android browser doesn't fire upload progress events, but in chunking mode we can fake them
+					if (o.Env.browser === 'Android Browser') {
+						// doesn't harm in general, but is not required anywhere else
+						up.trigger('UploadProgress', file);
+					} 
+				} else {
+					file.loaded = file.size;
+				}
+
+				chunkBlob = formData = null; // Free memory
+
+				// Check if file is uploaded
+				if (!offset || offset >= blob.size) {
+					// If file was modified, destory the copy
+					if (file.size != file.origSize) {
+						blob.destroy();
+						blob = null;
+					}
+
+					up.trigger('UploadProgress', file);
+
+					file.status = plupload.DONE;
+
+					up.trigger('FileUploaded', file, {
+						response : xhr.responseText,
+						status : xhr.status,
+						responseHeaders: xhr.getAllResponseHeaders()
+					});
+				} else {
+					// Still chunks left
+					delay(uploadNextChunk, 1); // run detached, otherwise event handlers interfere
+				}
+			};
+
+			xhr.onerror = function() {
+				handleError();
+			};
+
+			xhr.onloadend = function() {
+				this.destroy();
+				xhr = null;
+			};
+
+			// Build multipart request
+			if (up.settings.multipart && features.multipart) {
+
+				args.name = file.target_name || file.name;
+
+				xhr.open("post", url, true);
+
+				// Set custom headers
+				plupload.each(up.settings.headers, function(value, name) {
+					xhr.setRequestHeader(name, value);
+				});
+
+				formData = new o.FormData();
+
+				// Add multipart params
+				plupload.each(plupload.extend(args, up.settings.multipart_params), function(value, name) {
+					formData.append(name, value);
+				});
+
+				// Add file and send it
+				formData.append(up.settings.file_data_name, chunkBlob);
+				xhr.send(formData, {
+					runtime_order: up.settings.runtimes,
+					required_caps: up.settings.required_features,
+					preferred_caps: preferred_caps,
+					swf_url: up.settings.flash_swf_url,
+					xap_url: up.settings.silverlight_xap_url
+				});
+			} else {
+				// if no multipart, send as binary stream
+				url = plupload.buildUrl(up.settings.url, plupload.extend(args, up.settings.multipart_params));
+
+				xhr.open("post", url, true);
+
+				xhr.setRequestHeader('Content-Type', 'application/octet-stream'); // Binary stream header
+
+				// Set custom headers
+				plupload.each(up.settings.headers, function(value, name) {
+					xhr.setRequestHeader(name, value);
+				});
+
+				xhr.send(chunkBlob, {
+					runtime_order: up.settings.runtimes,
+					required_caps: up.settings.required_features,
+					preferred_caps: preferred_caps,
+					swf_url: up.settings.flash_swf_url,
+					xap_url: up.settings.silverlight_xap_url
+				});
+			}
+		}
+
+		blob = file.getSource();
+
+		// Start uploading chunks
+		if (up.settings.resize.enabled && runtimeCan(blob, 'send_binary_string') && !!~o.inArray(blob.type, ['image/jpeg', 'image/png'])) {
+			// Resize if required
+			resizeImage.call(this, blob, up.settings.resize, function(resizedBlob) {
+				blob = resizedBlob;
+				file.size = resizedBlob.size;
+				uploadNextChunk();
+			});
+		} else {
+			uploadNextChunk();
+		}
+	}
+
+
+	function onUploadProgress(up, file) {
+		calcFile(file);
+	}
+
+
+	function onStateChanged(up) {
+		if (up.state == plupload.STARTED) {
+			// Get start time to calculate bps
+			startTime = (+new Date());
+		} else if (up.state == plupload.STOPPED) {
+			// Reset currently uploading files
+			for (var i = up.files.length - 1; i >= 0; i--) {
+				if (up.files[i].status == plupload.UPLOADING) {
+					up.files[i].status = plupload.QUEUED;
+					calc();
+				}
+			}
+		}
+	}
+
+
+	function onCancelUpload() {
+		if (xhr) {
+			xhr.abort();
+		}
+	}
+
+
+	function onFileUploaded(up) {
+		calc();
+
+		// Upload next file but detach it from the error event
+		// since other custom listeners might want to stop the queue
+		delay(function() {
+			uploadNext.call(up);
+		}, 1);
+	}
+
+
+	function onError(up, err) {
+		// Set failed status if an error occured on a file
+		if (err.file) {
+			err.file.status = plupload.FAILED;
+			calcFile(err.file);
+
+			// Upload next file but detach it from the error event
+			// since other custom listeners might want to stop the queue
+			if (up.state == plupload.STARTED) { // upload in progress
+				up.trigger('CancelUpload');
+				delay(function() {
+					uploadNext.call(up);
+				}, 1);
+			}
+		}
 	}
-	settings.filters = plupload.extend({
-		mime_types: [],
-		prevent_duplicates: !!settings.prevent_duplicates,
-		max_file_size: settings.max_file_size
-	}, settings.filters);
 
 
-	// Convert settings
-	settings.filters.max_file_size = plupload.parseSize(settings.filters.max_file_size) || 0;
-	settings.chunk_size = plupload.parseSize(settings.chunk_size) || 0;
+	function onDestroy(up) {
+		up.stop();
+
+		// Purge the queue
+		plupload.each(files, function(file) {
+			file.destroy();
+		});
+		files = [];
+
+		if (fileInputs.length) {
+			plupload.each(fileInputs, function(fileInput) {
+				fileInput.destroy();
+			});
+			fileInputs = [];
+		}
+
+		if (fileDrops.length) {
+			plupload.each(fileDrops, function(fileDrop) {
+				fileDrop.destroy();
+			});
+			fileDrops = [];
+		}
 
-	// Normalize the list of required capabilities
-	settings.required_features = required_caps = normalizeCaps(plupload.extend({}, settings));
+		preferred_caps = {};
+		disabled = false;
+		startTime = xhr = null;
+		total.reset();
+	}
 
 
+	// Default settings
+	settings = {
+		runtimes: o.Runtime.order,
+		max_retries: 0,
+		chunk_size: 0,
+		multipart: true,
+		multi_selection: true,
+		file_data_name: 'file',
+		flash_swf_url: 'js/Moxie.swf',
+		silverlight_xap_url: 'js/Moxie.xap',
+		filters: {
+			mime_types: [],
+			prevent_duplicates: false,
+			max_file_size: 0
+		},
+		resize: {
+			enabled: false,
+			preserve_headers: true,
+			crop: false
+		},
+		send_chunk_number: true // whether to send chunks and chunk numbers, or total and offset bytes
+	};
+
+	
+	setOption.call(this, options, null, true);
+
+	// Inital total state
+	total = new plupload.QueueProgress(); 
+
 	// Add public methods
 	plupload.extend(this, {
 
@@ -1144,7 +1630,8 @@ plupload.Uploader = function(settings) {
 		 * @property id
 		 * @type String
 		 */
-		id : plupload.guid(),
+		id : uid,
+		uid : uid, // mOxie uses this to differentiate between event targets
 
 		/**
 		 * Current state of the total uploading progress. This one can either be plupload.STARTED or plupload.STOPPED.
@@ -1171,7 +1658,7 @@ plupload.Uploader = function(settings) {
 		 * @property runtime
 		 * @type String
 		 */
-		runtime : o.Runtime.thatCan(required_caps, settings.runtimes), // predict runtime
+		runtime : null,
 
 		/**
 		 * Current upload queue, an array of File instances.
@@ -1207,12 +1694,6 @@ plupload.Uploader = function(settings) {
 		init : function() {
 			var self = this;
 
-			settings.browse_button = o.get(settings.browse_button);
-			
-			// Check if drop zone requested
-			settings.drop_element = o.get(settings.drop_element);
-
-
 			if (typeof(settings.preinit) == "function") {
 				settings.preinit(self);
 			} else {
@@ -1221,7 +1702,6 @@ plupload.Uploader = function(settings) {
 				});
 			}
 
-
 			// Check for required options
 			if (!settings.browse_button || !settings.url) {
 				this.trigger('Error', {
@@ -1231,284 +1711,55 @@ plupload.Uploader = function(settings) {
 				return;
 			}
 
+			bindEventListeners.call(this);
 
-			self.bind("FilesAdded", function(up, filteredFiles) {
-				// Add files to queue				
-				[].push.apply(files, filteredFiles);
-
-				delay(function() {
-					self.trigger("QueueChanged");
-					self.refresh();
-				}, 1);		
-			});
-
-			self.bind("CancelUpload", function() {
-				if (xhr) {
-					xhr.abort();
-				}
-			});
-
-			// Generate unique target filenames
-			if (settings.unique_names) {
-				self.bind("BeforeUpload", function(up, file) {
-					var matches = file.name.match(/\.([^.]+)$/), ext = "part";
-					if (matches) {
-						ext = matches[1];
-					}
-					file.target_name = file.id + '.' + ext;
-				});
-			}
-
-			self.bind("UploadFile", function(up, file) {
-				var url = up.settings.url, features = up.features, chunkSize = settings.chunk_size,
-					retries = settings.max_retries,
-					blob, offset = 0;
-
-				// make sure we start at a predictable offset
-				if (file.loaded) {
-					offset = file.loaded = chunkSize * Math.floor(file.loaded / chunkSize);
-				}
-
-				function handleError() {
-					if (retries-- > 0) {
-						delay(uploadNextChunk, 1);
-					} else {
-						file.loaded = offset; // reset all progress
-
-						up.trigger('Error', {
-							code : plupload.HTTP_ERROR,
-							message : plupload.translate('HTTP Error.'),
-							file : file,
-							response : xhr.responseText,
-							status : xhr.status,
-							responseHeaders: xhr.getAllResponseHeaders()
-						});
-					}
-				}
-
-				function uploadNextChunk() {
-					var chunkBlob, formData, args, curChunkSize;
-
-					// File upload finished
-					if (file.status == plupload.DONE || file.status == plupload.FAILED || up.state == plupload.STOPPED) {
-						return;
-					}
-
-					// Standard arguments
-					args = {name : file.target_name || file.name};
-
-					if (chunkSize && features.chunks && blob.size > chunkSize) { // blob will be of type string if it was loaded in memory 
-						curChunkSize = Math.min(chunkSize, blob.size - offset);
-						chunkBlob = blob.slice(offset, offset + curChunkSize);
-					} else {
-						curChunkSize = blob.size;
-						chunkBlob = blob;
-					}
-
-					// If chunking is enabled add corresponding args, no matter if file is bigger than chunk or smaller
-					if (chunkSize && features.chunks) {
-						// Setup query string arguments
-						if (settings.send_chunk_number) {
-							args.chunk = Math.ceil(offset / chunkSize);
-							args.chunks = Math.ceil(blob.size / chunkSize);
-						} else { // keep support for experimental chunk format, just in case
-							args.offset = offset;
-							args.total = blob.size;
-						}
-					}
-
-					xhr = new o.XMLHttpRequest();
-
-					// Do we have upload progress support
-					if (xhr.upload) {
-						xhr.upload.onprogress = function(e) {
-							file.loaded = Math.min(file.size, offset + e.loaded);
-							up.trigger('UploadProgress', file);
-						};
-					}
-
-					xhr.onload = function() {
-						// check if upload made itself through
-						if (xhr.status >= 400) {
-							handleError();
-							return;
-						}
-
-						// Handle chunk response
-						if (curChunkSize < blob.size) {
-							chunkBlob.destroy();
-
-							offset += curChunkSize;
-							file.loaded = Math.min(offset, blob.size);
-
-							up.trigger('ChunkUploaded', file, {
-								offset : file.loaded,
-								total : blob.size,
-								response : xhr.responseText,
-								status : xhr.status,
-								responseHeaders: xhr.getAllResponseHeaders()
-							});
-
-							// stock Android browser doesn't fire upload progress events, but in chunking mode we can fake them
-							if (o.Env.browser === 'Android Browser') {
-								// doesn't harm in general, but is not required anywhere else
-								up.trigger('UploadProgress', file);
-							} 
-						} else {
-							file.loaded = file.size;
-						}
-
-						chunkBlob = formData = null; // Free memory
-
-						// Check if file is uploaded
-						if (!offset || offset >= blob.size) {
-							// If file was modified, destory the copy
-							if (file.size != file.origSize) {
-								blob.destroy();
-								blob = null;
-							}
-
-							up.trigger('UploadProgress', file);
-
-							file.status = plupload.DONE;
-
-							up.trigger('FileUploaded', file, {
-								response : xhr.responseText,
-								status : xhr.status,
-								responseHeaders: xhr.getAllResponseHeaders()
-							});
-						} else {
-							// Still chunks left
-							delay(uploadNextChunk, 1); // run detached, otherwise event handlers interfere
-						}
-					};
-
-					xhr.onerror = function() {
-						handleError();
-					};
-
-					xhr.onloadend = function() {
-						this.destroy();
-						xhr = null;
-					};
-
-					// Build multipart request
-					if (up.settings.multipart && features.multipart) {
-
-						args.name = file.target_name || file.name;
-
-						xhr.open("post", url, true);
-
-						// Set custom headers
-						plupload.each(up.settings.headers, function(value, name) {
-							xhr.setRequestHeader(name, value);
-						});
-
-						formData = new o.FormData();
-
-						// Add multipart params
-						plupload.each(plupload.extend(args, up.settings.multipart_params), function(value, name) {
-							formData.append(name, value);
-						});
-
-						// Add file and send it
-						formData.append(up.settings.file_data_name, chunkBlob);
-						xhr.send(formData, {
-							runtime_order: up.settings.runtimes,
-							required_caps: required_caps,
-							swf_url: up.settings.flash_swf_url,
-							xap_url: up.settings.silverlight_xap_url
-						});
-					} else {
-						// if no multipart, send as binary stream
-						url = plupload.buildUrl(up.settings.url, plupload.extend(args, up.settings.multipart_params));
-
-						xhr.open("post", url, true);
-
-						xhr.setRequestHeader('Content-Type', 'application/octet-stream'); // Binary stream header
-
-						// Set custom headers
-						plupload.each(up.settings.headers, function(value, name) {
-							xhr.setRequestHeader(name, value);
-						});
-
-						xhr.send(chunkBlob, {
-							runtime_order: up.settings.runtimes,
-							required_caps: required_caps,
-							swf_url: up.settings.flash_swf_url,
-							xap_url: up.settings.silverlight_xap_url
-						});
-					}
-				}
-
-				blob = file.getSource();
-
-				// Start uploading chunks
-				if (!o.isEmptyObj(up.settings.resize) && runtimeCan(blob, 'send_binary_string') && !!~o.inArray(blob.type, ['image/jpeg', 'image/png'])) {
-					// Resize if required
-					resizeImage.call(this, blob, up.settings.resize, function(resizedBlob) {
-						blob = resizedBlob;
-						file.size = resizedBlob.size;
-						uploadNextChunk();
-					});
+			initControls.call(this, settings, function(inited) {
+				if (typeof(settings.init) == "function") {
+					settings.init(self);
 				} else {
-					uploadNextChunk();
-				}
-			});
-
-			self.bind('UploadProgress', function(up, file) {
-				calcFile(file);
-			});
-
-			self.bind('StateChanged', function(up) {
-				if (up.state == plupload.STARTED) {
-					// Get start time to calculate bps
-					startTime = (+new Date());
-				} else if (up.state == plupload.STOPPED) {
-					// Reset currently uploading files
-					for (var i = up.files.length - 1; i >= 0; i--) {
-						if (up.files[i].status == plupload.UPLOADING) {
-							up.files[i].status = plupload.QUEUED;
-							calc();
-						}
-					}
+					plupload.each(settings.init, function(func, name) {
+						self.bind(name, func);
+					});
 				}
-			});
-
-			self.bind('QueueChanged', calc);
 
-			self.bind("Error", function(up, err) {
-				// Set failed status if an error occured on a file
-				if (err.file) {
-					err.file.status = plupload.FAILED;
-
-					calcFile(err.file);
-
-					// Upload next file but detach it from the error event
-					// since other custom listeners might want to stop the queue
-					if (up.state == plupload.STARTED) {
-						delay(function() {
-							uploadNext.call(self);
-						}, 1);
-					}
+				if (inited) {
+					self.runtime = o.Runtime.getInfo(getRUID()).type;
+					self.trigger('Init', { runtime: self.runtime });
+					self.trigger('PostInit');
+				} else {
+					self.trigger('Error', {
+						code : plupload.INIT_ERROR,
+						message : plupload.translate('Init error.')
+					});
 				}
 			});
+		},
 
-			self.bind("FileUploaded", function() {
-				calc();
-
-				// Upload next file but detach it from the error event
-				// since other custom listeners might want to stop the queue
-				delay(function() {
-					uploadNext.call(self);
-				}, 1);
-			});
-
-			// some dependent scripts hook onto Init to alter configuration options, raw UI, etc (like Queue Widget),
-			// therefore we got to fire this one, before we dive into the actual initializaion
-			self.trigger('Init', { runtime: this.runtime });
+		/**
+		 * Set the value for the specified option(s).
+		 *
+		 * @method setOption
+		 * @since 2.1
+		 * @param {String|Object} option Name of the option to change or the set of key/value pairs
+		 * @param {Mixed} [value] Value for the option (is ignored, if first argument is object)
+		 */
+		setOption: function(option, value) {
+			setOption.call(this, option, value, !this.runtime); // until runtime not set we do not need to reinitialize
+		},
 
-			initControls.call(this);
+		/**
+		 * Get the value for the specified option or the whole configuration, if not specified.
+		 * 
+		 * @method getOption
+		 * @since 2.1
+		 * @param {String} [option] Name of the option to get
+		 * @return {Mixed} Value for the option or the whole set
+		 */
+		getOption: function(option) {
+			if (!option) {
+				return settings;
+			}
+			return settings[option];
 		},
 
 		/**
@@ -1518,10 +1769,12 @@ plupload.Uploader = function(settings) {
 		 * @method refresh
 		 */
 		refresh : function() {
-			if (fileInput) {
-				fileInput.trigger("Refresh");
+			if (fileInputs.length) {
+				plupload.each(fileInputs, function(fileInput) {
+					fileInput.trigger('Refresh');
+				});
 			}
-			this.trigger("Refresh");
+			this.trigger('Refresh');
 		},
 
 		/**
@@ -1532,7 +1785,7 @@ plupload.Uploader = function(settings) {
 		start : function() {
 			if (this.state != plupload.STARTED) {
 				this.state = plupload.STARTED;
-				this.trigger("StateChanged");
+				this.trigger('StateChanged');
 
 				uploadNext.call(this);
 			}
@@ -1546,8 +1799,8 @@ plupload.Uploader = function(settings) {
 		stop : function() {
 			if (this.state != plupload.STOPPED) {
 				this.state = plupload.STOPPED;
-				this.trigger("StateChanged");
-				this.trigger("CancelUpload");
+				this.trigger('StateChanged');
+				this.trigger('CancelUpload');
 			}
 		},
 
@@ -1561,11 +1814,13 @@ plupload.Uploader = function(settings) {
 		disableBrowse : function() {
 			disabled = arguments[0] !== undef ? arguments[0] : true;
 
-			if (fileInput) {
-				fileInput.disable(disabled);
+			if (fileInputs.length) {
+				plupload.each(fileInputs, function(fileInput) {
+					fileInput.disable(disabled);
+				});
 			}
 
-			this.trigger("DisableBrowse", disabled);
+			this.trigger('DisableBrowse', disabled);
 		},
 
 		/**
@@ -1590,6 +1845,7 @@ plupload.Uploader = function(settings) {
 		 * if any files were added to the queue. Otherwise nothing happens.
 		 *
 		 * @method addFile
+		 * @since 2.0
 		 * @param {plupload.File|mOxie.File|File|Node|Array} file File or files to add to the queue.
 		 * @param {String} [fileName] If specified, will be used as a name for the file
 		 */
@@ -1600,14 +1856,6 @@ plupload.Uploader = function(settings) {
 			, ruid
 			;
 
-			function getRUID() {
-				var ctrl = fileDrop || fileInput;
-				if (ctrl) {
-					return ctrl.getRuntime().uid;
-				}
-				return false;
-			}
-
 			function filterFile(file, cb) {
 				var queue = [];
 				o.each(self.settings.filters, function(rule, name) {
@@ -1657,8 +1905,9 @@ plupload.Uploader = function(settings) {
 						filterFile(file, function(err) {
 							if (!err) {
 								files.push(file);
+								self.trigger("FileFiltered", file);
 							}
-							cb();
+							delay(cb, 1); // do not build up recursions or eventually we might hit the limits
 						});
 					});
 				} 
@@ -1720,14 +1969,27 @@ plupload.Uploader = function(settings) {
 			// Splice and trigger events
 			var removed = files.splice(start === undef ? 0 : start, length === undef ? files.length : length);
 
+			// if upload is in progress we need to stop it and restart after files are removed
+			var restartRequired = false;
+			if (this.state == plupload.STARTED) { // upload in progress
+				restartRequired = true;
+				this.stop();
+			}
+
 			this.trigger("FilesRemoved", removed);
-			this.trigger("QueueChanged");
 
 			// Dispose any resources allocated by those files
 			plupload.each(removed, function(file) {
 				file.destroy();
 			});
 
+			this.trigger("QueueChanged");
+			this.refresh();
+
+			if (restartRequired) {
+				this.start();
+			}
+
 			return removed;
 		},
 
@@ -1739,27 +2001,6 @@ plupload.Uploader = function(settings) {
 		 * @param {String} name Event name to fire.
 		 * @param {Object..} Multiple arguments to pass along to the listener functions.
 		 */
-		trigger : function(name) {
-			var list = events[name.toLowerCase()], i, args;
-
-			// console.log(name, arguments);
-
-			if (list) {
-				// Replace name with sender in args
-				args = Array.prototype.slice.call(arguments);
-				args[0] = this;
-
-				// Dispatch event to all listeners
-				for (i = 0; i < list.length; i++) {
-					// Fire event, break chain if false is returned
-					if (list[i].func.apply(list[i].scope, args) === false) {
-						return false;
-					}
-				}
-			}
-
-			return true;
-		},
 
 		/**
 		 * Check whether uploader has any listeners to the specified event.
@@ -1767,9 +2008,7 @@ plupload.Uploader = function(settings) {
 		 * @method hasEventListener
 		 * @param {String} name Event name to check for.
 		 */
-		hasEventListener : function(name) {
-			return !!events[name.toLowerCase()];
-		},
+
 
 		/**
 		 * Adds an event listener by name.
@@ -1780,12 +2019,13 @@ plupload.Uploader = function(settings) {
 		 * @param {Object} scope Optional scope to execute the specified function in.
 		 */
 		bind : function(name, func, scope) {
-			var list;
-
-			name = name.toLowerCase();
-			list = events[name] || [];
-			list.push({func : func, scope : scope || this});
-			events[name] = list;
+			var self = this;
+			// adapt moxie EventTarget style to Plupload-like
+			plupload.Uploader.prototype.bind.call(this, name, function() {
+				var args = [].slice.call(arguments);
+				args.splice(0, 1, self); // replace event object with uploader instance
+				return func.apply(this, args);
+			}, 0, scope);
 		},
 
 		/**
@@ -1795,42 +2035,13 @@ plupload.Uploader = function(settings) {
 		 * @param {String} name Name of event to remove.
 		 * @param {function} func Function to remove from listener.
 		 */
-		unbind : function(name) {
-			name = name.toLowerCase();
-
-			var list = events[name], i, func = arguments[1];
-
-			if (list) {
-				if (func !== undef) {
-					for (i = list.length - 1; i >= 0; i--) {
-						if (list[i].func === func) {
-							list.splice(i, 1);
-								break;
-						}
-					}
-				} else {
-					list = [];
-				}
-
-				// delete event list if it has become empty
-				if (!list.length) {
-					delete events[name];
-				}
-			}
-		},
 
 		/**
 		 * Removes all event listeners.
 		 *
 		 * @method unbindAll
 		 */
-		unbindAll : function() {
-			var self = this;
 
-			plupload.each(events, function(list, name) {
-				self.unbind(name);
-			});
-		},
 
 		/**
 		 * Destroys Plupload instance and cleans after itself.
@@ -1838,36 +2049,15 @@ plupload.Uploader = function(settings) {
 		 * @method destroy
 		 */
 		destroy : function() {
-			this.stop();
-
-			// Purge the queue
-			plupload.each(files, function(file) {
-				file.destroy();
-			});
-			files = [];
-
-			if (fileInput) {
-				fileInput.destroy();
-				fileInput = null;
-			}
-
-			if (fileDrop) {
-				fileDrop.destroy();
-				fileDrop = null;
-			}
-
-			required_caps = {};
-			startTime = total = disabled = xhr = null;
-
 			this.trigger('Destroy');
-
-			// Clean-up after uploader itself
+			settings = total = null; // purge these exclusively
 			this.unbindAll();
-			events = {};
 		}
 	});
 };
 
+plupload.Uploader.prototype = o.EventTarget.instance;
+
 /**
  * Constructs a new file instance.
  *