var Compro = Compro || {};

	window['IncludeJavaScript'] = function(jsFile)
	{
		document.write('<script type="text/javascript" src="' + jsFile + '"></scr' + 'ipt>');
	}
	
	IncludeJavaScript('http://media.compro.se/common/effects.prototype.js');



	document.loadCSS = function( filename )
	{
		if( typeof this.filesadded == 'undefined' || !this.filesadded )
		{
			this.filesadded = "";
		}
		
		if( this.filesadded.indexOf("["+filename+"]") == -1 )
		{
			this.filesadded += "["+filename+"]";
			document.getElementsByTagName("head")[0].appendChild(new Element("link", {'media':'screen','rel':'stylesheet','type':'text/css','href':filename}));
		}
		return document;
	}
	
	document.loadJS = function( filename )
	{
		if( typeof this.filesadded == 'undefined' || !this.filesadded )
		{
			this.filesadded = "";
		}
		
		if( this.filesadded.indexOf("["+filename+"]")==-1 )
		{
			this.filesadded += "["+filename+"]";
			document.getElementsByTagName("head")[0].appendChild(new Element("script", {'type':'text/javascript','src':filename}));
		}
		return document;
	}
	
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	
	Ajax.Send = function( requestURL, data )
	{
		if( typeof Ajax.Send.firstListIndex == 'undefined' )
		{
			Ajax.Send.requests = [];
			Ajax.Send.firstListIndex = 0;
			Ajax.Send.lastListIndex = 0;
		}

		if( typeof requestURL == 'undefined' || !requestURL )
		{
			if( Ajax.Send.firstListIndex == Ajax.Send.lastListIndex )
			{
				return;
			}
			else
			{
				var req = Ajax.Send.requests[Ajax.Send.firstListIndex];
				requestURL = req['requestURL'];
				data = req['data'];
			}
		}
		else
		{
			var req = {"requestURL":requestURL,"data":data};
			Ajax.Send.requests[Ajax.Send.lastListIndex++] = req;
			if( (Ajax.Send.lastListIndex - Ajax.Send.firstListIndex) == 1 )
			{
				Ajax.Send();
			}
			return;
		}
		
		return new Ajax.Request(requestURL,
		{
			method:(data?'post':'get'),
			parameters:data,
			onComplete: function(transport)
			{
				Ajax.Send.firstListIndex++;
				Ajax.Send();
			}
		});

	}
	
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	String.prototype.insert = function(index, str) 
	{
		return this.substring(0,index) + str.toString() + this.substring(index);
	}
	
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	
	String.prototype.trim = function()
	{
		return this.replace(/^\s+|\s+$/g, "");
	}
	
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	
	String.prototype.sprintf = function()
	{
		// http://kevin.vanzonneveld.net
		// +   original by: Ash Searle (http://hexmen.com/blog/)
		// + namespaced by: Michael White (http://getsprink.com)
		// +    tweaked by: Jack
		// +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
		// +      input by: Paulo Ricardo F. Santos
		// +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
		// +      input by: Brett Zamir (http://brett-zamir.me)
		// +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
		// *     example 1: sprintf("%01.2f", 123.1);
		// *     returns 1: 123.10
		// *     example 2: sprintf("[%10s]", 'monkey');
		// *     returns 2: '[    monkey]'
		// *     example 3: sprintf("[%'#10s]", 'monkey');
		// *     returns 3: '[####monkey]'

		var regex = /%%|%(\d+\$)?([-+\'#0 ]*)(\*\d+\$|\*|\d+)?(\.(\*\d+\$|\*|\d+))?([scboxXuidfegEG])/g;
		var a = arguments, i = 0, format = a[i++];

		// pad()
		var pad = function (str, len, chr, leftJustify) {
			if (!chr) {chr = ' ';}
			var padding = (str.length >= len) ? '' : Array(1 + len - str.length >>> 0).join(chr);
			return leftJustify ? str + padding : padding + str;
		};

		// justify()
		var justify = function (value, prefix, leftJustify, minWidth, zeroPad, customPadChar) {
			var diff = minWidth - value.length;
			if (diff > 0) {
				if (leftJustify || !zeroPad) {
					value = pad(value, minWidth, customPadChar, leftJustify);
				} else {
					value = value.slice(0, prefix.length) + pad('', diff, '0', true) + value.slice(prefix.length);
				}
			}
			return value;
		};

		// formatBaseX()
		var formatBaseX = function (value, base, prefix, leftJustify, minWidth, precision, zeroPad) {
			// Note: casts negative numbers to positive ones
			var number = value >>> 0;
			prefix = prefix && number && {'2': '0b', '8': '0', '16': '0x'}[base] || '';
			value = prefix + pad(number.toString(base), precision || 0, '0', false);
			return justify(value, prefix, leftJustify, minWidth, zeroPad);
		};

		// formatString()
		var formatString = function (value, leftJustify, minWidth, precision, zeroPad, customPadChar) {
			if (precision != null) {
				value = value.slice(0, precision);
			}
			return justify(value, '', leftJustify, minWidth, zeroPad, customPadChar);
		};

		// doFormat()
		var doFormat = function (substring, valueIndex, flags, minWidth, _, precision, type) {
			var number;
			var prefix;
			var method;
			var textTransform;
			var value;

			if (substring == '%%') {return '%';}

			// parse flags
			var leftJustify = false, positivePrefix = '', zeroPad = false, prefixBaseX = false, customPadChar = ' ';
			var flagsl = flags.length;
			for (var j = 0; flags && j < flagsl; j++) {
				switch (flags.charAt(j)) {
					case ' ': positivePrefix = ' '; break;
					case '+': positivePrefix = '+'; break;
					case '-': leftJustify = true; break;
					case "'": customPadChar = flags.charAt(j+1); break;
					case '0': zeroPad = true; break;
					case '#': prefixBaseX = true; break;
				}
			}

			// parameters may be null, undefined, empty-string or real valued
			// we want to ignore null, undefined and empty-string values
			if (!minWidth) {
				minWidth = 0;
			} else if (minWidth == '*') {
				minWidth = +a[i++];
			} else if (minWidth.charAt(0) == '*') {
				minWidth = +a[minWidth.slice(1, -1)];
			} else {
				minWidth = +minWidth;
			}

			// Note: undocumented perl feature:
			if (minWidth < 0) {
				minWidth = -minWidth;
				leftJustify = true;
			}

			if (!isFinite(minWidth)) {
				throw new Error('sprintf: (minimum-)width must be finite');
			}

			if (!precision) {
				precision = 'fFeE'.indexOf(type) > -1 ? 6 : (type == 'd') ? 0 : undefined;
			} else if (precision == '*') {
				precision = +a[i++];
			} else if (precision.charAt(0) == '*') {
				precision = +a[precision.slice(1, -1)];
			} else {
				precision = +precision;
			}

			// grab value using valueIndex if required?
			value = valueIndex ? a[valueIndex.slice(0, -1)] : a[i++];

			switch (type) {
				case 's': return formatString(String(value), leftJustify, minWidth, precision, zeroPad, customPadChar);
				case 'c': return formatString(String.fromCharCode(+value), leftJustify, minWidth, precision, zeroPad);
				case 'b': return formatBaseX(value, 2, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
				case 'o': return formatBaseX(value, 8, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
				case 'x': return formatBaseX(value, 16, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
				case 'X': return formatBaseX(value, 16, prefixBaseX, leftJustify, minWidth, precision, zeroPad).toUpperCase();
				case 'u': return formatBaseX(value, 10, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
				case 'i':
				case 'd':
					number = parseInt(+value, 10);
					prefix = number < 0 ? '-' : positivePrefix;
					value = prefix + pad(String(Math.abs(number)), precision, '0', false);
					return justify(value, prefix, leftJustify, minWidth, zeroPad);
				case 'e':
				case 'E':
				case 'f':
				case 'F':
				case 'g':
				case 'G':
					number = +value;
					prefix = number < 0 ? '-' : positivePrefix;
					method = ['toExponential', 'toFixed', 'toPrecision']['efg'.indexOf(type.toLowerCase())];
					textTransform = ['toString', 'toUpperCase']['eEfFgG'.indexOf(type) % 2];
					value = prefix + Math.abs(number)[method](precision);
					return justify(value, prefix, leftJustify, minWidth, zeroPad)[textTransform]();
				default: return substring;
			}
		};

		return format.replace(regex, doFormat);
	}
	
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	Prototype.setRule = function(selector, styles) {
		var i, x, sheet, rules;

		for (x = document.styleSheets.length - 1; 0 <= x ; x--){
			sheet = document.styleSheets[x];
			rules = sheet.cssRules || sheet.rules;
			
			for (i = rules.length - 1; 0 <= i; i--){
				if (rules[i].selectorText == selector){
					return Object.extend(rules[i].style, styles);
				}
			}
		}
		
		var index = rules.length;
		if (sheet.insertRule){ // Normal browsers
			sheet.insertRule(selector + '{ }', index);
		} else { // IE: if (sheet.addRule){
			sheet.addRule(selector, ';', index);
		}
		
		Object.extend((sheet.cssRules || sheet.rules)[index].style, styles);
	}
	
	Prototype.getRules = function(selector, rules) {
		var retRules = {};
		rules = (typeof rules=='string'?$w(rules):rules);
		$A(rules).each( function(v){ retRules[v]=null});
		
		var i, x, sheet, styleRules;
		
		var reg = new RegExp(selector, 'i');
		
		for (x = document.styleSheets.length - 1; 0 < x ; x--){
			sheet = document.styleSheets[x];
			try
			{
				styleRules = sheet.cssRules || sheet.rules;
			}
			catch( err )
			{
				continue;
			}
			
			for (i = styleRules.length - 1; 0 <= i; i--){
				if( reg.test(styleRules[i].selectorText) )
				{
					$A(rules).each( function (v,k) {
						if( styleRules[i].style[v] )
						{
							retRules[v] = styleRules[i].style[v];
						}
					});
				}
			}
		}
		return retRules;
	}


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	
	String.prototype.ucfirst = function()
	{
		var str = this;
		str += '';
		var f = str.charAt(0).toUpperCase();
		return f + str.substr(1);
	}
	
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	String.prototype.prepend = function( text )
	{
		return text + this;
	}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	
	Array.prototype.shuffle = function()
	{
		for(var j, x, i = this.length; i; j = parseInt(Math.random() * i), x = this[--i], this[i] = this[j], this[j] = x);
		return this;
	};
	
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	
	var ElementDefinitions = {}
	ElementDefinitions.selectChange = function( element, attributeName )
	{
		if( typeof(attributeName) == 'undefined' || !attributeName ){
			attributeName = 'href';
		}
		
		if( element.selectedIndex != null )
		{	
			var selopt = element[element.selectedIndex];
			selopt = $(selopt);
			var selUrl = element.readAttribute(attributeName);
			if( selUrl )
			{
				window.document.location = "".sprintf(selUrl, selopt.readAttribute('value'));
			}
			else
			{
				var url = selopt.readAttribute(attributeName);
				if( url )
				{
					window.document.location = url;
				}
			}
		}
	}

	Object.extend( Object, {
		copyMethods: function( destination, source ) {
			var skipMethods = {selectionStart:1,selectionEnd:1}; // hidden input element hack...
			for (var property in source)
				if( !skipMethods[property] && typeof source[property] == 'function' )
				{
					destination[property] = source[property];
				}
			}
		} );

	ElementDefinitions.clone = (function() {
		var cfn = Element.clone;
		return function(element, deep)
		{
			var r = cfn( element, deep );
			Object.copyMethods(r, element);
			if( (r.onClone = element.onClone) )
			{
				r.onClone.call(r);
			}
			
			if( deep )
			{
				var od = element.select('*');
				var nd = r.select('*');
				i = od.length;
				while (i--) {
					Object.copyMethods(nd[i], od[i]);
					if( (nd[i].onClone = od[i].onClone) )
					{
						nd[i].onClone.call(nd[i])
					}					
				}
			}
			return r;
		}
	})();

	ElementDefinitions.recursiveReplace = function( element, search, replace )
	{
		oid = element.id;
		oname = element.readAttribute('name');
		var nid = null;
		var nname = null;
		if( oid || oname )
		{
			if( oid && oid != (nid = oid.replace( new RegExp(search,'g'), replace)) )
			{
				element.writeAttribute('id', nid);
			}
			
			if( oname && oname != (nname = oname.replace( new RegExp(search,'g'), replace)) )
			{
				element.writeAttribute('name', nname);
			}

			var all = element.select('*');
			var i = all.length;
			while(i--) {
				var vid = String(all[i].id);
				vname = all[i].readAttribute('name');
				if(vid && vid != (nid = vid.replace( new RegExp(search,'g'), replace))) {
					all[i].writeAttribute('id', nid);
				}
				if(vname && vname != (nname = vname.replace( new RegExp(search,'g'), replace))) {
					all[i].writeAttribute('name', nname);
				}
			}
		}
	}
	
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


	ElementDefinitions.scrollFollow = function( element, options )
	{
		element._scrollFollowOptions = Object.extend( {
			duration:0.5,
			transition:Effect.Transitions.sinoidal,
			offset:20,
			_top:(parseInt(element.getStyle('top'))||0),
			dynamic:true
		}, options );

		element._scrollFollow = function( event ) {
			var vpOffset = document.viewport.getScrollOffsets();
			if( !this._scrollFollowOptions.dynamic || !this._scrollFollowOptions.pDims )
			{
				this._scrollFollowOptions.pDims = this.up().getDimensions();
				this._scrollFollowOptions.pOffset = this.up().cumulativeOffset();
				this._scrollFollowOptions.pBorders =  parseInt( this.up().getStyle('borderBottomWidth') ) || 0 + 
								parseInt( this.up().getStyle('borderTopWidth') ) || 0 + 
								parseInt( this.up().getStyle('paddingTop') ) || 0 + 
								parseInt( this.up().getStyle('paddingBottom') ) || 0 +
								parseInt( this.getStyle('marginTop') ) || 0 + 
								parseInt( this.getStyle('marginBottom') ) || 0;
				this._scrollFollowOptions.bDims = this.getDimensions();
			}
			
			var offset = Math.max( 0, vpOffset[1] + (vpOffset[1]?this._scrollFollowOptions.offset:0) - this._scrollFollowOptions.pOffset[1] );
			offset += this._scrollFollowOptions._top;
			offset = Math.min(offset, this._scrollFollowOptions.pDims['height'] - this._scrollFollowOptions.bDims['height'] - this._scrollFollowOptions.pBorders);
			if( parseInt(this.getStyle('top')) != offset )
			{
				this.Morph({style:'top:'+offset+'px',duration:this._scrollFollowOptions.duration,transition:this._scrollFollowOptions.transition}, {clear:true});
			}		
		};
		
		var ps = element.getStyle('position');
		if( ps != 'relative' && ps != 'absolute' )
		{
			element.setStyle({position:'relative'});
		}
		
		Element.observe(window,'scroll', element._scrollFollow.bindAsEventListener(element));
		Element.observe(window,'resize', element._scrollFollow.bindAsEventListener(element));

	}


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	ElementDefinitions.shade2 = function( element, options )
	{
		var opt = Object.extend({left:0, top: 0, blur:2, opacity:.5, color:"black"}, options);
		opt.blur = Math.max(0,opt.blur);

		var clone = element.cloneNode(false);
		var inner = element.replace(clone);
		clone.update(inner);
		element = clone;
		clone = inner;		
		
		clone.setStyle({margin:0,zIndex:2,position:'relative',float:'none'});
		element.setStyle({
			border:0,
			padding:'0px',
			position:'relative',
			background:0,
			overflow:'visible'
		});
		
		if( typeof ElementDefinitions.shade2.shades == 'undefined' )
		{
			ElementDefinitions.shade2.shades = {};
		}
		var pid = Object.toJSON(opt);

		var shadows = ElementDefinitions.shade2.shades[pid];
		if( typeof shadows == 'undefined' )
		{
			shadows = [];
			shadows[0] = new Element('div').setStyle({
				zIndex:0,
				position:'absolute',
				width:'100%',
				height:'100%',
				opacity:0.5 /(opt.blur * 8),
				left:(0+opt.blur)+'px',
				top:(0+opt.blur)+'px',
				backgroundColor:opt.color
			});

			var layers = (8 * opt.blur) + 1;
			for (i = 1; i < layers; i++) {
				shadows[i] = shadows[0].cloneNode(true);
			}

			var i = 1;
			var j = opt.blur;

			while (j > 0) {
				var j2 = j*2;
				shadows[i].setStyle({left: (opt.left)+'px', top: (-j2 + opt.top)+'px'});              //top
				shadows[i + 1].setStyle({left: (j * 2 + opt.left)+'px', top: (opt.top)+'px'});   //right
				shadows[i + 2].setStyle({left: ( + opt.left)+'px', top: (j * 2 + opt.top)+'px'});   //bottom
				shadows[i + 3].setStyle({left: (-j2 + opt.left)+'px', top: (opt.top)+'px'});          //left
				shadows[i + 4].setStyle({left: (j + opt.left)+'px', top: (-j + opt.top)+'px'});       //top-right
				shadows[i + 5].setStyle({left: (j + opt.left)+'px', top: (j + opt.top)+'px'});   //bottom-right
				shadows[i + 6].setStyle({left: (-j + opt.left)+'px', top: (j + opt.top)+'px'});       //bottom-left
				shadows[i + 7].setStyle({left: (-j + opt.left)+'px', top: (-j + opt.top)+'px'});           //top-left

				i += 8;
				j--;
			}
			ElementDefinitions.shade2.shades[pid] = shadows;
		}

		shadows.each( function( shadow ) {
			element.insert({top:shadow.cloneNode(false)});
		});

	}
	
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	
	ElementDefinitions.imageGallery = function(element)
	{
		element.currentImage = 0;
		element.prevImage = function(event)
		{
			var images = this.select(".item");
			images[this.currentImage].setStyle({zIndex:0});
			this.currentImage--;
			if( this.currentImage < 0 )
			{
				this.currentImage = images.length - 1;
			}
			images[this.currentImage].setStyle({zIndex:1});
			this.syncCounter(images.length);
		}
		element.nextImage = function(event)
		{
			var images = this.select(".item");
			images[this.currentImage].setStyle({zIndex:0});
			this.currentImage++;
			this.currentImage %= images.length;
			images[this.currentImage].setStyle({zIndex:1});
			this.syncCounter(images.length);
		}
		element.syncCounter = function( tcount )
		{
			this.select(".buttons span").first().update( "&nbsp;" + (this.currentImage+1) + " av " + tcount + " " );
		}

		var buttons = element.select(".buttons img");
		if( typeof buttons != 'undefined' && buttons.length == 2 )
		{
			buttons[0].observe('click',element.prevImage.bind(element));
			buttons[1].observe('click',element.nextImage.bind(element));
		}
	}
	

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	ElementDefinitions.getStyles = function( element, styles )
	{
		styles = (typeof styles=='string'?$w(styles):styles);
		var retStyles = {};
		var classGet = [];
		styles.each( function(v) {
			retStyles[v] = element.getStyle(v);
			if( !retStyles[v] )
			{
				classGet.push(v);
			}
		}, element);
		
		return Object.extend(retStyles, Prototype.getRules( $w(element.className).invoke('prepend',"\\.").join('|'), classGet ));
	}
	
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	ElementDefinitions.getStyle2 = function( element, style )
	{
		switch(style)
		{
			case 'margin':
			case 'borderWidth':
			case 'padding':
					var pad = element.getStyle(style);
					if( !pad )
					{
						pad = "";
						['-top','-right','-bottom','-left'].each( function( item, index ) {
							pad += (index!=0?' ':'') + element.getStyle(style+item);
						});
						
						return pad;
					}
					var aPad = pad.split(' ');				
					switch(aPad.length)
					{
						case 1:
						{
							pad == 'null'?pad = 0:null;
							return [pad,pad,pad,pad].join(' ');
						}
						case 2:
						{
							return [aPad[0],aPad[1],aPad[0],aPad[1]].join(' ');
						}
						case 3:
						{
							return [aPad[0],aPad[1],aPad[2],aPad[1]].join(' ');
						}
					}
				break;
		}
		return element.getStyle(style);
	}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	
	ElementDefinitions.clickShow = function( element, params )
	{
		element.setStyle({overflow:'hidden'});
		var showEffect = (params && params.show?params.show:'show');
		var hideEffect = (params && params.hide?params.hide:'hide');
		var ordering = (params && params.order?params.order:'auto');
		var elPad = element.getStyle2('padding').replace(/px/g,"").split(' ');
		
		element.insert( new Element('div', {className:'clickShowNavbar',style:'position:absolute;bottom:0px;width:' + element.getWidth() + 'px;' + (elPad.length?(elPad[3]?'margin-left:-'+elPad[3]+'px':''):'')}).update(new Element('ul', {style:'list-style-image:none;list-style-type:none;'})) );
		element.select("img").each( function( item, index ) {
			Object.extend(item,{
					clickShow_insert:function()
					{
						var ctrler = this.up('.clickShow').setStyle({backgroundImage:'none'});
						var ul = element.select(".clickShowNavbar ul").pop();
						var first = ul.empty();
						ul.insert(
							new Element('li', {className:(first?'active':'')}).update(ul.childElements().length+1)
								.observe('click',function(event) {
									var el = event.element();
									el.up('.clickShow').select('img')[el.previousSiblings().length].clickShow_show();
									})
								.observe('mouseover', function(event){event.element().addClassName('hover')} )
								.observe('mouseout', function(event){event.element().removeClassName('hover')})
							);
						ctrler.insert(this.remove());
						this.clickShow_fit();
						if( first )
						{
							this.clickShow_show();
						}
					},
					clickShow_show:function()
					{
						this.adjacent('img').invoke(hideEffect);
						this[showEffect]();
						var li = this.up('.clickShow').select('li')[this.previousSiblings().length-1];
						if( li )
						{
							li.adjacent('li').invoke('removeClassName', 'active');
							li.addClassName('active');
						}
						return this;
					},
					clickShow_next:function()
					{
						var ns = this.next('img');
						if( ns )
						{
							ns.clickShow_show();
						}
						else
						{
							this.adjacent('img').shift().clickShow_show();
						}
						return this;
					},
					clickShow_fit:function()
					{
						var idim = this.getDimensions();
						if( !idim.width || !idim.height )
						{
							return this;
						}
						idim.aspect = idim.width/idim.height;
						
						var cdim = this.up(".clickShow").getDimensions();
						var navbar = this.up(".clickShow").select(".clickShowNavbar")[0];
						var bs = /([0-9]+)px/i.exec(element.getStyle('borderWidth'));
						bs = (bs&&bs[1]?bs[1]:0);
						cdim.height -= navbar.getHeight() + 2*bs + parseInt(elPad[0]) + parseInt(elPad[2]);
						cdim.width -= parseInt(elPad[1]) + parseInt(elPad[3]);
						cdim.aspect = cdim.width/cdim.height;
						
						if( idim.aspect > cdim.aspect )
						{
							this.setStyle({
									width:cdim.width+'px',
									height:Math.round(idim.height/idim.width*cdim.width)+'px',
									top:Math.round((cdim.height - idim.height/idim.width*cdim.width)/2+(Prototype.Browser.IE6||Prototype.Browser.IE7?parseInt(elPad[0]):0))+'px'
								});
						}
						else
						{
							var style = {
									width:Math.round(idim.width/idim.height*cdim.height)+'px',
									height:cdim.height+'px',
									top:(Prototype.Browser.IE6||Prototype.Browser.IE7?parseInt(elPad[0]):0)+'px',
									left:Math.round((cdim.width - idim.width/idim.height*cdim.height)/2+(Prototype.Browser.IE6||Prototype.Browser.IE7?parseInt(elPad[3]):0))+'px'
								};
								
							//alert(Object.toJSON(style));
							this.setStyle(style);

						}
						return this;
					}
				});

				item.setStyle({position:'absolute',cursor:'pointer'});
				item.observe('load', function(event){event.element().clickShow_insert()});
				item.observe('click', function(event){event.element().clickShow_next()});
				item.hide();
				
			});			
	}
	
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	
	ElementDefinitions.observes = function(element, events) {
		$H(events).each( function(pair) {
			element.observe( pair.key, new Function(pair.value) );
		});
		return element;
	}
	
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	
	ElementDefinitions.Morph = function( element, params, queueParams )
	{
		
		if( typeof params == 'string' )
		{
			params = {style:params};
		}
		
		if( queueParams && typeof queueParams.clear != 'undefined' )
		{
			Effect.Queues.get(element.identify()).each( function(effect) {
					effect.cancel();
				});
		}
		
		return new Effect.Morph( element.identify(),Object.extend({queue:Object.extend({position:'end',limit:1,scope:element.identify()}, queueParams)},params) );
	}
	
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	ElementDefinitions.fixPng = function( element )
	{
		var arVersion = navigator.appVersion.split("MSIE");
		var version = parseFloat(arVersion[1]);
		
		if( element )
		{
			if( document.body.filters  )
			{
				if( /\.png/i.match(element.src) && !element.hasClassName('pngFixed') )
				{
					element.setStyle({filter:"progid:DXImageTransform.Microsoft.AlphaImageLoader(src=\"" + element.src + "\", sizingMethod='scale')",display:'inline-block',width:element.getWidth(),height:element.getHeight()});
					element.addClassName('pngFixed');
					if( version < 7 )
					{
						element.src = '';
					}
					else
					{
						//element.src = "http://media.compro.se/common/blank.gif";
					}
				}
				return element;
			}
		}
		try {
			if( (version >= 5.5) && (version <= 7) && (document.body.filters) )
			{
				document.observe("dom:loaded", function() {
						$$('img').invoke('fixPng');
					});
			}
		} catch(e) {}
	};
	
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	ElementDefinitions.playMe = function( event )
	{
		var flashVars = this.readAttribute('flashvars');
		flashVars = (flashVars?flashVars.evalJSON():{});
		var params = this.readAttribute('flashparams');
		params = (params?params.evalJSON():{});
		var dim = this.getDimensions();
		if( flashVars['flv'] )
		{
			swfobject.embedSWF("http://media.compro.se/swf/player_flv_maxi.swf?s="+Math.random(), this.identify(), dim.width , dim.height, "9.0.115", "http://media.compro.se/common/swfobject/expressInstall.swf", flashVars, params);
		}
		else if( flashVars['youtube'] )
		{
			this.update("<object width='" + flashVars['width'] + "px' height='" + flashVars['height'] + "px'><param name='movie' value='http://www.youtube-nocookie.com/v/" + flashVars['youtube'] + "?rel=0" + (flashVars['autoplay']?'&autoplay=1':'') + "'></param><param name='allowFullScreen' value='true'></param><param name='allowscriptaccess' value='always'></param><embed src='http://www.youtube-nocookie.com/v/" + flashVars['youtube'] + "?rel=0" + (flashVars['autoplay']?'&autoplay=1':'') + "' type='application/x-shockwave-flash' allowscriptaccess='always' allowfullscreen='true' width='" + flashVars['width'] + "px' height='" + flashVars['height'] + "px'></embed></object>");
		}
		else if( flashVars['html'] )
		{
			this.update(flashVars['html']);
		}
		
	}
					
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	ElementDefinitions.scrubSlider = function( element )
	{
		element.setStyle({overflow:'hidden'});
		Event.observe(window, 'load', function() {
		
			var maxHeight = 0;
			element.select('.scrubSlider_item').each( function(item)
			{
				var ih = item.getHeight();
				maxHeight = (ih>maxHeight?ih:maxHeight);
			});

			var arrows = "<div class='scrubSlider_arrow' id='leftArrow'><img src=\"/images/arrow_left.png\" /></div>";
				arrows += "<div class='scrubSlider_arrow' id='rightArrow'><img src=\"/images/arrow_right.png\" /></div>";
			element.innerHTML = arrows + element.innerHTML;

			var leftArrow = element.select(".scrubSlider_arrow#leftArrow").first();
			var rightArrow = element.select(".scrubSlider_arrow#rightArrow").first();
			rightArrow.setStyle({left:(element.getWidth() - 51) + "px"});


			[leftArrow, rightArrow].each( function( item ) {
				var tOffset = Math.round((parseInt(element.getHeight()) - parseInt(item.getHeight()))/2) + "px";
				tOffset = '20px';
				item.setStyle({opacity:0.3,top:tOffset,'zoom':1});
				item.select('img').invoke('observe', 'load', function( event ) { 
					this.fixPng();
					});

				item.observe('mouseover', function() {
						this.Morph({style:{opacity:0.8},duration:0.15}, {limit:2});
					});

				item.observe('mouseout', function() {
						if( this._mdownEvent )
						{
							this._mdownEvent.stop();
							this._mdownEvent = null;
							this._click();
						};

						this.Morph({style:{opacity:0.3},duration:0.05}, {clear:true});
					});

				item.observe('mouseup', function() {
						if( this._mdownEvent )
						{
							this._mdownEvent.stop();
							this._mdownEvent = null;
						};
					});
			});

			rightArrow.observe('mousedown', function() {
					var itemContainer = element.select('.scrubSlider_itemContainer').first();
					this._mdownEvent = new PeriodicalExecuter(function(pe) {
							pe.stop();
							pe.frequency = 0.1;
							pe.registerCallback();

							var itemContainer = element.select('.scrubSlider_itemContainer').first();
							var nv = (parseInt(itemContainer.getStyle('marginLeft')) - 50) + "px";
							
							var lchild = itemContainer.select('.scrubSlider_item:last-child').first();
							if( parseInt(lchild.positionedOffset()[0]) - parseInt(lchild.getWidth()) < 0 )
							{
								return;
							}
							
							itemContainer.Morph({style:{marginLeft:nv},duration:0.08,transition:Effect.Transitions.linear});
						}, 0.25);
					});

			rightArrow._click = function(event) {
					var itemContainer = element.select('.scrubSlider_itemContainer').first();
					var currMarginLeft = parseInt(itemContainer.getStyle('marginLeft'));
					
					var lchild = itemContainer.select('.scrubSlider_item:last-child').first();
					if( parseInt(lchild.positionedOffset()[0]) - parseInt(lchild.getWidth()) < 0 )
					{
						return;
					}

					var nv = (currMarginLeft - 100) + "px";
					element.select('.scrubSlider_item').each( function(item)
					{
						if( parseInt(item.positionedOffset()[0]) >= 0 )
						{
							nv = (currMarginLeft - item.getWidth()) + "px";
							throw $break;
						}
					});

					itemContainer.Morph({style:{marginLeft:nv},duration:0.3});
				};

			rightArrow.observe('click', rightArrow._click);

			leftArrow.observe('mousedown', function() {
					var itemContainer = element.select('.scrubSlider_itemContainer').first();

					this._mdownEvent = new PeriodicalExecuter(function(pe) {
							pe.stop();
							pe.frequency = 0.1;
							pe.registerCallback();

							var itemContainer = element.select('.scrubSlider_itemContainer').first();
							var nv = (parseInt(itemContainer.getStyle('marginLeft')) + 50) + "px";
							
							var lchild = itemContainer.select('.scrubSlider_item:first-child').first();
							if( parseInt(lchild.positionedOffset()[0]) - parseInt(lchild.getWidth()) > 0 )
							{
								return;
							}
							
							itemContainer.Morph({style:{marginLeft:nv},duration:0.08,transition:Effect.Transitions.linear});
						}, 0.25);
					});


			leftArrow._click = function(event) {
					var itemContainer = element.select('.scrubSlider_itemContainer').first();
					var currMarginLeft = parseInt(itemContainer.getStyle('marginLeft'));
					
					var lchild = itemContainer.select('.scrubSlider_item:first-child').first();
					if( parseInt(lchild.positionedOffset()[0]) - parseInt(lchild.getWidth()) > 0 )
					{
						return;
					}

					var nv = (currMarginLeft + 100) + "px";
					element.select('.scrubSlider_item').each( function(item)
					{
						var iWidth = parseInt(item.getWidth());
						if( parseInt(item.positionedOffset()[0]) + iWidth >= 0 )
						{
							nv = (currMarginLeft + iWidth) + "px";
							throw $break;
						}
					});
					itemContainer.Morph({style:{marginLeft:nv},duration:0.3});
				};
				leftArrow.observe('click', leftArrow._click);
			
		});

	}
	
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	
	ElementDefinitions.clearForm = function( element, without ) {
		without = without?without instanceof Array?without:[without]:[];
		element.select('input[type=text]','textarea','input[type=hidden]','input[type=password]').reject( Enumerable.include.bind( without ) ).invoke('setValue','');
		element.select('input[type=radio]','input[type=checkbox]').reject( Enumerable.include.bind( without ) ).each( function( el ) {
			el.checked = false;
		});
	}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	ElementDefinitions.autoComplete = function( element, url )
	{
		element.ajaxCache = {};
		element.updateEvent = null;
		element.writeAttribute('autocomplete', 'off');

		element._result = function(result)
		{
			var el = $('autoCompleteList');
			if( !el )
			{
				el = new Element('div', {id:'autoCompleteList',className:'autoCompleteList'});
				this.insert({after:el});
			}
			var pos = this.cumulativeOffset();
			el.setStyle({left:pos[0]+'px', top:(pos[1]+this.getHeight())+'px',display:result.size()?'block':'none'});

			var ul = new Element('ul');
			result.each( function( item ) {
				ul.insert( new Element('li', {value:item}).update(item) );
			});
			el.update(ul);
			var t = this;
			ul.select('li').each( function(li) {
				li.observe('mouseover', function(event) {
					$$('#autoCompleteList li.hover').invoke('removeClassName', 'hover');
					this.addClassName('hover');
				} );
				li.observe('mouseout', li.removeClassName.curry('hover') );
				li.observe('click', function( event ) {
					t.setValue(li.readAttribute('value'));
					t._autoComplete(true);
					var el = $('autoCompleteList');
					el?el.hide():'';
					t.focus();
				});
			});

		};

		element._request = function(url, hideResult) {
			hideResult = hideResult?true:false;
			element.updateEvent = null;

			var val = this.getValue().trim();
			if( val.length == 0 )
			{
				var el = $('autoCompleteList');
				el?el.hide():'';
				return;
			}

			new Ajax.Request(url, {
				method: 'get',
				parameters: 'q=' + val,
				onSuccess: function(transport) {
					try {
						var result = transport.responseText.evalJSON();
						element.ajaxCache[transport.request.parameters['q']] = result;
						if( !hideResult )
						{
							element._result(result);
						}
					}
					catch(err)
					{

					}
				}
			});

		};

		element._autoComplete = function( hideResult ) {
			var val = this.getValue().trim();
			if( val.length == 0 )
			{
				var el = $('autoCompleteList');
				el?el.hide():'';
				return;
			}
			if( typeof element.ajaxCache[val] != 'undefined' )
			{
				window.clearTimeout( element.updateEvent );
				element.updateEvent = null;
				if( !hideResult )
				{
					element._result(element.ajaxCache[val]);
				}
				return;
			}

			if( element.updateEvent )
			{
				window.clearTimeout( element.updateEvent );
			}
			element.updateEvent = element._request.bind(element).delay(0.2, url, hideResult);

		};

		element.observe('keyup', function( event ) {
			switch(event.keyCode)
			{
				case 38:
				{
					var li = $$('#autoCompleteList li.hover').first();
					if( !li )
					{
						li = $$('#autoCompleteList li').last();
						li?li.addClassName('hover'):'';
					}
					else
					{
						var nli = li.previousSiblings().first();
						if( nli )
						{
							$$('#autoCompleteList li.hover').invoke('removeClassName', 'hover');
							nli.addClassName('hover');
						}
						else
						{
							nli = li.nextSiblings().last();
							if( nli )
							{
								$$('#autoCompleteList li.hover').invoke('removeClassName', 'hover');
								nli.addClassName('hover');
							}
						}
					}
					break;
				}
				case 40:
				{
					var li = $$('#autoCompleteList li.hover').first();
					if( !li )
					{
						li = $$('#autoCompleteList li').first();
						li?li.addClassName('hover'):'';
					}
					else
					{
						var nli = li.nextSiblings().first();
						if( nli )
						{
							$$('#autoCompleteList li.hover').invoke('removeClassName', 'hover');
							nli.addClassName('hover');
						}
						else
						{
							nli = li.previousSiblings().last();
							if( nli )
							{
								$$('#autoCompleteList li.hover').invoke('removeClassName', 'hover');
								nli.addClassName('hover');
							}
						}
					}
					break;
				}
				case 13:
				{
					var li = $$('#autoCompleteList li.hover').first();
					if( li )
					{
						this.setValue(li.readAttribute('value'));
						this._autoComplete(true);
						var el = $('autoCompleteList');
						el?el.hide():'';
						this.focus();
						event.stop();
					}
					break;
				}
				default:
				{
					this._autoComplete();
				}
			}

		});

	};
	
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	ElementDefinitions.showZoom = function(element)
	{
		if( !Element.showZoom.zoomEventHandler )
		{
			if( !$('zoomOverlay') )
			{
				$(document.body).insert( new Element('div', {id:'zoomOverlay',
					style:'position: absolute; width: 195px; height: 195px; top: 0; left: 0; border: 1px solid #666666; z-index: 98; display: none; background-image: url(http://media.compro.se/common/ajax-loader.gif); background-repeat: no-repeat; background-position: center center; background-color: #FFFFFF;'
				}).update( new Element('a', {id:'zoomOverlayImage',
					style:'width: 100%; height: 100%; background-image: none; background-repeat: no-repeat; display:block;'
				}) ) );
			}

			Element.showZoom.hideBlock = false;

			Element.showZoom.zoomEventHandler = function( event ) {
				var dims = this.getDimensions();
				var offset = this.cumulativeOffset();
				var x = event.pointerX() - offset[0];
				var y = event.pointerY() - offset[1];
				if( x>=0 && x<=dims.width && y>=0 && y<=dims.height )
				{
					Element.showZoom.hideBlock = true;
					$('zoomOverlay').setStyle({
						display:'block',
						left:(event.pointerX()-98)+'px',
						top:(event.pointerY()-98)+'px'
					});
					var inner = $('zoomOverlay').down();
					var link = this.up('a');
					if( link )
					{
						inner.writeAttribute( 'href', link.readAttribute('href') );
						inner.writeAttribute( 'target', link.readAttribute('target') );
					}
					var bg = inner.getStyle('backgroundImage');
					var newbg = 'url('+this.readAttribute('zoomImage')+')';
					if( newbg != bg )
					{
						inner.setStyle({
							backgroundImage:newbg
						});
					}
					inner.setStyle({
						backgroundPosition:(x/dims.width*100)+'% ' + (y/dims.height*100) + '%'
					});
				}
			};

			Element.showZoom.closeEventHandler = function( event )
			{
				if( Element.showZoom.hideBlock == false )
				{
					$('zoomOverlay').setStyle({display:'none'});
				}
				Element.showZoom.hideBlock = false;
			};

			document.observe('mousemove', Element.showZoom.closeEventHandler);
		}
		document.observe('mousemove', Element.showZoom.zoomEventHandler.bindAsEventListener(element));
	};
	
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	
	Element.addMethods(ElementDefinitions);
	
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	Object.extend(Prototype.Browser, {
			IE6:((document.all && !window.opera && !window.XMLHttpRequest && typeof document.addEventListener != 'function')?true:false),
			IE7:((navigator.appVersion.indexOf("MSIE 7.")==-1)?false:true)
		});
		
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	Object.extend(Date,{
		format:function( format, timestamp ) {
			// Format a local time/date
			//
			// +	discuss at: http://kevin.vanzonneveld.net/techblog/article/javascript_equivalent_for_phps_date/
			// +	   version: 901.1301
			// +   original by: Carlos R. L. Rodrigues (http://www.jsfromhell.com)
			// +	  parts by: Peter-Paul Koch (http://www.quirksmode.org/js/beat.html)
			// +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
			// +   improved by: MeEtc (http://yass.meetcweb.com)
			// +   improved by: Brad Touesnard
			// +   improved by: Tim Wiel
			// +   improved by: Bryan Elliott
			// +   improved by: Brett Zamir
			// +   improved by: David Randall
			// +  prototype.js: Kristoffer Ingemansson
			// *	 example 1: date('H:m:s \\m \\i\\s \\m\\o\\n\\t\\h', 1062402400);
			// *	 returns 1: '09:09:40 m is month'
			// *	 example 2: date('F j, Y, g:i a', 1062462400);
			// *	 returns 2: 'September 2, 2003, 2:26 am'
			// *	 example 3: date('Y W o', 1062462400);
			// *	 returns 3: '2003 36 2003'
			// *	 example 4: x = date('Y m d', (new Date()).getTime()/1000); // 2009 01 09
			// *	 example 4: (x+'').length == 10
			// *	 returns 4: true

			var a, jsdate=(
				(typeof(timestamp) == 'undefined') ? new Date() : // Not provided
				(typeof(timestamp) == 'number') ? new Date(timestamp*1000) : // UNIX timestamp
				new Date(timestamp) // Javascript Date()
			);
			var pad = function(n, c){
				if( (n = n + "").length < c ) {
					return new Array(++c - n.length).join("0") + n;
				} else {
					return n;
				}
			};
			var txt_weekdays = ["S&ouml;ndag","M&aring;ndag","Tisdag","Onsdag",
				"Torsdag","Fredag","L&ouml;rdag"];
			var txt_ordin = {
					1:"a",
					2:"a",
					21:"a",
					22:"a",
					31:"a"
					};
			var txt_months =  ["", "Januari", "Februari", "Mars", "April",
				"Maj", "Juni", "Juli", "Augusti", "September", "Oktober", "November",
				"December"];

			var f = {
				// Day
					d: function(){
						return pad(f.j(), 2);
					},
					D: function(){
						var t = f.l();
						return t.substr(0,3);
					},
					j: function(){
						return jsdate.getDate();
					},
					l: function(){
						return txt_weekdays[f.w()];
					},
					N: function(){
						return f.w() + 1;
					},
					S: function(){
						return txt_ordin[f.j()] ? txt_ordin[f.j()] : 'e';
					},
					w: function(){
						return jsdate.getDay();
					},
					z: function(){
						return (jsdate - new Date(jsdate.getFullYear() + "/1/1")) / 864e5 >> 0;
					},

				// Week
					W: function(){
						var a = f.z(), b = 364 + f.L() - a;
						var nd2, nd = (new Date(jsdate.getFullYear() + "/1/1").getDay() || 7) - 1;

						if(b <= 2 && ((jsdate.getDay() || 7) - 1) <= 2 - b){
							return 1;
						} else{

							if(a <= 2 && nd >= 4 && a >= (6 - nd)){
								nd2 = new Date(jsdate.getFullYear() - 1 + "/12/31");
								return date("W", Math.round(nd2.getTime()/1000));
							} else{
								return (1 + (nd <= 3 ? ((a + nd) / 7) : (a - (7 - nd)) / 7) >> 0);
							}
						}
					},

				// Month
					F: function(){
						return txt_months[f.n()];
					},
					m: function(){
						return pad(f.n(), 2);
					},
					M: function(){
						t = f.F(); return t.substr(0,3);
					},
					n: function(){
						return jsdate.getMonth() + 1;
					},
					t: function(){
						var n;
						if( (n = jsdate.getMonth() + 1) == 2 ){
							return 28 + f.L();
						} else{
							if( n & 1 && n < 8 || !(n & 1) && n > 7 ){
								return 31;
							} else{
								return 30;
							}
						}
					},

				// Year
					L: function(){
						var y = f.Y();
						return (!(y & 3) && (y % 1e2 || !(y % 4e2))) ? 1 : 0;
					},
					o: function(){
						if (f.n() === 12 && f.W() === 1) {
							return jsdate.getFullYear()+1;
						}
						if (f.n() === 1 && f.W() >= 52) {
							return jsdate.getFullYear()-1;
						}
						return jsdate.getFullYear();
					},
					Y: function(){
						return jsdate.getFullYear();
					},
					y: function(){
						return (jsdate.getFullYear() + "").slice(2);
					},

				// Time
					a: function(){
						return jsdate.getHours() > 11 ? "pm" : "am";
					},
					A: function(){
						return f.a().toUpperCase();
					},
					B: function(){
						// peter paul koch:
						var off = (jsdate.getTimezoneOffset() + 60)*60;
						var theSeconds = (jsdate.getHours() * 3600) +
										 (jsdate.getMinutes() * 60) +
										  jsdate.getSeconds() + off;
						var beat = Math.floor(theSeconds/86.4);
						if (beat > 1000) beat -= 1000;
						if (beat < 0) beat += 1000;
						if ((String(beat)).length == 1) beat = "00"+beat;
						if ((String(beat)).length == 2) beat = "0"+beat;
						return beat;
					},
					g: function(){
						return jsdate.getHours() % 12 || 12;
					},
					G: function(){
						return jsdate.getHours();
					},
					h: function(){
						return pad(f.g(), 2);
					},
					H: function(){
						return pad(jsdate.getHours(), 2);
					},
					i: function(){
						return pad(jsdate.getMinutes(), 2);
					},
					s: function(){
						return pad(jsdate.getSeconds(), 2);
					},
					u: function(){
						return pad(jsdate.getMilliseconds()*1000, 6);
					},

				// Timezone
					//e not supported yet
					I: function(){
						var DST = (new Date(jsdate.getFullYear(),6,1,0,0,0));
						DST = DST.getHours()-DST.getUTCHours();
						var ref = jsdate.getHours()-jsdate.getUTCHours();
						return ref != DST ? 1 : 0;
					},
					O: function(){
					   var t = pad(Math.abs(jsdate.getTimezoneOffset()/60*100), 4);
					   if (jsdate.getTimezoneOffset() > 0) t = "-" + t; else t = "+" + t;
					   return t;
					},
					P: function(){
						var O = f.O();
						return (O.substr(0, 3) + ":" + O.substr(3, 2));
					},
					//T not supported yet
					Z: function(){
					   var t = -jsdate.getTimezoneOffset()*60;
					   return t;
					},

				// Full Date/Time
					c: function(){
						return f.Y() + "-" + f.m() + "-" + f.d() + "T" + f.h() + ":" + f.i() + ":" + f.s() + f.P();
					},
					r: function(){
						return f.D()+', '+f.d()+' '+f.M()+' '+f.Y()+' '+f.H()+':'+f.i()+':'+f.s()+' '+f.O();
					},
					U: function(){
						return Math.round(jsdate.getTime()/1000);
					}
			};

			return format.replace(/[\\]?([a-zA-Z])/g, function(t, s){
				if( t!=s ){
					// escaped
					ret = s;
				} else if( f[s] ){
					// a date function exists
					ret = f[s]();
				} else{
					// nothing special
					ret = s;
				}

				return ret;
			});
		}
	});
	
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	
	// Adopted from: http://www.quirksmode.org/js/cookies.html
	var Cookie = {
		create: function(name, value, days) {
			if (days) {
				var date = new Date();
				date.setTime(date.getTime()+(days*24*60*60*1000));
				var expires = "; expires="+date.toGMTString();
			}
			else var expires = "";
			document.cookie = name+"="+value+expires+"; path=/";
		},
		read: function(name) {
			var nameEQ = name + "=";
			var ca = document.cookie.split(';');
			for(var i=0;i < ca.length;i++) {
				var c = ca[i];
				while (c.charAt(0)==' ') c = c.substring(1,c.length);
				if (c.indexOf(nameEQ) == 0) return c.substring(nameEQ.length,c.length);
			}
			return null;
		},
		erase:function(name) {
			Cookie.create(name,"",-1);
		}
	}
	
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	// cookie to detect JS enabled/disabled
	if (!Cookie.read('jsenabled')) {
		Cookie.create('jsenabled', 1, 30);
	}
	
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	document.domloaded = function( fn )
	{	
		if( !document.domloaded.items )
			document.domloaded.items = [];
			
		if( !document.loaded )
			document.domloaded.items.push(fn);
		else
			fn.call();
	}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	document.observe("dom:loaded", 
		function(event) {
		
		/*
			if( Compro_Debug.isDebug() )
			{
				if( (o = $(document.body).appendChild(new Element('OBJECT',{type:'application/x-shockwave-flash'})) ) )
				{
					console.log(o);
					o.remove();
				}
			}
		*/
			$$('input[defValue]').each( function( element ) {
				!element.getValue()?element.setValue(element.readAttribute('defValue')):'';
				element.observe('focus', function() { this.getValue()==this.readAttribute('defValue')?this.setValue(''):''});
				element.observe('blur', function() {!this.getValue()?this.setValue(this.readAttribute('defValue')):''});
				var _form = element.up('form');
				if( _form )
				{
					element.up('form').observe('submit', function(item, event) {item.getValue()==item.readAttribute('defValue')?item.setValue(''):'';}.curry(element));
				}
			});
			
			if( (ftables = $$('table.filterable')) && ftables.length )
			{
				ftables.invoke('insert',{before:"<div class='quickfilter'>Filtrera: <input type='text'/> <a href='#'><img src='http://media.compro.se/common/inputclear.gif' style='vertical-align:middle;margin-bottom:2px;' /></a></div>"});
				$$('div.quickfilter input').each( function( el ) {
					el._keyup = function() {
						var re = new RegExp( this.getValue(), 'i' );
						var tbl = this.up('.quickfilter').next('table.filterable');
						tbl.select("tbody>tr").slice(1).each( function( element ) {
							re.test(
								element.select('td').pluck('innerHTML').join(' ')
							)?element.show():element.hide();
						});
					}
					el.observe('keyup', el._keyup);
				} );

				$$('div.quickfilter a').invoke('observe','click', function( event ) {
					event.stop();
					this.previous().setValue('');
					this.previous()._keyup();
				});
			}

			$$('table.sortable th').each( function( el ) {
				el.setStyle( {cursor:'pointer'} );
				el.observe( 'click', function() {
					var column = this.previousSiblings().length;
					var mod = this.sortorder==1?this.sortorder=-1:this.sortorder=1;


					var tbl = this.up('table');
					var rows = tbl.select('tbody>tr').slice(1).invoke('remove');
					rows.sort(function(a, b) {
						var keyA = a.childElements()[column].innerHTML.toUpperCase();
						var keyB = b.childElements()[column].innerHTML.toUpperCase();
						if (keyA < keyB) return 1*mod;
						if (keyA > keyB) return -1*mod;
						return 0;
					});
					rows.each( Element.insert.curry(tbl.down('tbody')) );
				});
			});

			$$('a.email[name]').each( function( el ) {
				el.writeAttribute('href', 'mailto:' + el.readAttribute ('name').replace('//','@').replace(/\//g,'.'));
				el.update( el.innerHTML.replace(' [at] ', '@').replace(' DOT ', '.') );
			});			
			
			$$('*[shade]').each( function( element ) {
				element.shade2( element.readAttribute('shade').evalJSON() );
			});
			
			$$('[gaevent]').invoke('observe','click', function( event ) {
				var _gadata = this.readAttribute('gaevent').split('|');
				_gadata.unshift('_trackEvent');
				_gadata = _gadata.slice(0,5);
				_gadata[4] = parseInt(_gadata[4]);
				_gaq && _gaq.push( _gadata );
			});
						
			$$('*[autocompleter]').each( function( element ) {
				element.autoComplete( element.readAttribute('autocompleter') );
			});
			
			$$('*[zoomImage]').invoke('showZoom');
			
			Element.observe(window, 'mousemove', function( event ) {
				this.Position.current = [event.pointerX(), event.pointerY()];
			});
			
			
			document.domloaded.items?document.domloaded.items.invoke('call'):'';
			
		}.bindAsEventListener(document)
	);
	document.loaded?document.fire('dom:loaded'):'';
		
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	var Compro_Debug = {
		'isDebug':function() {
			if( /ComproDebug/i.match(navigator.userAgent) )
			{
				return true;
			}
			return false;
		},
		'isSales':function( ip ) {
			var ips = {'192.168.3.57':1,'192.168.3.32':1,'192.168.3.48':1,'192.168.3.55':1,'192.168.3.70':1,'192.168.3.37':1,'192.168.3.41':1,'192.168.3.39':1,'192.168.3.33':1,'192.168.3.56':1,'192.168.3.45':1,'192.168.3.68':1,'192.168.3.50':1,'192.168.3.53':1};
			if( ips[ip] )
			{
				return true;
			}
			return false;
		}
	};

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	
	Compro.FlashMessenger = {
		OK:'flashMessageOK',
		ERROR:'flashMessageERROR',
		INFO:'flashMessageINFO',
		NOTICE:'flashMessageNOTICE',
		HELP:'flashMessageHELP',
		QUESTION:'flashMessageQUESTION',
		WARNING:'flashMessageWARNING',

		TYPE_POPUP:'flashMessagePOPUP',
		TYPE_LIST:'flashMessageLIST',
		TYPE_ALERT:'flashMessageALERT',
		flash:function(message, code, type) {
			code || (code = this.OK);
			type || (type = this.TYPE_LIST);
			if (type == this.TYPE_ALERT) {
				alert(message);
			} else if (type == this.TYPE_LIST) {
				if (container = $('flashMessages-list')) {
					if (!(ul = container.down('ul'))) {
						container.update(ul = new Element('ul'));
					}
					ul.insert(new Element('li', {'class':code}).update(message));
				} else {
					alert(message);
				}
			} else if (type == this.TYPE_POPUP) {
				if (!(container = $('flashMessages-popup'))) {
					$(document.body).insert(container = new Element('div', {id:'flashMessages-popup'}));
				}
				if (!(ul = container.down('ul'))) {
					container.update(ul = new Element('ul'));
				}
				if (!(ok = container.down('input[type=button]'))) {
					container.insert(ok = new Element('input', {type:'button',value:'Stäng'}));
					ok.observe('click', Compro.FlashMessenger.clear.bind(this, Compro.FlashMessenger.TYPE_POPUP));
				}
				ul.insert(new Element('li', {'class':code}).update(message));
				container.show();
				ok.focus();
			}
		},
		clear:function(type) {
			if (!type || type == this.TYPE_LIST) {
				if (container = $('flashMessages-list')) {
					container.update();
				}
			}
			if (!type || type == this.TYPE_POPUP) {
				if (container = $('flashMessages-popup')) {
					if (ul = container.down('ul')) {
						ul.update();
					}
					container.hide();
				}
			}
		}
	}