(function(window, undefined)
{
	var plat4m, bootstrapList, compstrapList,
	document	= window.document,
	location	= window.location,
	navigator	= window.navigator,
		_tri4m	= window.tri4m,
		tri4m	= function(selector, context) { return new tri4m.shell.init(selector, context, plat4m); },
	ECMA_push	= Array.prototype.push,
	ECMA_slice	= Array.prototype.slice,
	ECMA_indexOf	= Array.prototype.indexOf,
	ECMA_toString	= Object.prototype.toString,
	ECMA_hasOwn	= Object.prototype.hasOwnProperty,
	ECMA_trim	= String.prototype.trim,
	ECMA_classType	= {},
	DOMContentLoaded = function()
	{
		if(document.addEventListener)
		{
			document.removeEventListener("DOMContentLoaded", DOMContentLoaded, false);
			tri4m.bootstrap();
		}
		else if(document.readyState === "complete")
		{
			document.detachEvent("onreadystatechange", DOMContentLoaded);
			tri4m.bootstrap();
		}
	};
	
	var REGEX_V_MS_PREFIX 	= /^-ms-/;
	var REGEX_D_DASH_ALPHA	= /-([\da-z])/gi;
	var REGEX_C_NOT_WHITE	= /\S/;
	var REGEX_C_SPACE	= /\s+/;
	
	var JQUERY_SRC		= 'http://code.jquery.com/jquery-latest.min.js';
	var JQUERY_INIT_TIME	= 500; // idle for jQuery === undefined

tri4m.shell = tri4m.prototype =
{
	constructor: tri4m,
	init: function(selector, context, plat4m)
	{
		if(!selector)
			return this;
			
		if(selector.nodeType)
		{
			this.context = this[0] = selector;
			this.length = 1;
			return this;
		}
		
		if(typeof selector === "string")
		{
			tri4m.log('no jQuery - no selector support! (request: ' + selector + ')', 3);
			return this;
		}
		else if(tri4m.isFunction(selector))
		{
			return plat4m.compstrap(selector);
		}

		if(typeof selector.selector !== 'undefined')
		{
			this.selector = selector.selector;
			this.context  = selector.context;
		}

		return tri4m.makeArray(selector, this);
	},
	selector: "",
	build: "1.8.3",
	minor: "1.8.2",
	major: "1.8.3",
	length: 0,
	size: function()
	{
		return this.length;
	},
	toArray: function()
	{
		return ECMA_slice.call(this);
	},
	get: function(num)
	{
		return num == null
			? this.toArray()
			: (num < 0 ? this[this.length + num] : this[num]);
	},
	pushStack: function(elems, name, selector)
	{
		var ret = tri4m.merge(this.constructor(), elems);
		
		ret.prevObject = this;
		ret.context    = this.context;

		if(name === "find")
		{
			ret.selector = this.selector + (this.selector ? " " : "") + selector;
		}
		else if(name)
		{
			ret.selector = this.selector + "." + name + "(" + selector + ")";
		}
		
		return ret;
	},
	each: function(callback, args)
	{
		return tri4m.each(this, callback, args);
	},
	bootstrap: function(fn)
	{
		tri4m.bootstrap.promise().done(fn);
		return this;
	},
	compstrap: function(fn)
	{
		tri4m.compstrap.promise().done(fn);
		return this;
	},
	eq: function(i)
	{
		i = +i;
		return i === -1
			? this.slice(i)
			: this.slice(i, i + 1);
	},
	first: function()
	{
		return this.eq(0);
	},
	last: function()
	{
		return this.eq(-1);
	},
	slice: function()
	{
		return this.pushStack
		(
			ECMA_slice.apply(this, arguments),
			"slice",
			ECMA_slice.call(arguments).join(",")
		);
	},
	map: function(callback)
	{
		return this.pushStack
		(
			tri4m.map
			(
				this,
				function(elem, i)
				{
					return callback.call(elem, i, elem);
				}
			)
		);
	},
	end: function()
	{
		return this.prevObject || this.constructor(null);
	},
	push: ECMA_push,
	sort: [].sort,
	splice: [].splice
};

tri4m.shell.init.prototype = tri4m.shell;


tri4m.extend = tri4m.shell.extend = function()
{
	var opt, name, des, ref, refIsArray, clone, tar = arguments[0] || {}, i = 1, length = arguments.length, rec = false;

	if(typeof tar === "boolean")
	{
		rec = tar;
		tar = arguments[1] || {};
		i = 2;
	}
		
	if(typeof tar !== "object"
	&& !tri4m.isFunction(tar))
		tar = {};
		
	if(length === i)
	{
		tar = this;
		--i;
	}

	for(; i < length; i++)
	{
		if((opt = arguments[i]) == null)
			continue;
		
		for(name in opt)
		{
			des = tar[name];
			ref = opt[name];
			
			if(tar === ref)
				continue;

			if(rec
			&& ref
			&& (tri4m.isPlainObject(ref) || (refIsArray = tri4m.isArray(ref))))
			{
				if(refIsArray)
				{
					refIsArray = false;
					clone = des && tri4m.isArray(des) ? des : [];

				}
				else
				{
					clone = des && tri4m.isPlainObject(des) ? des : {};
				}

				tar[name] = tri4m.extend(rec, clone, ref);
				
				continue;
			}
			
			if(ref === undefined)
				continue;
				
			tar[name] = ref;
		}
	}
	
	return tar;
};

tri4m.extend(
{
	isBootstrapped: false,
	isCompstrapped: false,
	bootstrapWait: 1,
	compstrapWait: 1,
	holdBoot: function(hold)
	{
		if(hold)
		{
			tri4m.bootstrapWait++;
		}
		else
		{
			tri4m.bootstrap(true);
		}
	},
	bootstrap: function(wait)
	{
		if(wait === true ? --tri4m.bootstrapWait : tri4m.isBootstrapped)
			return;
			
		if(!document.body)
			return setTimeout(tri4m.bootstrap, 1);

		tri4m.isBootstrapped = true;
		
		if(wait !== true
		&& --tri4m.bootstrapWait > 0)
			return;
		
		bootstrapList.resolveWith(document, [tri4m]);

		tri4m.log('-- Bootstrap complete');
	},
	compstrap: function(wait)
	{
		if(wait === true ? --tri4m.compstrapWait : tri4m.isCompstrapped)
			return;
			
		if(!document.body)
			return setTimeout(tri4m.compstrap, 1);

		tri4m.isCompstrapped = true;
		
		if(wait !== true
		&& --tri4m.compstrapWait > 0)
			return;
		
		compstrapList.resolveWith(document, [tri4m]);
		
		tri4m.log('-- Compstrap complete');
	},
	log : function(sText, sType, _bTimestamp)
	{
		var debugMode = true, useConsole = true,
			 c = null, d = ['log', 'info', 'warn', 'error'], sType = sType || 0, n = d[sType];
						
		if(typeof l == 'undefined')
			l = 0;
	
		if(false === debugMode)
			return this;
		
		
		if(null === c)
			c = (typeof console !== 'undefined' && typeof console.log !== 'undefined');
		

		if(typeof(_bTimestamp) !== 'undefined' && _bTimestamp)
			sText = sText + ' | ' + new Date().getTime();

		sText = 'tri4m: ' + sText;
		sType = d[sType];
		
		l++;
		
		if(c && useConsole)
		{
			if(typeof console[sType] === 'undefined')
				sType = d[sType];
			
			if(typeof console[sType] !== 'undefined')
			{
				console[sType](sText);
			}
			else
			{
				console.log(sText);
			}
		}
		
		return this;
	},
	isFunction: function(obj)
	{
		return tri4m.type(obj) === "function";
	},
	isArray: Array.isArray || function(obj)
	{
		return tri4m.type(obj) === "array";
	},
	isWindow: function(obj)
	{
		return obj != null && obj == obj.window;
	},
	isNumeric: function(obj)
	{
		return !isNaN(parseFloat(obj)) && isFinite(obj);
	},
	type: function(obj)
	{
		return obj == null ?
			String(obj) :
			ECMA_classType[ECMA_toString.call(obj)] || "object";
	},
	isPlainObject: function(obj)
	{
		if(!obj || tri4m.type(obj) !== "object" || obj.nodeType || tri4m.isWindow(obj))
			return false;

		try {
			if(obj.constructor
			&& !ECMA_hasOwn.call(obj, "constructor")
			&& !ECMA_hasOwn.call(obj.constructor.prototype, "isPrototypeOf"))
				return false;
		}
		catch(e)
		{
			return false;
		}

		var key;
		for(key in obj) {}

		return key === undefined || ECMA_hasOwn.call(obj, key);
	},
	isEmptyObject: function(obj)
	{
		var name;
		for(name in obj)
			return false;
		
		return true;
	},
	stringToFlag: function(options, type)
	{
		var object = {};
		
		var type = (type
				&& type === true
				|| type === false
				|| type === null
				|| type === 0
				|| type === 1
				|| type === 2)
					? type
					: true;
		
		tri4m.each
		(
			options.split(REGEX_C_SPACE),
			function(i, flag)
			{
				i++;
				if(type === 0)
				{
					object[flag] = i - 1;
					return;
				}
				
				if(type === 1)
				{
					object[flag] = i;
					return;
				}
				
				if(type === 2)
				{
					object[flag] = Math.pow(2, i);
					return;
				}
				
				object[flag] = type;
			}
		);
		
		return object;
	},
	objectToString : function(object, includeFunctions, fullPrintFunctions, tbl)
	{
		var incFunctions = includeFunctions || false, prntFunctions = fullPrintFunctions || false, tbl = tbl || false;
		
		var type = function(p, t, l)
		{
			var l = l || 0, s = tri4m.stringRepeat('    ', l), n = "\n" + s, d = n + '@prop ' + p + ': ', r;
			
			var space	= n;
			var type	= '[property] ';
			var name	= p;
			var value	= t;
			var scalar	= true;
			
			switch(true)
			{
				case(typeof t === "undefined"):
					value = "undefined";
					break;
				case(t === null):
					value = "null";
					break;
				case(typeof t === "boolean"):
					value = (t === true) ? "true" : 'false';
					type = "[boolean]";
					break;
				case(t === NaN):
					value = "NaN" ;
					break;
				case(tri4m.isFunction(t)):
					internal = t.toString().match(/\[native code\]/g);
					type = "[function"+ ((internal !== null) ? "[internal: " + t.constructor.name + "]" : "") + "]";
					value = (true === prntFunctions) ? t.toString() : null;
					break;
				case(tri4m.isArray(t) && t.length === 0):
					type = "[array]";
					value = "[]";
					break;
				case(tri4m.isArray(t)):
					var b = parse(t, (l + 1)).join("");
					type = "[array]";
					value = n + " [" + b + n + "], ";
					scalar = false;
					break;
				case (typeof t === "object" && tri4m.isEmptyObject(t)):
					type = "[object]";
					value = "[]";
					break;
				case (typeof t === "object"):
					var b = parse(t, (l + 1)).join(s);
					type = "[object]";
					value = "[" + b + n +"], ";
					scalar = false;
					break;
				case (typeof t === "string"):
					type = "[string]";
					value = "'" + t.toString() + "', ";
					break;
				default:
					type = "[" + (typeof t) + "]";
					value = t.toString();
					break;
			}
			
			return { space : space, type : type, name : name, value : value, scalar : scalar };
		};
		
		var parse = function(o, l)
		{
			var a = [], b = [], l = l || 1, tl = 0, nl = 0;
			
			for(var p in o)
			{
				if(typeof o.hasOwnProperty !== 'function')
					continue;
					
				if(!o.hasOwnProperty(p))
					continue;
				
				var t = o[p];
				
				if(false === incFunctions
				&& tri4m.isFunction(t))
					continue;
				
				a[a.length] = type(p, t, l);
			}
			
			for(var i in a)
			{
				var atl = a[i].type.length, anl = a[i].name.length;
				
				if(atl > tl)
					tl = atl;
					
				if(anl > nl)
					nl = anl;
			}
			
			for(var i in a)
			{
				var t = a[i], n = t.name, p = t.type, v = t.value;
				
				if(true === t.scalar && true === tbl)
				{
					n = tri4m.stringPadRight(t.name, " ", nl);
					p = tri4m.stringPadRight(t.type, " ", tl)
				}
				
				v =  (null === v) ? "" : ": " + v;
				
				b[b.length] = t.space + p + " " + n + v;
			}
			
			return b;
		};
		
		var r = parse(object).join("");
		r = (r !== '') ? r + "\n" : 'null';
			
		return "{{{!:" + r + ":!EOF}}}\n";
	},
	rand: function(numericScope)
	{
		if(!numericScope)
			var numericScope = Math.floor(Math.random());
		
		return Math.floor(Math.random() * numericScope);
	},
	sprintf: function(str)
	{
		for(var i = 1, len = arguments.length; i < len; ++i)
			str = str.replace("{" + (i - 1) + "}", arguments[i]);
		
		return str;
	},
	sizeOf : function(subject)
	{
		if(tri4m.isArray(subject))
			return subject.length;
			
		if(typeof subject === 'undefined') return;
		if(typeof subject === null) return;
		
		var c = 0;
		for(var i in subject) c++;
		return c;
	},
	sleep : function(subject, time, callback)
	{
		var i = subject;
		
		i.queue(function()
		{
			setTimeout(function()
			{
				i.dequeue();
				if(callback) callback();
				return subject;
			}, time);
		});
		
		return subject;
	},
	stringFindNumber: function(string)
	{
		string = string.replace(/[^0-9]/gi, '');
		if(!string || isNaN(string)) string = 0;
		return string;
	},
	stringPadLeft: function(string, chr, width)
	{
		var result = string, length = width - result.toString().length, i = length - 1;
			
		if(width > 0 && i >= 0)
			do result = chr + result;
			while(i--);
		
		return result;
	},
	stringPadRight: function(string, chr, width)
	{
		var result = string, length = width - result.toString().length, i = length - 1;
			
		if(width > 0 && i >= 0)
			do result = result + chr;
			while(i--);
		
		return result;
	},
	stringRepeat: function(string, width)
	{
		var result = '';
		for(var i = 0; i < width; i++)
			result += string;
		
		return result;
	},
	stringToWrite : function(str, depth, width, chr)
	{
		var width = width || 8, depth = depth || 0, chr = chr || ' ';
		return tri4m.stringRepeat(chr, depth * width) + str + "\n";
	},
	trimChar: function(string, chr)
	{
		if(string.substr(0, 1) === chr)
			string = string.substr(1, (string.length - 1));
		if(string.substr((string.length - 1), string.length) === chr)
			string = string.substr(0, (string.length - 1));
		return string;
	},
	trimCharsRight: function(string, charlist)
	{
		charlist = !charlist ? ' \\s\u00A0' : (charlist + '').replace(/([\[\]\(\)\.\?\/\*\{\}\+\tri4m\^\:])/g, '\\tri4m1');
		return (string + '').replace(new RegExp('[' + charlist + ']+tri4m', 'g') , '');
	},
	zeroFill: function(number, width, includeDecimal)
	{
		if(typeof includeDecimal == 'undefined')
			includeDecimal = false;
		
		var result = parseFloat(number), negative = false, length = width - result.toString().length, i = length - 1;
		
		if(result < 0)
		{
			result = Math.abs(result);
			negative = true;
			length++;
			i = length - 1;
		}
		
		if(width > 0)
		{
			if(result.toString().indexOf('.') > 0)
			{
				if(!includeDecimal)
					length += result.toString().split('.')[1].length;
				length++;
				i = length - 1;
			}
			
			if(i >= 0)
				do result = '0' + result;
				while (i--);
		}
		
		return (true === negative)
			? '-' + result
			: result;
	},
	rgb2hex : function(dec)
	{
		var n = parseInt(dec), c = 'ABCDEF', b = n / 16, r = n % 16; b = b-(r/16); 
		b = ((b >= 0) && (b <= 9)) ? b : c.charAt(b - 10);    
		return ((r >= 0) && (r <= 9)) ? b + '' + r : b + '' + c.charAt(r - 10);
	},
	dec2hex : function(d)
	{
		return Number(d).toString(16).toUpperCase();
	},
	dec2hexCode : function(dec, length)
	{
		if(!length) var length = 8;
		return '0x' + tri4m.stringPadLeft(tri4m.dec2hex(dec), '0', length);
	},
	error: function(msg)
	{
		throw new Error(msg);
	},
	noop: function() {},
	globalEval: function(data) {
		if(data
		&& ECMA_rnotwhite.test(data))
			(window.execScript || function(data) { window["eval"].call(window, data); })(data);
	},
	camelCase: function(string) {
		return string.replace(REGEX_V_MS_PREFIX, "ms-").replace(REGEX_D_DASH_ALPHA, fcamelCase);
	},
	nodeName: function(elem, name) {
		return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
	},
	each: function(obj, callback, args)
	{
		var name, i = 0, length = obj.length, isObj = length === undefined || tri4m.isFunction(obj);

		if(args)
		{
			if(isObj)
			{
				for(name in obj)
					if(callback.apply(obj[name], args) === false)
						break;
			}
			else
			{
				for(; i < length;)
					if(callback.apply(obj[i++], args) === false)
						break;
			}
		}
		else
		{
			if(isObj)
			{
				for(name in obj)
					if(callback.call(obj[name], name, obj[name]) === false)
						break;
			} 
			else
			{
				for(; i < length;)
					if(callback.call(obj[i], i, obj[i++]) === false)
						break;
			}
		}

		return obj;
	},
	trim: function(text)
	{
		if(ECMA_trim
		&& !ECMA_trim.call("\uFEFF\xA0"))
		{
			return (function(text)
			{
				return text == null
					? ""
					: ECMA_trim.call(text);
			})(text);
		}
		else
		{
			return (function(text)
			{
				return text == null
				? ""
				: (text + "").replace(rtrim, "");
			})(text);
		}
	},
	makeArray: function(arr, results)
	{
		var type, ret = results || [];

		if(arr == null)
			return ret;
			
		type = tri4m.type(arr);

		if(arr.length == null
		|| type === "string"
		|| type === "function"
		|| type === "regexp"
		|| tri4m.isWindow(arr))
		{
			ECMA_push.call(ret, arr);
		}
		else
		{
			tri4m.merge(ret, arr);
		}

		return ret;
	},
	inArray: function(elem, arr, i) {
		var len;

		if(arr)
		{
			if(ECMA_indexOf)
				return ECMA_indexOf.call(arr, elem, i);
	
			len = arr.length;
			i = i ? i < 0 ? Math.max(0, len + i) : i : 0;
			
			for(; i < len; i++)
				if(i in arr
				&& arr[i] === elem)
					return i;
		}

		return -1;
	},
	merge: function(first, second)
	{
		var l = second.length, i = first.length, j = 0;

		if(typeof l === "number")
		{
			for(; j < l; j++)
				first[i++] = second[j];
		}
		else
		{
			while(second[j] !== undefined)
				first[i++] = second[j++];
		}

		first.length = i;

		return first;
	},
	grep: function(elems, callback, inv)
	{
		var retVal, ret = [], i = 0, length = elems.length;
		
		inv = !!inv;

		for(; i < length; i++)
		{
			retVal = !!callback(elems[i], i);
			if(inv !== retVal)
				ret.push(elems[i]);
		}

		return ret;
	},
	map: function(elems, callback, arg)
	{
		var value, key, ret = [], i = 0, length = elems.length,
		isArray = elems instanceof tri4m
				|| length !== undefined 
					&& typeof length === "number"
					&& ((length > 0 && elems[0] && elems[length -1])
						|| length === 0
						|| tri4m.isArray(elems));

		if(isArray)
		{
			for(; i < length; i++)
			{
				value = callback(elems[i], i, arg);

				if(value != null)
					ret[ret.length] = value;
			}
		}
		else
		{
			for(key in elems)
			{
				value = callback(elems[key], key, arg);
				
				if(value != null)
					ret[ret.length] = value;
			}
		}

		return ret.concat.apply([], ret);
	},
	guid: 1,
	proxy: function(fn, context)
	{
		var tmp, args, proxy;

		if(typeof context === "string")
		{
			tmp = fn[context];
			context = fn;
			fn = tmp;
		}

		if(!tri4m.isFunction(fn))
			return undefined;

		args = ECMA_slice.call(arguments, 2);
		proxy = function()
		{
			return fn.apply(context, args.concat(ECMA_slice.call(arguments)));
		};
		
		proxy.guid = fn.guid = fn.guid || tri4m.guid++;

		return proxy;
	},
	access: function(elems, fn, key, value, chainable, emptyGet, pass)
	{
		var exec, bulk = key == null, i = 0, length = elems.length;
		
		if(key
		&& typeof key === "object")
		{
			for(i in key)
				tri4m.access(elems, fn, i, key[i], 1, emptyGet, value);
			
			chainable = 1;
		}
		else if(value !== undefined)
		{
			exec = pass === undefined && tri4m.isFunction(value);

			if(bulk)
			{
				if(exec)
				{
					exec = fn;
					
					fn = function(elem, key, value)
					{
						return exec.call(tri4m(elem), value);
					};
				}
				else
				{
					fn.call(elems, value);
					fn = null;
				}
			}

			if(fn)
				for(; i < length; i++)
					fn(elems[i], key, exec ? value.call(elems[i], i, fn(elems[i], key)) : value, pass);

			chainable = 1;
		}

		return chainable
			? elems
			: bulk
				? fn.call(elems)
				: length
					? fn(elems[0], key)
					: emptyGet;
	},
	now: function()
	{
		return (new Date()).getTime();
	},
	loadScript: function(src, callback)
	{
		var head = document.getElementsByTagName('head')[0],
			script = document.createElement('script');
			done = false;
		
		script.setAttribute('src', src);
		script.setAttribute('type', 'text/javascript');
		script.setAttribute('charset', 'utf-8');
		
		script.onload = script.onreadstatechange = function()
		{
			if(!done
			&& (!this.readyState || this.readyState == 'loaded' || this.readyState == 'complete'))
			{
				done = true;
				script.onload = script.onreadystatechange = null;
				if(callback)
				{
					callback();
				}
			}
		};
		
		head.insertBefore(script, head.firstChild);
	},
	toRegister :
	{
		expr :
		{
			':' : {}
		}
	}
});

		
tri4m.bootstrap.promise = function(obj)
{
	if(!bootstrapList)
	{
		bootstrapList = tri4m.Deferred();
		
		if(document.readyState === "complete")
		{
			setTimeout(tri4m.bootstrap, 1);
		}
		else if(document.addEventListener)
		{
			document.addEventListener("DOMContentLoaded", DOMContentLoaded, false);
			window.addEventListener("load", tri4m.bootstrap, false);
		}
		else
		{
			document.attachEvent("onreadystatechange", DOMContentLoaded);
			window.attachEvent("onload", tri4m.bootstrap);
			var top = false;

			try
			{
				top = window.frameElement == null && document.documentElement;
			}
			catch(e)
			{
			}

			if(top && top.doScroll)
			{
				(function doScrollCheck()
				{
					if(!tri4m.isBootstrapped)
					{
						try
						{
							top.doScroll("left");
						}
						catch(e)
						{
							return setTimeout(doScrollCheck, 50);
						}

						tri4m.bootstrap();
					}
				})();
			}
		}
	}
	
	return bootstrapList.promise(obj);
};

tri4m.compstrap.promise = function(obj)
{
	if(!compstrapList)
		compstrapList = tri4m.Deferred();
	
	return compstrapList.promise(obj);
};

tri4m.each
(
	"Boolean Number String Function Array Date RegExp Object".split(" "),
	function(i, name)
	{
		ECMA_classType["[object " + name + "]"] = name.toLowerCase();
	}
);

plat4m = tri4m(document);


var optionsCache = {};
var createOptions = function(options)
{
	var object = optionsCache[options] = {};
	tri4m.each
	(
		options.split(REGEX_C_SPACE),
		function(_, flag)
		{
			object[flag] = true;
		}
	);
	
	return object;
};

tri4m.Callbacks = function(options)
{
	options = typeof options === "string"
		? (optionsCache[options] || createOptions(options))
		: tri4m.extend({}, options);

	var memory,
		fired,
		firing,
		firingStart,
		firingLength,
		firingIndex,
		list 		= [],
		stack 		= !options.once && [],
		fire = function(data)
		{
			memory		= options.memory && data;
			fired		= true;
			firingIndex	= firingStart || 0;
			firingStart	= 0;
			firingLength	= list.length;
			firing		= true;
			
			for(; list && firingIndex < firingLength; firingIndex++)
			{
				if(list[firingIndex].apply(data[0], data[1]) === false
				&& options.stopOnFalse)
				{
					memory = false;
					break;
				}
			}
			
			firing = false;
			
			if(list)
			{
				if(stack)
				{
					if(stack.length)
						fire(stack.shift());
				}
				else if(memory)
				{
					list = [];
				}
				else
				{
					self.disable();
				}
			}
		},
		self = {
			add : function()
			{
				if(list)
				{
					var start = list.length;
					
					(function add(args)
					{
						tri4m.each(args, function(_, arg)
						{
							var type = tri4m.type(arg);
							
							if(type === "function")
							{
								if(!options.unique
								|| !self.has(arg))
									list.push(arg);
							}
							else if(arg
							&& arg.length
							&& type !== "string")
							{
								add(arg);
							}
						});
					})(arguments);
					
					if(firing)
					{
						firingLength = list.length;
					}
					else if(memory)
					{
						firingStart = start;
						fire(memory);
					}
				}
				
				return this;
			},
			remove: function()
			{
				if(list)
				{
					tri4m.each
					(
						arguments,
						
						function(_, arg)
						{
							var index;
							
							while((index = tri4m.inArray(arg, list, index)) > -1)
							{
								list.splice(index, 1);
								if(firing)
								{
									if(index <= firingLength)
										firingLength--;
										
									if(index <= firingIndex)
										firingIndex--;
								}
							}
						}
					);
				}
				
				return this;
			},
			has: function(fn)
			{
				return tri4m.inArray(fn, list) > -1;
			},
			empty: function()
			{
				list = [];
				return this;
			},
			disable: function()
			{
				list = stack = memory = undefined;
				return this;
			},
			disabled: function()
			{
				return !list;
			},
			lock: function()
			{
				stack = undefined;
				if(!memory)
					self.disable();
				
				return this;
			},
			locked: function()
			{
				return !stack;
			},
			fireWith: function(context, args)
			{
				args = args || [];
				args = [context, args.slice ? args.slice() : args];
				
				if(list
				&& (!fired || stack))
				{
					if(firing)
					{
						stack.push(args);
					}
					else
					{
						fire(args);
					}
				}
				
				return this;
			},
			fire: function()
			{
				self.fireWith(this, arguments);
				return this;
			},
			fired: function()
			{
				return !!fired;
			}
		};

	return self;
};

tri4m.extend(
{
	Deferred: function(func)
	{
		var 	tuples =
			[	/* action, add listener, listener list, final state */
				["resolve", "done",     tri4m.Callbacks("once memory"), "resolved"],
				["reject",  "fail",     tri4m.Callbacks("once memory"), "rejected"],
				["notify",  "progress", tri4m.Callbacks("memory")]
			],
			state = "pending",
			promise =
			{
				state: function()
				{
					return state;
				},
				always: function()
				{
					deferred.done(arguments).fail(arguments);
					return this;
				},
				then: function(/* fnDone, fnFail, fnProgress */)
				{
					var fns = arguments;
					return tri4m.Deferred(function(newDefer)
					{
						tri4m.each(tuples, function(i, tuple)
						{
							var action = tuple[0],
								fn = fns[i];
							
							deferred[tuple[1]](tri4m.isFunction(fn)
								? function()
								{
									var returned = fn.apply(this, arguments);
									if(returned && tri4m.isFunction(returned.promise))
									{
										returned.promise()
											.done(newDefer.resolve)
											.fail(newDefer.reject)
											.progress(newDefer.notify);
									}
									else
									{
										newDefer[action + "With"](this === deferred
											? newDefer
											: this, [returned]);
									}
								}
								: newDefer[action]
							);
						});
						
						fns = null;
						
					}).promise();
				},
				promise: function(obj)
				{
					return obj != null
						? tri4m.extend(obj, promise)
						: promise;
				}
			},
			deferred = {};

		promise.pipe = promise.then;
		
		tri4m.each(tuples, function(i, tuple)
		{
			var list = tuple[2], stateString = tuple[3];
			promise[tuple[1]] = list.add;
			
			if(stateString)
			{
				list.add
				(
					function()
					{
						state = stateString;
					},
					tuples[i ^ 1][2].disable,
					tuples[2][2].lock
				);
			}

			deferred[tuple[0]] = list.fire;
			deferred[tuple[0] + "With"] = list.fireWith;
		});

		promise.promise(deferred);

		if(func)
			func.call(deferred, deferred);

		return deferred;
	},
	when: function(subordinate /* , ..., subordinateN */)
	{
		var 	i 		= 0,
			resolveValues	= core_slice.call(arguments),
			length		= resolveValues.length,
			remaining	= length !== 1 || (subordinate && tri4m.isFunction(subordinate.promise)) ? length : 0,
			deferred	= remaining === 1 ? subordinate : tri4m.Deferred(),
			updateFunc = function(i, contexts, values)
			{
				return function(value)
				{
					contexts[i]	= this;
					values[i]	= arguments.length > 1 ? core_slice.call(arguments) : value;
					
					if(values === progressValues)
					{
						deferred.notifyWith(contexts, values);
					}
					else if(!(--remaining))
					{
						deferred.resolveWith(contexts, values);
					}
				};
			},
			progressValues, progressContexts, resolveContexts;

		if(length > 1)
		{
			progressValues		= new Array(length);
			progressContexts	= new Array(length);
			resolveContexts		= new Array(length);
			
			for(; i < length; i++)
			{
				if(resolveValues[i]
				&& tri4m.isFunction(resolveValues[i].promise))
				{
					resolveValues[i].promise()
						.done(updateFunc(i, resolveContexts, resolveValues))
						.fail(deferred.reject)
						.progress(updateFunc(i, progressContexts, progressValues));
				}
				else
				{
					--remaining;
				}
			}
		}
		
		if(!remaining)
			deferred.resolveWith(resolveContexts, resolveValues);

		return deferred.promise();
	}
});

tri4m.extend
(
	{
		lib :
		{
			exception :
			{
				Throwable : function(name)
				{
					var name = name;
					
					var constructor = function(message)
					{
						//Error.apply(this, arguments);
						if(this == window) return new arguments.callee(message, level);
						
						this.message	= message || '';
						this.name	= name + '.Exception';
					};
					
					constructor.name = name || 'tri4m.lib.exception.Throwable';
					constructor.prototype.toString = Error.prototype.toString;
					
					return constructor;
				}
			},
			loader :
			{
				/**
				 * @param string src
				 * @param object lfo		the expected object
				 * @param function onload
				 * @param function callback
				 */
				Javascript : function(options)
				{
					this.name = 'tri4m.lib.loader.Javascript';
					this.Exception = new tri4m.lib.exception.Throwable(this.name);
					
					var tried 	= false;
					var avail 	= false;
					
					var __settings = tri4m.extend(
					{
						src		: null,
						lfo		: null,
						success		: null
					}, options);
					
					this.load = function()
					{
						if(true === tried)
							return this;
							
						tried = true;
							
						if(null === __settings.src)
							throw new this.Exception('src is null.');
						
						/* NullReferenceError....
						if(typeof __settings.lfo !== 'undefined' && __settings.lfo !== null)
						{
							tri4m.log('lfo is avail: ' + tri4m.objectToString(__settings.lfo));
							
							avail = true;
							__settings.callback(this);
							return this;
						}
						
						*/
						
						tri4m.log('Load script ' + __settings.src);
						
						try
						{
							var head = document.getElementsByTagName('head')[0],
								script = document.createElement('script');
						
							script.setAttribute('src', __settings.src);
							script.setAttribute('type', 'text/javascript');
							script.setAttribute('charset', 'utf-8');
							
							script.onload = script.onreadstatechange = function()
							{
								if(!this.readyState
								|| this.readyState == 'loaded'
								|| this.readyState == 'complete')
								{
									script.onload = script.onreadystatechange = null;
									
									if(tri4m.isFunction(__settings.success))
										__settings.success(__settings);
										
								}
							};
						
							head.insertBefore(script, head.firstChild);
							
						}
						catch(e)
						{
							throw new this.Exception('Unable to append javasript ' + __settings.src)
						}
						
						
						return this;
					}
				},
				/**
				 * @param string src
				 * @param object lfo		the expected object
				 * @param function onload
				 * @param function callback
				 */
				Stylesheet : function(options)
				{
					this.name = 'tri4m.lib.loader.Stylesheet';
					this.Exception = new tri4m.lib.exception.Throwable(this.name);
					
					var tried 	= false;
					var avail 	= false;
					
					var __settings = tri4m.extend(
					{
						src		: null,
						lfo		: null,
						success		: null
					}, options);
					
					this.load = function()
					{
						if(true === tried)
							return this;
							
						tried = true;
							
						if(null === __settings.src)
							throw new this.Exception('src is null.');
						
						/* NullReferenceError....
						if(typeof __settings.lfo !== 'undefined' && __settings.lfo !== null)
						{
							tri4m.log('lfo is avail: ' + tri4m.objectToString(__settings.lfo));
							
							avail = true;
							__settings.callback(this);
							return this;
						}
						
						*/
						
						tri4m.log('Load script ' + __settings.src);
						
						try
						{
							var head = document.getElementsByTagName('head')[0],
								script = document.createElement('link');
						
							script.setAttribute('src', __settings.src);
							script.setAttribute('type', 'text/css');
							script.setAttribute('media', 'all');
							
							script.onload = script.onreadstatechange = function()
							{
								if(!this.readyState
								|| this.readyState == 'loaded'
								|| this.readyState == 'complete')
								{
									script.onload = script.onreadystatechange = null;
									
									if(tri4m.isFunction(__settings.success))
										__settings.success(__settings);
										
								}
							};
						
							head.insertBefore(script, head.firstChild);
							
						}
						catch(e)
						{
							throw new this.Exception('Unable to append stylesheet ' + __settings.src)
						}
						
						
						return this;
					}
				},
				/**
				 * Queue-Loader based on Automation-Player
				 *
				 *
				 * var Loader = new tri4m.lib.loader.Queue('Javascript');
				 *
				 * var myComplete = function() { Loader.next(); alert('whohoo'); }
				 *
				 * Loader.push(new tri4m.lib.loader.Javascript({src : 'swfobject.js', success : Loader.next}))
				 * Loader.push(new tri4m.lib.loader.Javascript({src : 'whoohooo.js', success : myComplete }));
				 * Loader.push(new tri4m.lib.loader.Javascript({src : 'another.js', success : Loader.next }));
				 * Loader.start();
				 *
				 *
				 * jQuery is ready before we init our plugins:
				 * plat4m.bootstrap(function()
				 * {
				 * 	var JS = tri4m.lib.loader.Javascript, JSLoader = tri4m.lib.loader.Queue,
				 * 		Compstrap = new JSLoader,
				 *		Bootstrap = new JSLoader({ success: Compstrap.start });
				 * 	
				 * 	Bootstrap.push(new JS({ src : 'http://localfrost/wp-content/plugins/tri4m/jquery.js', success : Bootstrap.next }));
				 * 	Compstrap.push(new JS({ src : 'http://localfrost/wp-content/plugins/tri4m/tri4mQtLoader/js/tri4m.QtLoader.js' }));
				 * 	
				 * 	setTimeout
				 * 	(
				 * 		function()
				 * 		{
				 * 			typeof jQuery === 'undefined'
				 * 				? Bootstrap.start()
				 * 				: Compstrap.start();
				 * 		} , 200
				 * 	);
				 * });
				 *
				 * @note calling Loader.next() in File-callback is required
				 * @see ri4m.lib.automation.Player
				 */
				Queue : function(options) 
				{
					var __methods = new tri4m.lib.method.Hook,
						__player = new tri4m.lib.automation.Player(options);
					
					/**
					 * @param tri4m.lib.loader.File File
					 */
					this.push = function(File)
					{
						__methods.push(File.load);
						return this;
					}
					
					/**
					 * start
					 */
					this.start = function()
					{	
						__player.setup(__methods).play();
						return this;
					}
					
					/**
					 * next
					 */
					this.next = function()
					{
						__player.next();
						return this;
					}
				}
			},
			property :
			{
				/**
				 * value for value-queue
				 *
				 * overwrite is allowed or not
				 *
				 * @param value mixed
				 * @param protect bool true: can not overwrite existing value
				 */
				Value : function(value, protect)
				{
					this.name = 'tri4m.lib.property.Value';
					this.Exception = new tri4m.lib.exception.Throwable(this.name);
					
					var __value = value || null;
					var __protect = (protect === true) ? true : false;
					
					/**
					 * get value
					 * @return mixed
					 */
					this.get = function()
					{
						return __value;
					};
					
					/**
					 * set value
					 *
					 * this has no effect, if __protect is true
					 * @return tri4m.lib.property.Value
					 */
					this.set = function(value)
					{
						if(__protect === true)
							throw new this.Exception(value + ' is protected', 3);
						
						__value = value;
						return this;
					};
					
					/**
					 * get variable as object
					 *
					 * @return object
					 */
					this.toObject = function()
					{
						return {
							value   : __value,
							protect : __protect
						};
					};
				},
				/**
				 * value registry
				 *
				 * store vars with values
				 *
				 * // new value-queue
				 * var foo = new tri4m.lib.property.Registry();
				 *
				 * // var "baz"
				 * foo.register('baz', 'baz: bar'); log.t100(foo.get('baz')); // baz: bar
				 * foo.set('baz', 'baz: bar -> foo'); log.t100(foo.get('baz')); // baz: foo
				 *
				 * // protected var "foo"
				 * foo.register('foo', 'foo: lol', true); log.t100(foo.get('foo')); // foo: lol
				 * foo.set('foo', 'foo: lol -> rofl'); log.t100(foo.get('foo')); // foo: lol
				 */
				Registry : function()
				{
					this.name = 'tri4m.lib.property.Registry';
					this.Exception = new tri4m.lib.exception.Throwable(this.name);
					
					var __data = {};
					
					/**
					 * register value-instance
					 *
					 * @param name string instance-name
					 * @param value mixed
					 * @param protect bool true: can not overwrite existing value
					 * @see tri4m.lib.property.Value()
					 * @return tri4m.lib.property.Registry
					 */
					this.register = function(name, value, protect)
					{
						if(this.isset(name) === true)
							throw new this.Exception('Unable to register existing property ' +  name, 3);
						
						__data[name] = new tri4m.lib.property.Value(value, protect);

						return this;
					};
					
					/**
					 * unregister value-instance
					 *
					 * @param name string instance-name
					 * @return tri4m.lib.property.Registry
					 */
					this.unregister = function(name)
					{
						if(this.isset(name) === false)
							return this;
						
						delete _data[name]

						return this;
					};

					/**
					 * isset instance
					 *
					 * @param name string instance-name
					 * @return bool
					 */
					this.isset = function(name)
					{
						return (!__data[name]) ? false : true;
					};

					/**
					 * get value of instance
					 *
					 * @param name string instance-name
					 * @see tri4m.lib.property.Value.get()
					 * @return tri4m.lib.property.Value || null
					 */
					this.get = function(name)
					{
						return ((this.isset(name) === true) ? __data[name].get() : null);
					};

					/**
					 * set value of instance
					 *
					 * you must register your variable at first!
					 * you can not use this registry as garbage dump!
					 *
					 * @param name string instance-name
					 * @param value mixed
					 * @see tri4m.lib.property.Value.set()
					 * @return tri4m.lib.property.Registry
					 */
					this.set = function(name, value)
					{
						if(false === this.isset(name))
							throw new this.Exception('Unable to update value for ' +  name + ': not found', 3);
						
						try{ __data[name].set(value); }
						catch(e){ throw new this.Exception('Unable update value for ' +  name, 3); }
						
						return this;
					};

					/**
					 * get queue as object
					 *
					 * @return tri4m.lib.property.Registry  as propertyName:propertyValue object
					 */
					this.toObject = function()
					{
						var q = {};
						for(i in __data)
							q[i] = __data[i].toObject();
						return q;
					};

					/**
					 * get queue as value object
					 *
					 * @return tri4m.lib.property.Registry.__data as propertyValue object
					 */
					this.toValueObject = function()
					{
						var q = {};
						for(i in __data)
							q[i] = __data[i].toObject().value;
						return q;
					};

					/**
					 * get queue as property object
					 *
					 * @return tri4m.lib.property.Registry.__data as propertyName object
					 */
					this.toPropertyObject = function()
					{
						var q = {};
						var k = 0;
						for(i in __data)
						{
							q[k] = i;
							k++;
						}
						return q;
					};
				}
			},
			method :
			{
				/**
				 * method FIFO
				 *
				 * @param runonce bool true: terminate queue on exec
				 *
				 * // some stuff
				 * var test11 = function(){log.t100('test1.1')};
				 * var test12 = function(){log.t100('test1.2')};
				 *
				 * // default queue
				 * var bar = new tri4m.lib.method.Hook;
				 * bar.push(test11).push(test12)
				 *	.execute()	// test1.1 test1.2
				 *	.execute();	// test1.1 test1.2
				 *
				 * // run-once queue
				 * var baz = new tri4m.lib.method.Hook(true);
				 * baz.push(test11).push(test12)
				 *	.execute()	// test1.1 test1.2
				 *	.execute();	// nothing
				 */
				Hook : function(runonce)
				{
					this.name = 'tri4m.lib.method.Hook';
					this.Exception = new tri4m.lib.exception.Throwable(this.name);
					
					var __hook = [];
					var __runonce = (runonce !== true) ? false : true;

					/**
					 * add function to queue
					 *
					 * @param fn function
					 * @return tri4m.lib.method.Hook
					 */
					this.push = function(fn)
					{
						__hook.push(fn);
						return this;
					};

					/**
					 * execute queue
					 *
					 * @return tri4m.lib.method.Hook
					 */
					this.execute = function()
					{
						if(__hook.length === 0)
							return this;

						if(__runonce === false)
							for(i in __hook) __hook[i]();
						else
							while(__hook.length > 0) (__hook.shift())();

						return this;
					};

					/**
					 * terminate queue
					 *
					 * @return tri4m.lib.method.Hook
					 */
					this.reset = function()
					{
						__hook = [];
						return this;
					};

					/**
					 * get queue as array
					 *
					 * @return tri4m.lib.method.Hook.__hook... imho as copy
					 */
					this.toArray = function()
					{
						var a = __hook;
						return a;
					};
				},
				/**
				 * method hook registry
				 *
				 * // some stuff
				 * var test11 = function(){log.t100('test1.1')};
				 * var test12 = function(){log.t100('test1.2')};
				 * var test21 = function(){log.t100('test2.1')};
				 * var test22 = function(){log.t100('test2.2')};
				 *
				 * // create registry queue
				 * var foo = new tri4m.lib.method.Registry();
				 *
				 * // default queue
				 * foo.register('test1').push('test1', test11).push('test1', test12)
				 *	.execute('test1')	// test1.1 test1.2
				 *	.execute('test1');	// test1.1 test1.2
				 *
				 * // run-once queue
				 * foo.register('test2', true).push('test2', test11).push('test2', test12)
				 *	.execute('test2')	// test2.1 test2.2
				 *	.execute('test2');	// nothing
				 *
				 *
				 * // shorthand:
				 * // default queue
				 * foo.get('test3').push(test21).push(test22)
				 *	.execute()	// test2.1 test2.2
				 *	.execute();	// test2.1 test2.2
				 *
				 * // run-once queue
				 * foo.get('test4', true).push(test21).push(test22)
				 *	.execute()	// test2.1 test2.2
				 *	.execute();	// nothing
				 */
				Registry : function()
				{
					this.name = 'tri4m.lib.method.Registry';
					this.Exception = new tri4m.lib.exception.Throwable(this.name);
					
					var __hook = new tri4m.lib.property.Registry();

					/**
					 * register queue instance
					 *
					 * @param name string instance-name
					 * @param runonce bool
					 * @see tri4m.lib.method.Hook()
					 * @see tri4m.lib.property.Registry.register()
					 * @return tri4m.lib.method.Registry
					 */
					this.register = function(name, runonce)
					{
						__hook.register(name, new tri4m.lib.method.Hook(runonce), true);
						return this;
					};

					/**
					 * isset instance
					 *
					 * @param name string instance-name
					 * @see tri4m.lib.property.Registry.isset()
					 * @return bool tri4m.lib.property.Registry.isset()
					 */
					this.isset = function(name)
					{
						return __hook.isset(name);
					};

					/**
					 * get/create queue instance
					 *
					 * @param name string instance-name
					 * @param runonce bool
					 * @see tri4m.lib.method.Hook
					 * @return tri4m.lib.method.Hook
					 */
					this.get = function(name, runonce)
					{
						//log.t100(__hook.get(name).className());
						if(this.isset(name) === false)
							this.register(name, runonce);
						return __hook.get(name);
					};

					/**
					 * execute queue of instance
					 *
					 * @param name string instance-name
					 * @see tri4m.lib.method.Hook.execute()
					 * @return tri4m.lib.method.Registry
					 */
					this.execute = function(name)
					{
						if(this.isset(name) === true)
							this.get(name).execute();
						return this;
					};

					/**
					 * terminate queue
					 *
					 * @see tri4m.lib.method.Hook.reset()
					 * @return tri4m.lib.method.Registry
					 */
					this.reset = function(name)
					{
						if(this.isset(name) === true)
							this.get(name).reset();
						return this;
					};

					/**
					 * add function to queue of instance
					 *
					 * @param name string instance-name
					 * @param fn function
					 * @see tri4m.lib.method.Hook.push()
					 * @return tri4m.lib.method.Registry
					 */
					this.push = function(name, fn)
					{
						if(this.isset(name) === true)
							this.get(name).push(fn);
						return this;
					};

					/**
					 * get queue as object
					 *
					 * @return tri4m.lib.property.Registry.__hook as copy
					 */
					this.toObject = function()
					{
						return __hook.toObject();
					};

					/**
					 * get queue as object
					 *
					 * @return tri4m.lib.property.Registry.__hook as copy
					 */
					this.getHook = function()
					{
						var q = __hook;
						return q;
					};
				}
			},
			automation :
			{
				/**
				 * animation playlist player
				 *
				 * split methods from tri4m.lib.method.Hook
				 * to partials
				 *
				 * @example tri4m.lib.loader.Queue
				 *
				 *
				 * step 1:
				 * 	create your methods:
				 *
				 * ...
				 * Env :
				 * {
				 * 	Playlists : null,
				 * 	Animation :
				 * 	{
				 * 		test10 : function(){
				 * 			log.t100('test10');
				 * 			tri4m('ul.list li').css({height: 5});
				 * 			tri4m.Env.Playlists.next('intro');
				 * 		},
				 * 		test11 : function(){
				 * 			log.t100('test11');
				 * 			tri4m('ul.list li').animate({height: 140}, 2200, function()
				 * 			{
				 * 				log.t100('test11 anim callback');
				 * 				tri4m.Env.Playlists.next('intro');
				 * 			});
				 * 		},
				 * 		test12 : function(){
				 * 			log.t100('test12');
				 * 			tri4m('ul.list li').css({width: 10});
				 * 			tri4m.Env.Playlists.next('intro');
				 * 		},
				 * 		test13 : function(){
				 * 			log.t100('test13');
				 * 			tri4m('ul.list li').animate({width: 140}, 2200);
				 * 			tri4m.Env.Playlists.next('intro');
				 * 		}
				 * 	}
				 * },
				 * ...
				 *
				 *
				 * step 2:
				 *	init the animation registry and register
				 * 	the methods into sections, e.g. "intro" or "button-hover"
				 *
				 * ...
				 * test : function()
				 * {
				 * 	tri4m.Env.Playlists =
				 *		new tri4m.lib.automation.Registry();
				 *
				 * 	tri4m.Env.Playlists.register('intro')
				 * 		.push(tri4m.Env.Animation.test10)
				 * 		.push(tri4m.Env.Animation.test11)
				 * 		.push(tri4m.Env.Animation.test12)
				 * 		.push(tri4m.Env.Animation.test13)
				 * 	;
				 * 	tri4m.Env.Playlists.play('intro');
				 * },
				 * ...
				 *
				 *
				 * @todo	lock, pause, start, stop not really implemented
				 */
				Player : function(options)
				{
					this.name = 'tri4m.lib.automation.Player';
					this.Exception = new tri4m.lib.exception.Throwable(this.name);
					
					
					var __settings = tri4m.extend(
					{
						onPlayStart	: tri4m.noop,
						onPlayNext	: tri4m.noop,
						onPlayPause	: tri4m.noop,
						onPlayStop	: tri4m.noop,
						success	: tri4m.noop
					}, options);
					
					/**
					 * method registry queue
					 */
					var __registry = null;

					/**
					 * __isPlaying bool status quo
					 */
					var __isPlaying = false;

					/**
					 * translated registry as func-callback-object
					 */
					var __playlist = [];

					/**
					 * working-copy of __playlist
					 */
					var __playqueue = [];

					/**
					 * counter
					 */
					var __playedTimes = 0;

					/**
					 * install method queue
					 *
					 * @param registry tri4m.lib.method.Hook
					 * @return tri4m.lib.automation.Player
					 */
					this.setup = function(registry)
					{
						if(__registry !== null)
							return this;

						__registry = registry;

						var methods = __registry.toArray();

						for(var i = 0; i < methods.length; i++)
						{
							var fn = methods[i];

							if(typeof fn !== 'function')
								continue;

							var cb = function(){};
							
							if((next = methods[i+1]))
							{
								if(typeof next !== 'function')
									continue;

								cb = next;
							}

							var item = {
								method: fn,
								callback :
								{
									method : cb
								}
							};
							
							__playlist.push(item);
						}
						
						return this;
					};

					/**
					 * init playing
					 *
					 * @return tri4m.lib.automation.Player
					 */
					this.play = function()
					{
						if(true === this.isPlaying())
							return false;

						if(__playqueue.length === 0)
						{
							__playedTimes++;
							__settings.onPlayStart();
						}
							
						
						__isPlaying = true;
						__playqueue = __playlist;
						

						this.next();
						return this;
					};

					/**
					 * play next method
					 *
					 * test11 : function(){
					 * 	log.t100('test11');
					 * 	tri4m('ul.list li').animate({height: 140}, 2200, function()
					 * 	{
					 * 		log.t100('test11 anim callback');
					 * 		tri4m.Env.Playlists.next('intro');
					 * 	});
					 * },
					 *
					 * @return tri4m.lib.automation.Player
					 */
					this.next = function()
					{
						if(null === __playqueue)
							return this;

						var next = null;

						if(__playqueue.length > 0)
							next = __playqueue.shift();

						if(!next)
						{
							this.stop();
							__settings.success();
							return this;
						}

						__settings.onPlayNext();
						next.method();

						return this;
					};

					/**
					 * pause
					 *
					 * @return tri4m.lib.automation.Player
					 */
					this.pause = function()
					{
						__isPlaying = false;
						__settings.onPlayPause();
						return this;
					};

					/**
					 * stop/abort playing and delete working copy
					 *
					 * @return tri4m.lib.automation.Player
					 */
					this.stop = function()
					{
						__playqueue = [];
						__isPlaying = false;
						__settings.onPlayStop();
						return this;
					};

					/**
					 * is playing status
					 *
					 * @return bool status quo
					 */
					this.isPlaying = function()
					{
						return __isPlaying;
					};
				},
				/**
				 * playlist class
				 *
				 * holds a methodhook (playlist) and the player
				 *
				 */
				Playlist : function()
				{
					this.name = 'tri4m.lib.automation.Playlist';
					this.Exception = new tri4m.lib.exception.Throwable(this.name);
					
					/**
					 * method queue/playlist
					 */
					var __playlist	= new tri4m.lib.method.Hook();

					/**
					 * player
					 */
					var __player	= new tri4m.lib.automation.Player();

					/**
					 * push method to __playlist
					 *
					 * @param function
					 * @return tri4m.lib.automation.Playlist
					 */
					this.push = function(fn)
					{
						__playlist.push(fn);
						return this;
					};

					/**
					 * initialize player and start playing
					 *
					 * @return tri4m.lib.automation.Playlist
					 */
					this.play = function()
					{
						__player.setup(__playlist).play();
						return this;
					};

					/**
					 * play next frame
					 *
					 * this is the callback-caller
					 *
					 * test11 : function(){
					 * 	log.t100('test11');
					 * 	tri4m('ul.list li').animate({height: 140}, 2200, function()
					 * 	{
					 * 		log.t100('test11 anim callback');
					 * 		tri4m.Env.Playlists.next('intro');
					 * 	});
					 * },
					 *
					 *
					 * @return tri4m.lib.automation.Playlist
					 */
					this.next = function()
					{
						__player.next();
						return this;
					};
				},
				/**
				 * playlist/player registry
				 *
				 * store animation-queues by event-name
				 *
				 */
				Registry : function()
				{
					this.name = 'tri4m.lib.automation.Registry';
					this.Exception = new tri4m.lib.exception.Throwable(this.name);
					
					var __queue = new tri4m.lib.property.Registry();

					/**
					 * craete a new playlist-instance
					 *
					 * @param string instance name
					 * @return tri4m.lib.automation.Playlist
					 */
					this.register = function(name)
					{
						__queue.register(name, new tri4m.lib.automation.Playlist(), true);
						return __queue.get(name);
					};

					/**
					 * get playlist-instance
					 *
					 * @param string instance name
					 * @return tri4m.lib.automation.Playlist
					 */
					this.get = function(name)
					{
						return __queue.get(name);
					};
					
					/**
					 * play a playlist-instance
					 *
					 * @param string instance name
					 * @return tri4m.lib.automation.Registry
					 */
					this.play = function(name)
					{
						__queue.get(name).play();
						return this;
					};
					
					/**
					 * play next callback
					 *
					 * @param string instance name
					 * @return tri4m.lib.automation.Registry
					 */
					this.next = function(name)
					{
						__queue.get(name).next();
						return this;
					};
				}
			}
		}
	}
);

tri4m.extend
(
	{
		append :
		{
			/**
			 * head:
			 *
			 * (function(tri4m, undefined)
			 * {
			 * 	tri4m(function()
			 * 	{
			 * 		tri4m.append([
			 * 			'plugin.js',
			 * 			'another.js'
			 * 		],
			 * 		{
			 * 			success : function()
			 * 			{
			 * 				tri4m.log('-- init my plugin');
			 * 			}
			 * 		});
			 * 	});
			 * })(tri4m);
			 */
			Javascript : function(src, options, hold)
			{
				var __settings = tri4m.extend
				(
					{
						success	: tri4m.noop
					},
					options
				);
				
				if(typeof stack === 'undefined')
					 stack = new tri4m.lib.loader.Queue({ success : __settings.success });
				
				if(typeof src !== 'string')
				{
					var i = 0, l = src.length;
					
					for(var name in src)
					{
						i++;
						tri4m.append.Javascript(src[name], {}, i !== l)
					}
						
					return tri4m.com;
				}
				
				if(typeof cache === 'undefined')
					cache = [];
				
				for(var i in cache)
					if(src === cache[i])
						return tri4m.com;
				
				cache.push(src);	
				
				tri4m.log('append script ' + src);
				
					 
				var cur = stack;
				
				stack.push(new tri4m.lib.loader.Javascript(
				{
					//src : src + '?' + Math.random(0, 100000000),
					src : src,
					success : cur.next
					
				}));
				
				if(!hold || hold !== true)
					stack.start();
					
				return tri4m;
			},
			Stylesheet : function(src, options, hold)
			{
				var __settings = tri4m.extend
				(
					{
						success	: tri4m.noop
					},
					options
				);
				
				if(typeof stack === 'undefined')
					 stack = new tri4m.lib.loader.Queue({ success : __settings.success });
				
				if(typeof src !== 'string')
				{
					var i = 0, l = src.length;
					
					for(var name in src)
					{
						i++;
						tri4m.append.Stylesheet(src[name], {}, i !== l)
					}
						
					return tri4m.com;
				}
				
				if(typeof cache === 'undefined')
					cache = [];
				
				for(var i in cache)
					if(src === cache[i])
						return tri4m.com;
				
				cache.push(src);	
				
				tri4m.log('append script ' + src);
				
					 
				var cur = stack;
				
				stack.push(new tri4m.lib.loader.Stylesheet(
				{
					//src : src + '?' + Math.random(0, 100000000),
					src : src,
					success : cur.next
				}));
				
				if(!hold || hold !== true)
					stack.start();
					
				return tri4m;
			}
		}
	}
);

tri4m.com = function(name, base, prototype)
{
	var 	fullName,
		existingConstructor,
		constructor,
		basePrototype,
		namespace = name.split(".")[0];

	name		= name.split(".")[1];
	fullName	= 'tri4m-' + namespace + "-" + name;
	

	if(!prototype)
	{
		prototype	= base;
		base		= tri4m.__Com;
	}
	
	tri4m.toRegister.expr[':'][fullName] = function(elem)
	{
		return !!jQuery.data(elem, fullName);
	};

	tri4m[namespace]	= tri4m[namespace] || {};
	existingConstructor	= tri4m[namespace][name];
	
	constructor = tri4m[namespace][name] = function(options, element)
	{
		if(!this._create__Com)
			return new constructor(options, element);

		if(arguments.length)
			this._create__Com(options, element);
	};
	
	tri4m.extend(constructor, existingConstructor,
	{
		version: prototype.version,
		_proto: tri4m.extend({}, prototype),
		_childConstructors: []
	});

	basePrototype		= new base();
	basePrototype.options	= tri4m.com.extend({}, basePrototype.options);
	
	tri4m.each(prototype, function(prop, value)
	{
		if(tri4m.isFunction(value)) {
			prototype[prop] = (function()
			{
				var 	_super = function()
					{
						return base.prototype[prop].apply(this, arguments);
					},
					_superApply = function(args)
					{
						return base.prototype[prop].apply(this, args);
					};
					
				return function()
				{
					var	__super		= this._super,
						__superApply	= this._superApply,
						returnValue;

					this._super		= _super;
					this._superApply	= _superApply;
					returnValue 		= value.apply(this, arguments);
					this._super		= __super;
					this._superApply	= __superApply;

					return returnValue;
				};
			})();
		}
	});
	
	constructor.prototype = tri4m.com.extend
	(
		basePrototype,
		{
			comEventPrefix: name
		},
		prototype,
		{
			constructor:	constructor,
			namespace:	namespace,
			comName:	name,
			comBaseClass:	fullName,
			comFullName:	fullName
		}
	);

	if(existingConstructor)
	{
		tri4m.each(existingConstructor._childConstructors, function(i, child)
		{
			var childPrototype = child.prototype;
			tri4m.com(childPrototype.namespace + "." + childPrototype.comName, constructor, child._proto);
		});
		
		delete existingConstructor._childConstructors;
	}
	else
	{
		base._childConstructors.push(constructor);
	}

	tri4m.com.bridge(name, constructor);
};

tri4m.com.extend = function(target)
{
	var 	input		= ECMA_slice.call(arguments, 1),
		inputIndex	= 0,
		inputLength	= input.length,
		key,
		value;
		
	for(  ; inputIndex < inputLength; inputIndex++)
	{
		for(key in input[inputIndex])
		{
			value = input[inputIndex][key];
			
			if(input[inputIndex].hasOwnProperty(key) && value !== undefined)
			{
				target[key] = tri4m.isPlainObject(value)
					? tri4m.com.extend({}, target[key], value)
					: value;
			}
		}
	}
	
	return target;
};

tri4m.com.bridge = function(name, object)
{
	var fullName = object.prototype.comFullName;
	tri4m.shell[name] = function(options)
	{
		var	isMethodCall	= typeof options === "string",
			args		= ECMA_slice.call(arguments, 1),
			returnValue	= this;

		options = !isMethodCall && args.length
			? tri4m.com.extend.apply(null, [options].concat(args))
			: options;

		if(isMethodCall)
		{
			this.each(function()
			{
				var methodValue, instance = jQuery.data(this, fullName);
				
				if(!instance)
					return tri4m.log("cannot call methods on " + name + " prior to initialization; " + "attempted to call method '" + options + "'", 3);
				
				if(!tri4m.isFunction(instance[options]) || options.charAt(0) === "_")
					return tri4m.log("no such method '" + options + "' for " + name + " com instance", 3);
				
				
				methodValue = instance[options].apply(instance, args);
				
				
				if(methodValue !== instance
				&& methodValue !== undefined)
				{
					returnValue = methodValue && methodValue.jquery
						? returnValue.pushStack(methodValue.get())
						: methodValue;
						
					return false;
				}
			});
		}
		else
		{
			this.each(function()
			{
				var instance = tri4m.data(this, fullName);
				
				if(instance)
				{
					instance.option(options || {})._init();
				}
				else
				{
					new object(options, this);
				}
			});
		}

		return returnValue;
	};
};

var uuid			= 0;
tri4m.__Com			= function(options, element) {};
tri4m.__Com._childConstructors	= [];

tri4m.__Com.prototype =
{
	comName: "component",
	defaultElement: "<div>",
	options:
	{
		disabled: false,

		// callbacks
		create: null
	},
	_create__Com: function(options, element)
	{
		element			= jQuery(element || this.defaultElement || this)[0];
		this.element		= jQuery(element);
		this.uuid		= uuid++;
		this.eventNamespace	= "." + this.comName + this.uuid;
		this.options		= tri4m.com.extend
					(
						{},
						this.options,
						this._getCreateOptions(),
						options
					);
		
		if(element !== this)
		{
			jQuery.data(element, this.comName, this);
			jQuery.data(element, this.comFullName, this);
		}
		
		this.element.addClass(this.comFullName);

		this._create();
		this._init();
	},
	_getCreateOptions:	tri4m.noop,
	_getCreateEventData:	tri4m.noop,
	_init:			tri4m.noop,
	_log: function(message, level)
	{
		if(typeof this.options.debug === 'undefined')
			return;
			
		if(this.options.debug !== true)
			return;
			
		tri4m.log(this.comName + ': ' + message, level);
	},
	com: function()
	{
		return this.element;
	},
	keyCode: {
		ALT: 18,
		BACKSPACE: 8,
		CAPS_LOCK: 20,
		COMMA: 188,
		COMMAND: 91,
		COMMAND_LEFT: 91, // COMMAND
		COMMAND_RIGHT: 93,
		CONTROL: 17,
		DELETE: 46,
		DOWN: 40,
		END: 35,
		ENTER: 13,
		ESCAPE: 27,
		HOME: 36,
		INSERT: 45,
		LEFT: 37,
		MENU: 93, // COMMAND_RIGHT
		NUMPAD_ADD: 107,
		NUMPAD_DECIMAL: 110,
		NUMPAD_DIVIDE: 111,
		NUMPAD_ENTER: 108,
		NUMPAD_MULTIPLY: 106,
		NUMPAD_SUBTRACT: 109,
		PAGE_DOWN: 34,
		PAGE_UP: 33,
		PERIOD: 190,
		RIGHT: 39,
		SHIFT: 16,
		SPACE: 32,
		TAB: 9,
		UP: 38,
		WINDOWS: 91 // COMMAND
	},
	option: function(key, value)
	{
		var options = key, parts, curOption, i;

		if(arguments.length === 0)
			return tri4m.com.extend({}, this.options);

		if(typeof key === "string")
		{
			// handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
			options	= {};
			parts	= key.split(".");
			key	= parts.shift();
			
			if(parts.length)
			{
				curOption = options[key] = tri4m.com.extend({}, this.options[key]);
				
				for(i = 0; i < parts.length - 1; i++)
				{
					curOption[parts[i]]	= curOption[parts[i]] || {};
					curOption		= curOption[parts[i]];
				}
				
				key = parts.pop();
				
				if(value === undefined)
					return curOption[key] === undefined
						? null
						: curOption[key];
				
				curOption[key] = value;
			}
			else
			{
				if(value === undefined)
					return this.options[key] === undefined ? null : this.options[key];
				
				options[key] = value;
			}
		}

		this._setOptions(options);

		return this;
	},
	_setOptions: function(options)
	{
		var key;

		for (key in options)
			this._setOption(key, options[key]);

		return this;
	},
	_setOption: function(key, value)
	{
		this.options[key] = value;

		if(key === "disabled")
		{
			this.com()
				.toggleClass(this.comFullName + "-disabled ui-state-disabled", !!value)
				.attr("aria-disabled", value);
		}

		return this;
	}
};

tri4m.com("__postInit.__Com",
{
	_create__Com: function()
	{
		tri4m.__Com.prototype._create__Com.apply(this, arguments);
		this._init();
	},
});

plat4m.bootstrap(function()
{
	var 	JS		= tri4m.lib.loader.Javascript,
		JSLoader	= tri4m.lib.loader.Queue,
		Bootstrap	= new JSLoader({ success : tri4m.compstrap  });
	
	Bootstrap.push(new JS({ src : JQUERY_SRC, success : Bootstrap.next }));
	
	setTimeout
	(
		function()
		{
			typeof jQuery === 'undefined'
				? Bootstrap.start()
				: tri4m.compstrap();
		},
		JQUERY_INIT_TIME
	);
});

window.tri4m = tri4m;
})(window);