add sauce

lib/jquery/jquery.tmpl.js

@@ -0,0 +1,484 @@
+/*!
+ * jQuery Templates Plugin 1.0.0pre
+ * http://github.com/jquery/jquery-tmpl
+ * Requires jQuery 1.4.2
+ *
+ * Copyright 2011, Software Freedom Conservancy, Inc.
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ * http://jquery.org/license
+ */
+(function( jQuery, undefined ){
+	var oldManip = jQuery.fn.domManip, tmplItmAtt = "_tmplitem", htmlExpr = /^[^<]*(<[\w\W]+>)[^>]*$|\{\{\! /,
+		newTmplItems = {}, wrappedItems = {}, appendToTmplItems, topTmplItem = { key: 0, data: {} }, itemKey = 0, cloneIndex = 0, stack = [];
+
+	function newTmplItem( options, parentItem, fn, data ) {
+		// Returns a template item data structure for a new rendered instance of a template (a 'template item').
+		// The content field is a hierarchical array of strings and nested items (to be
+		// removed and replaced by nodes field of dom elements, once inserted in DOM).
+		var newItem = {
+			data: data || (data === 0 || data === false) ? data : (parentItem ? parentItem.data : {}),
+			_wrap: parentItem ? parentItem._wrap : null,
+			tmpl: null,
+			parent: parentItem || null,
+			nodes: [],
+			calls: tiCalls,
+			nest: tiNest,
+			wrap: tiWrap,
+			html: tiHtml,
+			update: tiUpdate
+		};
+		if ( options ) {
+			jQuery.extend( newItem, options, { nodes: [], parent: parentItem });
+		}
+		if ( fn ) {
+			// Build the hierarchical content to be used during insertion into DOM
+			newItem.tmpl = fn;
+			newItem._ctnt = newItem._ctnt || newItem.tmpl( jQuery, newItem );
+			newItem.key = ++itemKey;
+			// Keep track of new template item, until it is stored as jQuery Data on DOM element
+			(stack.length ? wrappedItems : newTmplItems)[itemKey] = newItem;
+		}
+		return newItem;
+	}
+
+	// Override appendTo etc., in order to provide support for targeting multiple elements. (This code would disappear if integrated in jquery core).
+	jQuery.each({
+		appendTo: "append",
+		prependTo: "prepend",
+		insertBefore: "before",
+		insertAfter: "after",
+		replaceAll: "replaceWith"
+	}, function( name, original ) {
+		jQuery.fn[ name ] = function( selector ) {
+			var ret = [], insert = jQuery( selector ), elems, i, l, tmplItems,
+				parent = this.length === 1 && this[0].parentNode;
+
+			appendToTmplItems = newTmplItems || {};
+			if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) {
+				insert[ original ]( this[0] );
+				ret = this;
+			} else {
+				for ( i = 0, l = insert.length; i < l; i++ ) {
+					cloneIndex = i;
+					elems = (i > 0 ? this.clone(true) : this).get();
+					jQuery( insert[i] )[ original ]( elems );
+					ret = ret.concat( elems );
+				}
+				cloneIndex = 0;
+				ret = this.pushStack( ret, name, insert.selector );
+			}
+			tmplItems = appendToTmplItems;
+			appendToTmplItems = null;
+			jQuery.tmpl.complete( tmplItems );
+			return ret;
+		};
+	});
+
+	jQuery.fn.extend({
+		// Use first wrapped element as template markup.
+		// Return wrapped set of template items, obtained by rendering template against data.
+		tmpl: function( data, options, parentItem ) {
+			return jQuery.tmpl( this[0], data, options, parentItem );
+		},
+
+		// Find which rendered template item the first wrapped DOM element belongs to
+		tmplItem: function() {
+			return jQuery.tmplItem( this[0] );
+		},
+
+		// Consider the first wrapped element as a template declaration, and get the compiled template or store it as a named template.
+		template: function( name ) {
+			return jQuery.template( name, this[0] );
+		},
+
+		domManip: function( args, table, callback, options ) {
+			if ( args[0] && jQuery.isArray( args[0] )) {
+				var dmArgs = jQuery.makeArray( arguments ), elems = args[0], elemsLength = elems.length, i = 0, tmplItem;
+				while ( i < elemsLength && !(tmplItem = jQuery.data( elems[i++], "tmplItem" ))) {}
+				if ( tmplItem && cloneIndex ) {
+					dmArgs[2] = function( fragClone ) {
+						// Handler called by oldManip when rendered template has been inserted into DOM.
+						jQuery.tmpl.afterManip( this, fragClone, callback );
+					};
+				}
+				oldManip.apply( this, dmArgs );
+			} else {
+				oldManip.apply( this, arguments );
+			}
+			cloneIndex = 0;
+			if ( !appendToTmplItems ) {
+				jQuery.tmpl.complete( newTmplItems );
+			}
+			return this;
+		}
+	});
+
+	jQuery.extend({
+		// Return wrapped set of template items, obtained by rendering template against data.
+		tmpl: function( tmpl, data, options, parentItem ) {
+			var ret, topLevel = !parentItem;
+			if ( topLevel ) {
+				// This is a top-level tmpl call (not from a nested template using {{tmpl}})
+				parentItem = topTmplItem;
+				tmpl = jQuery.template[tmpl] || jQuery.template( null, tmpl );
+				wrappedItems = {}; // Any wrapped items will be rebuilt, since this is top level
+			} else if ( !tmpl ) {
+				// The template item is already associated with DOM - this is a refresh.
+				// Re-evaluate rendered template for the parentItem
+				tmpl = parentItem.tmpl;
+				newTmplItems[parentItem.key] = parentItem;
+				parentItem.nodes = [];
+				if ( parentItem.wrapped ) {
+					updateWrapped( parentItem, parentItem.wrapped );
+				}
+				// Rebuild, without creating a new template item
+				return jQuery( build( parentItem, null, parentItem.tmpl( jQuery, parentItem ) ));
+			}
+			if ( !tmpl ) {
+				return []; // Could throw...
+			}
+			if ( typeof data === "function" ) {
+				data = data.call( parentItem || {} );
+			}
+			if ( options && options.wrapped ) {
+				updateWrapped( options, options.wrapped );
+			}
+			ret = jQuery.isArray( data ) ?
+				jQuery.map( data, function( dataItem ) {
+					return dataItem ? newTmplItem( options, parentItem, tmpl, dataItem ) : null;
+				}) :
+				[ newTmplItem( options, parentItem, tmpl, data ) ];
+			return topLevel ? jQuery( build( parentItem, null, ret ) ) : ret;
+		},
+
+		// Return rendered template item for an element.
+		tmplItem: function( elem ) {
+			var tmplItem;
+			if ( elem instanceof jQuery ) {
+				elem = elem[0];
+			}
+			while ( elem && elem.nodeType === 1 && !(tmplItem = jQuery.data( elem, "tmplItem" )) && (elem = elem.parentNode) ) {}
+			return tmplItem || topTmplItem;
+		},
+
+		// Set:
+		// Use $.template( name, tmpl ) to cache a named template,
+		// where tmpl is a template string, a script element or a jQuery instance wrapping a script element, etc.
+		// Use $( "selector" ).template( name ) to provide access by name to a script block template declaration.
+
+		// Get:
+		// Use $.template( name ) to access a cached template.
+		// Also $( selectorToScriptBlock ).template(), or $.template( null, templateString )
+		// will return the compiled template, without adding a name reference.
+		// If templateString includes at least one HTML tag, $.template( templateString ) is equivalent
+		// to $.template( null, templateString )
+		template: function( name, tmpl ) {
+			if (tmpl) {
+				// Compile template and associate with name
+				if ( typeof tmpl === "string" ) {
+					// This is an HTML string being passed directly in.
+					tmpl = buildTmplFn( tmpl );
+				} else if ( tmpl instanceof jQuery ) {
+					tmpl = tmpl[0] || {};
+				}
+				if ( tmpl.nodeType ) {
+					// If this is a template block, use cached copy, or generate tmpl function and cache.
+					tmpl = jQuery.data( tmpl, "tmpl" ) || jQuery.data( tmpl, "tmpl", buildTmplFn( tmpl.innerHTML ));
+					// Issue: In IE, if the container element is not a script block, the innerHTML will remove quotes from attribute values whenever the value does not include white space.
+					// This means that foo="${x}" will not work if the value of x includes white space: foo="${x}" -> foo=value of x.
+					// To correct this, include space in tag: foo="${ x }" -> foo="value of x"
+				}
+				return typeof name === "string" ? (jQuery.template[name] = tmpl) : tmpl;
+			}
+			// Return named compiled template
+			return name ? (typeof name !== "string" ? jQuery.template( null, name ):
+				(jQuery.template[name] ||
+					// If not in map, and not containing at least on HTML tag, treat as a selector.
+					// (If integrated with core, use quickExpr.exec)
+					jQuery.template( null, htmlExpr.test( name ) ? name : jQuery( name )))) : null;
+		},
+
+		encode: function( text ) {
+			// Do HTML encoding replacing < > & and ' and " by corresponding entities.
+			return ("" + text).split("<").join("&lt;").split(">").join("&gt;").split('"').join("&#34;").split("'").join("&#39;");
+		}
+	});
+
+	jQuery.extend( jQuery.tmpl, {
+		tag: {
+			"tmpl": {
+				_default: { $2: "null" },
+				open: "if($notnull_1){__=__.concat($item.nest($1,$2));}"
+				// tmpl target parameter can be of type function, so use $1, not $1a (so not auto detection of functions)
+				// This means that {{tmpl foo}} treats foo as a template (which IS a function).
+				// Explicit parens can be used if foo is a function that returns a template: {{tmpl foo()}}.
+			},
+			"wrap": {
+				_default: { $2: "null" },
+				open: "$item.calls(__,$1,$2);__=[];",
+				close: "call=$item.calls();__=call._.concat($item.wrap(call,__));"
+			},
+			"each": {
+				_default: { $2: "$index, $value" },
+				open: "if($notnull_1){$.each($1a,function($2){with(this){",
+				close: "}});}"
+			},
+			"if": {
+				open: "if(($notnull_1) && $1a){",
+				close: "}"
+			},
+			"else": {
+				_default: { $1: "true" },
+				open: "}else if(($notnull_1) && $1a){"
+			},
+			"html": {
+				// Unecoded expression evaluation.
+				open: "if($notnull_1){__.push($1a);}"
+			},
+			"=": {
+				// Encoded expression evaluation. Abbreviated form is ${}.
+				_default: { $1: "$data" },
+				open: "if($notnull_1){__.push($.encode($1a));}"
+			},
+			"!": {
+				// Comment tag. Skipped by parser
+				open: ""
+			}
+		},
+
+		// This stub can be overridden, e.g. in jquery.tmplPlus for providing rendered events
+		complete: function( items ) {
+			newTmplItems = {};
+		},
+
+		// Call this from code which overrides domManip, or equivalent
+		// Manage cloning/storing template items etc.
+		afterManip: function afterManip( elem, fragClone, callback ) {
+			// Provides cloned fragment ready for fixup prior to and after insertion into DOM
+			var content = fragClone.nodeType === 11 ?
+				jQuery.makeArray(fragClone.childNodes) :
+				fragClone.nodeType === 1 ? [fragClone] : [];
+
+			// Return fragment to original caller (e.g. append) for DOM insertion
+			callback.call( elem, fragClone );
+
+			// Fragment has been inserted:- Add inserted nodes to tmplItem data structure. Replace inserted element annotations by jQuery.data.
+			storeTmplItems( content );
+			cloneIndex++;
+		}
+	});
+
+	//========================== Private helper functions, used by code above ==========================
+
+	function build( tmplItem, nested, content ) {
+		// Convert hierarchical content into flat string array
+		// and finally return array of fragments ready for DOM insertion
+		var frag, ret = content ? jQuery.map( content, function( item ) {
+			return (typeof item === "string") ?
+				// Insert template item annotations, to be converted to jQuery.data( "tmplItem" ) when elems are inserted into DOM.
+				(tmplItem.key ? item.replace( /(<\w+)(?=[\s>])(?![^>]*_tmplitem)([^>]*)/g, "$1 " + tmplItmAtt + "=\"" + tmplItem.key + "\" $2" ) : item) :
+				// This is a child template item. Build nested template.
+				build( item, tmplItem, item._ctnt );
+		}) :
+		// If content is not defined, insert tmplItem directly. Not a template item. May be a string, or a string array, e.g. from {{html $item.html()}}.
+		tmplItem;
+		if ( nested ) {
+			return ret;
+		}
+
+		// top-level template
+		ret = ret.join("");
+
+		// Support templates which have initial or final text nodes, or consist only of text
+		// Also support HTML entities within the HTML markup.
+		ret.replace( /^\s*([^<\s][^<]*)?(<[\w\W]+>)([^>]*[^>\s])?\s*$/, function( all, before, middle, after) {
+			frag = jQuery( middle ).get();
+
+			storeTmplItems( frag );
+			if ( before ) {
+				frag = unencode( before ).concat(frag);
+			}
+			if ( after ) {
+				frag = frag.concat(unencode( after ));
+			}
+		});
+		return frag ? frag : unencode( ret );
+	}
+
+	function unencode( text ) {
+		// Use createElement, since createTextNode will not render HTML entities correctly
+		var el = document.createElement( "div" );
+		el.innerHTML = text;
+		return jQuery.makeArray(el.childNodes);
+	}
+
+	// Generate a reusable function that will serve to render a template against data
+	function buildTmplFn( markup ) {
+		return new Function("jQuery","$item",
+			// Use the variable __ to hold a string array while building the compiled template. (See https://github.com/jquery/jquery-tmpl/issues#issue/10).
+			"var $=jQuery,call,__=[],$data=$item.data;" +
+
+			// Introduce the data as local variables using with(){}
+			"with($data){__.push('" +
+
+			// Convert the template into pure JavaScript
+			jQuery.trim(markup)
+				.replace( /([\\'])/g, "\\$1" )
+				.replace( /[\r\t\n]/g, " " )
+				.replace( /\$\{([^\}]*)\}/g, "{{= $1}}" )
+				.replace( /\{\{(\/?)(\w+|.)(?:\(((?:[^\}]|\}(?!\}))*?)?\))?(?:\s+(.*?)?)?(\(((?:[^\}]|\}(?!\}))*?)\))?\s*\}\}/g,
+				function( all, slash, type, fnargs, target, parens, args ) {
+					var tag = jQuery.tmpl.tag[ type ], def, expr, exprAutoFnDetect;
+					if ( !tag ) {
+						throw "Unknown template tag: " + type;
+					}
+					def = tag._default || [];
+					if ( parens && !/\w$/.test(target)) {
+						target += parens;
+						parens = "";
+					}
+					if ( target ) {
+						target = unescape( target );
+						args = args ? ("," + unescape( args ) + ")") : (parens ? ")" : "");
+						// Support for target being things like a.toLowerCase();
+						// In that case don't call with template item as 'this' pointer. Just evaluate...
+						expr = parens ? (target.indexOf(".") > -1 ? target + unescape( parens ) : ("(" + target + ").call($item" + args)) : target;
+						exprAutoFnDetect = parens ? expr : "(typeof(" + target + ")==='function'?(" + target + ").call($item):(" + target + "))";
+					} else {
+						exprAutoFnDetect = expr = def.$1 || "null";
+					}
+					fnargs = unescape( fnargs );
+					return "');" +
+						tag[ slash ? "close" : "open" ]
+							.split( "$notnull_1" ).join( target ? "typeof(" + target + ")!=='undefined' && (" + target + ")!=null" : "true" )
+							.split( "$1a" ).join( exprAutoFnDetect )
+							.split( "$1" ).join( expr )
+							.split( "$2" ).join( fnargs || def.$2 || "" ) +
+						"__.push('";
+				}) +
+			"');}return __;"
+		);
+	}
+	function updateWrapped( options, wrapped ) {
+		// Build the wrapped content.
+		options._wrap = build( options, true,
+			// Suport imperative scenario in which options.wrapped can be set to a selector or an HTML string.
+			jQuery.isArray( wrapped ) ? wrapped : [htmlExpr.test( wrapped ) ? wrapped : jQuery( wrapped ).html()]
+		).join("");
+	}
+
+	function unescape( args ) {
+		return args ? args.replace( /\\'/g, "'").replace(/\\\\/g, "\\" ) : null;
+	}
+	function outerHtml( elem ) {
+		var div = document.createElement("div");
+		div.appendChild( elem.cloneNode(true) );
+		return div.innerHTML;
+	}
+
+	// Store template items in jQuery.data(), ensuring a unique tmplItem data data structure for each rendered template instance.
+	function storeTmplItems( content ) {
+		var keySuffix = "_" + cloneIndex, elem, elems, newClonedItems = {}, i, l, m;
+		for ( i = 0, l = content.length; i < l; i++ ) {
+			if ( (elem = content[i]).nodeType !== 1 ) {
+				continue;
+			}
+			elems = elem.getElementsByTagName("*");
+			for ( m = elems.length - 1; m >= 0; m-- ) {
+				processItemKey( elems[m] );
+			}
+			processItemKey( elem );
+		}
+		function processItemKey( el ) {
+			var pntKey, pntNode = el, pntItem, tmplItem, key;
+			// Ensure that each rendered template inserted into the DOM has its own template item,
+			if ( (key = el.getAttribute( tmplItmAtt ))) {
+				while ( pntNode.parentNode && (pntNode = pntNode.parentNode).nodeType === 1 && !(pntKey = pntNode.getAttribute( tmplItmAtt ))) { }
+				if ( pntKey !== key ) {
+					// The next ancestor with a _tmplitem expando is on a different key than this one.
+					// So this is a top-level element within this template item
+					// Set pntNode to the key of the parentNode, or to 0 if pntNode.parentNode is null, or pntNode is a fragment.
+					pntNode = pntNode.parentNode ? (pntNode.nodeType === 11 ? 0 : (pntNode.getAttribute( tmplItmAtt ) || 0)) : 0;
+					if ( !(tmplItem = newTmplItems[key]) ) {
+						// The item is for wrapped content, and was copied from the temporary parent wrappedItem.
+						tmplItem = wrappedItems[key];
+						tmplItem = newTmplItem( tmplItem, newTmplItems[pntNode]||wrappedItems[pntNode] );
+						tmplItem.key = ++itemKey;
+						newTmplItems[itemKey] = tmplItem;
+					}
+					if ( cloneIndex ) {
+						cloneTmplItem( key );
+					}
+				}
+				el.removeAttribute( tmplItmAtt );
+			} else if ( cloneIndex && (tmplItem = jQuery.data( el, "tmplItem" )) ) {
+				// This was a rendered element, cloned during append or appendTo etc.
+				// TmplItem stored in jQuery data has already been cloned in cloneCopyEvent. We must replace it with a fresh cloned tmplItem.
+				cloneTmplItem( tmplItem.key );
+				newTmplItems[tmplItem.key] = tmplItem;
+				pntNode = jQuery.data( el.parentNode, "tmplItem" );
+				pntNode = pntNode ? pntNode.key : 0;
+			}
+			if ( tmplItem ) {
+				pntItem = tmplItem;
+				// Find the template item of the parent element.
+				// (Using !=, not !==, since pntItem.key is number, and pntNode may be a string)
+				while ( pntItem && pntItem.key != pntNode ) {
+					// Add this element as a top-level node for this rendered template item, as well as for any
+					// ancestor items between this item and the item of its parent element
+					pntItem.nodes.push( el );
+					pntItem = pntItem.parent;
+				}
+				// Delete content built during rendering - reduce API surface area and memory use, and avoid exposing of stale data after rendering...
+				delete tmplItem._ctnt;
+				delete tmplItem._wrap;
+				// Store template item as jQuery data on the element
+				jQuery.data( el, "tmplItem", tmplItem );
+			}
+			function cloneTmplItem( key ) {
+				key = key + keySuffix;
+				tmplItem = newClonedItems[key] =
+					(newClonedItems[key] || newTmplItem( tmplItem, newTmplItems[tmplItem.parent.key + keySuffix] || tmplItem.parent ));
+			}
+		}
+	}
+
+	//---- Helper functions for template item ----
+
+	function tiCalls( content, tmpl, data, options ) {
+		if ( !content ) {
+			return stack.pop();
+		}
+		stack.push({ _: content, tmpl: tmpl, item:this, data: data, options: options });
+	}
+
+	function tiNest( tmpl, data, options ) {
+		// nested template, using {{tmpl}} tag
+		return jQuery.tmpl( jQuery.template( tmpl ), data, options, this );
+	}
+
+	function tiWrap( call, wrapped ) {
+		// nested template, using {{wrap}} tag
+		var options = call.options || {};
+		options.wrapped = wrapped;
+		// Apply the template, which may incorporate wrapped content,
+		return jQuery.tmpl( jQuery.template( call.tmpl ), call.data, options, call.item );
+	}
+
+	function tiHtml( filter, textOnly ) {
+		var wrapped = this._wrap;
+		return jQuery.map(
+			jQuery( jQuery.isArray( wrapped ) ? wrapped.join("") : wrapped ).filter( filter || "*" ),
+			function(e) {
+				return textOnly ?
+					e.innerText || e.textContent :
+					e.outerHTML || outerHtml(e);
+			});
+	}
+
+	function tiUpdate() {
+		var coll = this.nodes;
+		jQuery.tmpl( null, null, null, this).insertBefore( coll[0] );
+		jQuery( coll ).remove();
+	}
+})( jQuery );

