crystal-ext 0.0.1

data/lib/common_interface/public/common_interface/lib/jquery.swfupload/swfupload/swfupload.queue.js

@@ -0,0 +1,98 @@
+/*
+	Queue Plug-in
+	
+	Features:
+		*Adds a cancelQueue() method for cancelling the entire queue.
+		*All queued files are uploaded when startUpload() is called.
+		*If false is returned from uploadComplete then the queue upload is stopped.
+		 If false is not returned (strict comparison) then the queue upload is continued.
+		*Adds a QueueComplete event that is fired when all the queued files have finished uploading.
+		 Set the event handler with the queue_complete_handler setting.
+		
+	*/
+
+var SWFUpload;
+if (typeof(SWFUpload) === "function") {
+	SWFUpload.queue = {};
+	
+	SWFUpload.prototype.initSettings = (function (oldInitSettings) {
+		return function () {
+			if (typeof(oldInitSettings) === "function") {
+				oldInitSettings.call(this);
+			}
+			
+			this.queueSettings = {};
+			
+			this.queueSettings.queue_cancelled_flag = false;
+			this.queueSettings.queue_upload_count = 0;
+			
+			this.queueSettings.user_upload_complete_handler = this.settings.upload_complete_handler;
+			this.queueSettings.user_upload_start_handler = this.settings.upload_start_handler;
+			this.settings.upload_complete_handler = SWFUpload.queue.uploadCompleteHandler;
+			this.settings.upload_start_handler = SWFUpload.queue.uploadStartHandler;
+			
+			this.settings.queue_complete_handler = this.settings.queue_complete_handler || null;
+		};
+	})(SWFUpload.prototype.initSettings);
+
+	SWFUpload.prototype.startUpload = function (fileID) {
+		this.queueSettings.queue_cancelled_flag = false;
+		this.callFlash("StartUpload", [fileID]);
+	};
+
+	SWFUpload.prototype.cancelQueue = function () {
+		this.queueSettings.queue_cancelled_flag = true;
+		this.stopUpload();
+		
+		var stats = this.getStats();
+		while (stats.files_queued > 0) {
+			this.cancelUpload();
+			stats = this.getStats();
+		}
+	};
+	
+	SWFUpload.queue.uploadStartHandler = function (file) {
+		var returnValue;
+		if (typeof(this.queueSettings.user_upload_start_handler) === "function") {
+			returnValue = this.queueSettings.user_upload_start_handler.call(this, file);
+		}
+		
+		// To prevent upload a real "FALSE" value must be returned, otherwise default to a real "TRUE" value.
+		returnValue = (returnValue === false) ? false : true;
+		
+		this.queueSettings.queue_cancelled_flag = !returnValue;
+
+		return returnValue;
+	};
+	
+	SWFUpload.queue.uploadCompleteHandler = function (file) {
+		var user_upload_complete_handler = this.queueSettings.user_upload_complete_handler;
+		var continueUpload;
+		
+		if (file.filestatus === SWFUpload.FILE_STATUS.COMPLETE) {
+			this.queueSettings.queue_upload_count++;
+		}
+
+		if (typeof(user_upload_complete_handler) === "function") {
+			continueUpload = (user_upload_complete_handler.call(this, file) === false) ? false : true;
+		} else if (file.filestatus === SWFUpload.FILE_STATUS.QUEUED) {
+			// If the file was stopped and re-queued don't restart the upload
+			continueUpload = false;
+		} else {
+			continueUpload = true;
+		}
+		
+		if (continueUpload) {
+			var stats = this.getStats();
+			if (stats.files_queued > 0 && this.queueSettings.queue_cancelled_flag === false) {
+				this.startUpload();
+			} else if (this.queueSettings.queue_cancelled_flag === false) {
+				this.queueEvent("queue_complete_handler", [this.queueSettings.queue_upload_count]);
+				this.queueSettings.queue_upload_count = 0;
+			} else {
+				this.queueSettings.queue_cancelled_flag = false;
+				this.queueSettings.queue_upload_count = 0;
+			}
+		}
+	};
+}

data/lib/common_interface/public/common_interface/lib/jquery.template.js