lib/steelseries/scripts/src/tween.js

@@ -0,0 +1,380 @@
+/*!*********************************************************************
+TERMS OF USE - EASING EQUATIONS
+Open source under the BSD License.
+Copyright (c) 2001 Robert Penner
+JavaScript version copyright (C) 2006 by Philippe Maegerman
+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 the author nor the names of 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.
+*****************************************/
+function Delegate() {}
+Delegate.create = function (o, f) {
+	var a = [], i, l = arguments.length;
+	for (i = 2; i < l; i++) {
+		a[i - 2] = arguments[i];
+	}
+	return function () {
+		var aP = [].concat(arguments, a);
+		f.apply(o, aP);
+	};
+};
+
+/*
+object:
+  type:Object
+    The object you want to modify. It can be any object, a visual object that you want to animate ( document.body.style ) or an anymous object ( new Object() ).
+property:
+  type:String
+    The property that is updated on the target object, it can be empty ('')
+easing:
+  type:Function
+    The easing that will be applied to motion.
+start:
+  type:Number
+    Start value
+end:
+  type:Number
+    End value
+duration:
+  type:Number
+    Animation duration in seconds
+suffixe:
+ type:String
+   A string to append to the updated property ('%','pt','em' ...).
+*/
+
+var Tween = function (obj, prop, func, begin, finish, duration, suffixe) {
+	this.init(obj, prop, func, begin, finish, duration, suffixe);
+};
+var t = Tween.prototype;
+
+t.obj = {};
+t.prop = '';
+t.func = function (t, b, c, d) { return c * t / d + b; };
+t.begin = 0;
+t.change = 0;
+t.prevTime = 0;
+t.prevPos = 0;
+t.looping = false;
+t._duration = 0;
+t._time = 0;
+t._pos = 0;
+t._position = 0;
+t._startTime = 0;
+t._finish = 0;
+t.name = '';
+t.suffixe = '';
+t._listeners = [];
+t.setTime = function (t) {
+	this.prevTime = this._time;
+	if (t > this.getDuration()) {
+		if (this.looping) {
+			this.rewind(t - this._duration);
+			this.update();
+			this.broadcastMessage('onMotionLooped', {target: this, type: 'onMotionLooped'});
+		} else {
+			this._time = this._duration;
+			this.update();
+			this.stop();
+			this.broadcastMessage('onMotionFinished', {target: this, type: 'onMotionFinished'});
+		}
+	} else if (t < 0) {
+		this.rewind();
+		this.update();
+	} else {
+		this._time = t;
+		this.update();
+	}
+};
+t.getTime = function () {
+	return this._time;
+};
+t.setDuration = function (d) {
+	this._duration = (d === null || d <= 0) ? 100000 : d;
+};
+t.getDuration = function () {
+	return this._duration;
+};
+t.setPosition = function (p) {
+	this.prevPos = this._pos;
+	var a = this.suffixe !== '' ? this.suffixe : '';
+	this.obj[this.prop] = Math.round(p) + a;
+	this._pos = p;
+	this.broadcastMessage('onMotionChanged', {target: this, type: 'onMotionChanged'});
+};
+t.getPosition = function (t) {
+	if (t === undefined) {
+		t = this._time;
+	}
+	return this.func(t, this.begin, this.change, this._duration);
+};
+t.setFinish = function (f) {
+	this.change = f - this.begin;
+};
+t.getFinish = function () {
+	return this.begin + this.change;
+};
+t.init = function (obj, prop, func, begin, finish, duration, suffixe) {
+	if (!arguments.length) {
+		return;
+	}
+	this._listeners = [];
+	this.addListener(this);
+	if (suffixe) {
+		this.suffixe = suffixe;
+	}
+	this.obj = obj;
+	this.prop = prop;
+	this.begin = begin;
+	this._pos = begin;
+	this.setDuration(duration);
+	if (func !== null && func !== '') {
+		this.func = func;
+	}
+	this.setFinish(finish);
+};
+t.start = function () {
+	this.rewind();
+	this.startEnterFrame();
+	this.broadcastMessage('onMotionStarted', {target: this, type: 'onMotionStarted'});
+	//alert('in');
+};
+t.rewind = function (t) {
+	this.stop();
+	this._time = (t === undefined) ? 0 : t;
+	this.fixTime();
+	this.update();
+};
+t.fforward = function () {
+	this._time = this._duration;
+	this.fixTime();
+	this.update();
+};
+t.update = function () {
+	this.setPosition(this.getPosition(this._time));
+};
+t.startEnterFrame = function () {
+	this.stopEnterFrame();
+	this.isPlaying = true;
+	this.onEnterFrame();
+};
+t.onEnterFrame = function () {
+	if (this.isPlaying) {
+		this.nextFrame();
+		// To get real smooth movement you have to set the timeout to 0 instead of 25
+		setTimeout(Delegate.create(this, this.onEnterFrame), 25);
+	}
+};
+t.nextFrame = function () {
+	this.setTime((this.getTimer() - this._startTime) / 1000);
+};
+t.stop = function () {
+	this.stopEnterFrame();
+	this.broadcastMessage('onMotionStopped', {target: this, type: 'onMotionStopped'});
+};
+t.stopEnterFrame = function () {
+	this.isPlaying = false;
+};
+t.playing = function () {
+    return this.isPlaying;
+};
+t.continueTo = function (finish, duration) {
+	this.begin = this._pos;
+	this.setFinish(finish);
+	if (this._duration !== undefined) {
+		this.setDuration(duration);
+	}
+	this.start();
+};
+t.resume = function () {
+	this.fixTime();
+	this.startEnterFrame();
+	this.broadcastMessage('onMotionResumed', {target: this, type: 'onMotionResumed'});
+};
+t.yoyo = function () {
+	this.continueTo(this.begin, this._time);
+};
+t.addListener = function (o) {
+	this.removeListener(o);
+	return this._listeners.push(o);
+};
+t.removeListener = function (o) {
+	var a = this._listeners,
+		i = a.length;
+	while (i--) {
+		if (a[i] === o) {
+			a.splice(i, 1);
+			return true;
+		}
+	}
+	return false;
+};
+t.broadcastMessage = function () {
+	var arr = [], i, e, a = this._listeners,
+		l = a.length;
+	for (i = 0; i < arguments.length; i++) {
+		arr.push(arguments[i]);
+	}
+	e = arr.shift();
+
+	for (i = 0; i < l; i++) {
+		if (a[i][e]) {
+			a[i][e].apply(a[i], arr);
+		}
+	}
+};
+t.fixTime = function () {
+	this._startTime = this.getTimer() - this._time * 1000;
+};
+t.getTimer = function () {
+	return new Date().getTime() - this._time;
+};
+Tween.backEaseIn = function (t, b, c, d, a, p) {
+	var s = 1.70158;
+	return c * (t /= d) * t * ((s + 1) * t - s) + b;
+};
+Tween.backEaseOut = function (t, b, c, d, a, p) {
+	var s = 1.70158;
+	return c * ((t = t / d - 1) * t * ((s + 1) * t + s) + 1) + b;
+};
+Tween.backEaseInOut = function (t, b, c, d, a, p) {
+	var s = 1.70158;
+	if ((t /= d / 2) < 1) {
+		return c / 2 * (t * t * (((s *= (1.525)) + 1) * t - s)) + b;
+	}
+	return c / 2 * ((t -= 2) * t * (((s *= (1.525)) + 1) * t + s) + 2) + b;
+};
+Tween.elasticEaseIn = function (t, b, c, d, a, p) {
+	var s;
+	if (t === 0) {
+		return b;
+	}
+	if ((t /= d) === 1) {
+		return b + c;
+	}
+	if (!p) {
+		p = d * 0.3;
+	}
+	if (!a || a < Math.abs(c)) {
+		a = c;
+		s = p / 4;
+	} else {
+		s = p / (2 * Math.PI) * Math.asin(c / a);
+	}
+
+	return -(a * Math.pow(2, 10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p)) + b;
+
+};
+Tween.elasticEaseOut = function (t, b, c, d, a, p) {
+	var s;
+	if (t === 0) {
+		return b;
+	}
+	if ((t /= d) === 1) {
+		return b + c;
+	}
+	if (!p) {
+		p = d * 0.3;
+	}
+	if (!a || a < Math.abs(c)) {
+		a = c;
+		s = p / 4;
+	} else {
+		s = p / (2 * Math.PI) * Math.asin(c / a);
+	}
+	return (a * Math.pow(2, -10 * t) * Math.sin((t * d - s) * (2 * Math.PI) / p) + c + b);
+};
+Tween.elasticEaseInOut = function (t, b, c, d, a, p) {
+	var s;
+	if (t === 0) {
+		return b;
+	}
+	if ((t /= d / 2) === 2) {
+		return b + c;
+	}
+	if (!p) {
+		p = d * (0.3 * 1.5);
+	}
+	if (!a || a < Math.abs(c)) {
+		a = c;
+		s = p / 4;
+	} else {
+		s = p / (2 * Math.PI) * Math.asin(c / a);
+	}
+	if (t < 1) {
+		return -0.5 * (a * Math.pow(2, 10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p)) + b;
+	}
+	return a * Math.pow(2, -10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p) * 0.5 + c + b;
+};
+Tween.bounceEaseOut = function (t, b, c, d) {
+	if ((t /= d) < (1 / 2.75)) {
+		return c * (7.5625 * t * t) + b;
+	} else if (t < (2 / 2.75)) {
+		return c * (7.5625 * (t -= (1.5 / 2.75)) * t + 0.75) + b;
+	} else if (t < (2.5 / 2.75)) {
+		return c * (7.5625 * (t -= (2.25 / 2.75)) * t + 0.9375) + b;
+	} else {
+		return c * (7.5625 * (t -= (2.625 / 2.75)) * t + 0.984375) + b;
+	}
+};
+Tween.bounceEaseIn = function (t, b, c, d) {
+	return c - Tween.bounceEaseOut(d - t, 0, c, d) + b;
+};
+Tween.bounceEaseInOut = function (t, b, c, d) {
+	if (t < d / 2) {
+		return Tween.bounceEaseIn(t * 2, 0, c, d) * 0.5 + b;
+	} else {
+		return Tween.bounceEaseOut(t * 2 - d, 0, c, d) * 0.5 + c * 0.5 + b;
+	}
+};
+Tween.strongEaseInOut = function (t, b, c, d) {
+	return c * (t /= d) * t * t * t * t + b;
+};
+Tween.regularEaseIn = function (t, b, c, d) {
+	return c * (t /= d) * t + b;
+};
+Tween.regularEaseOut = function (t, b, c, d) {
+	return -c * (t /= d) * (t - 2) + b;
+};
+Tween.regularEaseInOut = function (t, b, c, d) {
+	if ((t /= d / 2) < 1) {
+		return c / 2 * t * t + b;
+	}
+	return -c / 2 * ((--t) * (t - 2) - 1) + b;
+};
+Tween.strongEaseIn = function (t, b, c, d) {
+	return c * (t /= d) * t * t * t * t + b;
+};
+Tween.strongEaseOut = function (t, b, c, d) {
+	return c * ((t = t / d - 1) * t * t * t * t + 1) + b;
+};
+Tween.strongEaseInOut = function (t, b, c, d) {
+	if ((t /= d / 2) < 1) {
+		return c / 2 * t * t * t * t * t + b;
+	}
+	return c / 2 * ((t -= 2) * t * t * t * t + 2) + b;
+};