@@ -0,0 +1,255 @@
+/**
+ * jQuery Templates
+ *
+ * Dual licensed under the MIT (http://www.opensource.org/licenses/mit-license.php)
+ * and GPL (http://www.opensource.org/licenses/gpl-license.php) licenses.
+ *
+ * Written by: Stan Lemon <stanlemon@mac.com>
+ *
+ * Based off of the Ext.Template library, available at:
+ * http://www.extjs.com
+ *
+ * This library provides basic templating functionality, allowing for macro-based
+ * templates within jQuery.
+ *
+ * Basic Usage:
+ *
+ * var t = $.template('<div id="foo">Hello ${name}, how are you ${question}?  I am ${me:substr(0,10)}</div>');
+ *
+ * $(selector).append( t , {
+ *     name: 'Stan',
+ *     question: 'feeling',
+ *     me: 'doing quite well myself, thank you very much!'
+ * });
+ *
+ * Requires: jQuery 1.2+
+ *
+ *
+ * @todo    Add callbacks to the DOM manipulation methods, so that events can be bound
+ *          to template nodes after creation.
+ */
+(function($){
+	
+	/**
+	 * Create a New Template
+	 */
+	$.template = function(html, options) {
+		return new $.template.instance(html, options);
+	};
+
+	/**
+	 * Template constructor - Creates a new template instance.
+	 *
+	 * @param 	html 	The string of HTML to be used for the template.
+	 * @param 	options An object of configurable options.  Currently
+	 * 			you can toggle compile as a boolean value and set a custom
+	 *          template regular expression on the property regx by
+	 *          specifying the key of the regx to use from the regx object.
+	 */
+	$.template.instance = function(html, options) {
+        // If a custom regular expression has been set, grab it from the regx object
+        if ( options && options['regx'] ) options.regx = this.regx[ options.regx ];
+
+		this.options = $.extend({
+			compile: 		false,
+			regx:           this.regx.standard
+		}, options || {});
+
+		this.html = html;
+
+		if (this.options.compile) {
+			this.compile();   
+		}
+		this.isTemplate = true;
+	};
+
+	/**
+	 * Regular Expression for Finding Variables
+	 *
+	 * The default pattern looks for variables in JSP style, the form of: ${variable}
+	 * There are also regular expressions available for ext-style variables and
+	 * jTemplate style variables.
+	 *
+	 * You can add your own regular expressions for variable ussage by doing.
+	 * $.extend({ $.template.re , {
+	 *     myvartype: /...../g
+	 * }
+	 *
+	 * Then when creating a template do:
+	 * var t = $.template("<div>...</div>", { regx: 'myvartype' });
+	 */
+	$.template.regx = $.template.instance.prototype.regx = {
+	    jsp:        /\$\{([\w-]+)(?:\:([\w\.]*)(?:\((.*?)?\))?)?\}/g,
+        ext:        /\{([\w-]+)(?:\:([\w\.]*)(?:\((.*?)?\))?)?\}/g,
+        jtemplates: /\{\{([\w-]+)(?:\:([\w\.]*)(?:\((.*?)?\))?)?\}\}/g
+	};
+	
+	/**
+	 * Set the standard regular expression to be used.
+	 */
+	$.template.regx.standard = $.template.regx.jsp;
+	
+	/**
+	 * Variable Helper Methods
+	 *
+	 * This is a collection of methods which can be used within the variable syntax, ie:
+	 * ${variable:substr(0,30)} Which would only print a substring, 30 characters in length
+	 * begining at the first character for the variable named "variable".
+	 *
+	 * A basic substring helper is provided as an example of how you can define helpers.
+	 * To add more helpers simply do:
+	 * $.extend( $.template.helpers , {
+	 *	 sampleHelper: function() { ... }	
+	 * });
+	 */
+	$.template.helpers = $.template.instance.prototype.helpers = {
+		substr : function(value, start, length){
+			return String(value).substr(start, length);
+		}
+	};
+
+
+	/**
+	 * Template Instance Methods
+	 */
+	$.extend( $.template.instance.prototype, {
+		
+		/**
+		 * Apply Values to a Template
+		 *
+		 * This is the macro-work horse of the library, it receives an object
+		 * and the properties of that objects are assigned to the template, where
+		 * the variables in the template represent keys within the object itself.
+		 *
+		 * @param 	values 	An object of properties mapped to template variables
+		 */
+		apply: function(values) {
+			if (this.options.compile) {
+				return this.compiled(values);
+			} else {
+				var tpl = this;
+				var fm = this.helpers;
+
+				var fn = function(m, name, format, args) {
+					if (format) {
+						if (format.substr(0, 5) == "this."){
+							return tpl.call(format.substr(5), values[name], values);
+						} else {
+							if (args) {
+								// quoted values are required for strings in compiled templates, 
+								// but for non compiled we need to strip them
+								// quoted reversed for jsmin
+								var re = /^\s*['"](.*)["']\s*$/;
+								args = args.split(',');
+
+								for(var i = 0, len = args.length; i < len; i++) {
+									args[i] = args[i].replace(re, "$1");
+								}
+								args = [values[name]].concat(args);
+							} else {
+								args = [values[name]];
+							}
+
+							return fm[format].apply(fm, args);
+						}
+					} else {
+						return values[name] !== undefined ? values[name] : "";
+					}
+				};
+
+				return this.html.replace(this.options.regx, fn);
+			}
+		},
+
+		/**
+		 * Compile a template for speedier usage
+		 */
+		compile: function() {
+			var sep = $.browser.mozilla ? "+" : ",";
+			var fm = this.helpers;
+
+			var fn = function(m, name, format, args){
+				if (format) {
+					args = args ? ',' + args : "";
+
+					if (format.substr(0, 5) != "this.") {
+						format = "fm." + format + '(';
+					} else {
+						format = 'this.call("'+ format.substr(5) + '", ';
+						args = ", values";
+					}
+				} else {
+					args= ''; format = "(values['" + name + "'] == undefined ? '' : ";
+				}
+				return "'"+ sep + format + "values['" + name + "']" + args + ")"+sep+"'";
+			};
+
+			var body;
+
+			if ($.browser.mozilla) {
+				body = "this.compiled = function(values){ return '" +
+					   this.html.replace(/\\/g, '\\\\').replace(/(\r\n|\n)/g, '\\n').replace(/'/g, "\\'").replace(this.options.regx, fn) +
+						"';};";
+			} else {
+				body = ["this.compiled = function(values){ return ['"];
+				body.push(this.html.replace(/\\/g, '\\\\').replace(/(\r\n|\n)/g, '\\n').replace(/'/g, "\\'").replace(this.options.regx, fn));
+				body.push("'].join('');};");
+				body = body.join('');
+			}
+			eval(body);
+			return this;
+		}
+	});
+
+
+	/**
+	 * Save a reference in this local scope to the original methods which we're 
+	 * going to overload.
+	 **/
+	var $_old = {
+	    domManip: $.fn.domManip,
+	    text: $.fn.text,
+	    html: $.fn.html
+	};
+
+	/**
+	 * Overwrite the domManip method so that we can use things like append() by passing a 
+	 * template object and macro parameters.
+	 */
+	$.fn.domManip = function( args, table, reverse, callback ) {
+		if (args[0] && args[0].isTemplate) {
+			// Apply the template and it's arguments...
+			args[0] = args[0].apply( args[1] );
+			// Get rid of the arguements, we don't want to pass them on
+			delete args[1];
+		}
+
+		// Call the original method
+		var r = $_old.domManip.apply(this, arguments);
+
+		return r;
+	};
+
+    /**
+     * Overwrite the html() method
+     */
+	$.fn.html = function( value , o ) {
+	    if (value && value.isTemplate) var value = value.apply( o );
+
+		var r = $_old.html.apply(this, [value]);
+
+		return r;
+	};
+	
+	/**
+	 * Overwrite the text() method
+	 */
+	$.fn.text = function( value , o ) {
+	    if (value && value.isTemplate) var value = value.apply( o );
+
+		var r = $_old.text.apply(this, [value]);
+
+		return r;
+	};
+
+})(jQuery);