var _arrCssHistory = new Object();
function loadCssFile(strFile, blnStatic, blnGen)
{
	if(blnGen)
	{
		strFile = 'http://gen:9000/css/web/'+strFile;
	}
	else
	{
		strFile = '/css/web/'+strFile;
	}
	if(typeof _arrCssHistory[strFile] == 'undefined')
	{
		_arrCssHistory[strFile] = 1;
		var Link = $(document.createElement('link'));
		Link.rel  = 'stylesheet';
		Link.href = strFile;
		Link.type = 'text/css';
		var Head = $A(document.getElementsByTagName('head'));
		var intEndPos = Head.length();
		Head[0].appendChild(Link);
	}
	
}


/**
 * Array für Unique IDs für Elemente die keine ID haben
 */
//var __uniqueElementIDs = new Array();

/**
 * Umleiten
 * 
 * @author ssc
 * @param strUrl
 * @return
 */
function redirectLocation(strUrl, blnReload)
{
	if(blnReload === true)
	{
		window.location.href = "";
	}
	
	document.fire('myEvent:showOverlay');
	document.fire('myEvent:stopOverlayListeners');
//	document.fire('myEvent:showLoader');
	window.location.href = strUrl;
}


function checkByClassname(strClassName, newStatus)
{
	var Elements = Main.Body.getElementsByClassName(strClassName);
	var count = Elements.length;
	for(var i = 0; i < count; i++)
	{
		Elements[i].checked = newStatus;
	}
}


/**
 * var_dump Funktion für JS
 *
 * @author	pro (1.0)
 * @param	Mixed	Variable
 * @return	String	Type
 */
function vd(obj)
{
	if(typeof obj == "object")
	{
		alert("Type: "+typeof(obj)+((obj.constructor) ? "\nConstructor: "+obj.constructor : "")+"\nValue: " + obj);
	}
	else
	{
		alert("Type: "+typeof(obj)+"\nValue: "+obj);
	}
}

/**
 * Ermittelt den Wert eines Cookies
 * @author	pro
 * @param	Sring	strName 	Name der Cookievar
 * @return 	String	Wert der Cookies oder False
 */
function getCookie(strName)
{
	var alleCookies = document.cookie;
	var cookieArr 	= alleCookies.split(";");
	var anzCookies 	= cookieArr.length;

	/*
	 * Nach dem gewünschten Cookie Aussschau halten
	 */
	for(var i=0;i<anzCookies;i++)
	{
		var cookie = trim(cookieArr[i].split("=")[0]);
		if(cookie == strName)
		{
			cookieWert = cookieArr[i].split("=");
			return cookieWert[1];
		}
	}	
	return false;
}

if(typeof PortalId == "undefined")
{
	alert("Portal ID nicht verfügbar!");
}

var c1 = 'sbid2'+PortalId;
var c2 = 'sbid';
var c3 = 'sbcookie';

/**
 * Alias für getCookie
 * @author	pro
 */
function gc(strName)
{
	return getCookie(strName);
}

/**
 * Setzt einen Cookie
 * 
 * @author	pro
 * @param	Sring	strName 	Name des Cookies
 * @param	Sring	strValue	Wert des Cookies
 * @param	Integre	intExpires	Gültigkeit
 * @param	String	strPath		Gültigkeit
 * @param	String	strDomain	Domain
 */
function setCookie(strName, strValue, intExpires, strPath)
{
	var cookieData = strName + '=' + escape(strValue) + '; ' + 'path=' + ((strPath == null) ? '/' : strPath) + '; expires=' + ((intExpires == null) ? '0' : intExpires) + ';';
	document.cookie = cookieData;
	return true;
}

/**
 * Alias für setCookie
 * @author	pro
 */
function sc(strName, strValue, intExpires, strPath, strDomain)
{
	return setCookie(strName, strValue, intExpires, strPath, strDomain);
}

/**
 * Falsche md5 Funktion
 * 
 * @author 	pro (1.0)
 * @param	String	strSting
 * @return 	String
 */
function MD5(strSting)
{
	return strSting;
}


/**
 * Erstellt den Cookie und Hashwert für Ajax-Requests, der Name wurde bewusst gewählt
 * 
 * @author	ssc, pro (1.0)
 * @param	
 */
Math.randum = function()
{
	var ci = '';
	var sh = '';

	if(!(ci = parseInt(gc(c2))) || !(sh = gc(c1)))
	{
		return false;
	}
	var g  = 180;
		ci = ci.toString();
	var ch = '';
	var uht = md5(Math.random().toString()) + md5(Math.random().toString());
	var uh = new Array();
	var c = uht.length;
	for(var i = 0; i < c; i++)
	{
		var t = uht.substr(i, 1);
		if(t > -1){ }else
		{
			uh.push(t);
		}
	}
	delete uht;
	uh = uh.join('');

	var e = ci + (ci * (ci % 3));
		e = e.toString();

	var G = 1000;
	var d = new Date();
	var t = d.toGMTString(d.setTime((d.getTime())+(g*G)));

	var r = Math.random().toString();
		r = r.substr(-2, 1);
	while(e.length > 1)
	{
		e = Math.abs(e.length - ci.substr(r, 1)).toString();
	}

	var i = 0;
	var k = 2;
	var x = 32;
	var z = 0;
	while(ch.length < x && z<30)
	{
	 	ch += uh.substr(i,k).toString();
	 	i++;
	 	k += Math.ceil((i/k) * Math.abs(r-e));
	 	k = Math.ceil(x / k);
	 	z++;
	}

	if(sc((c3+'_'+uh), (ch.toString()+'_'+e.toString()+'_'+r.toString()), t))
	{
		return uh;
	}
	else
	{
		return false;
	}
}




function getPageScroll()
{
	var yScroll;

	if (self.pageYOffset)
	{
		yScroll = self.pageYOffset;
	}
	else if (document.documentElement && document.documentElement.scrollTop)
	{
		yScroll = document.documentElement.scrollTop;
	}
	else if (document.body)
	{
		yScroll = document.body.scrollTop;
	}
	return yScroll;
}

/**
 * changeDisplaySelection
 * 
 * @author	pro (1.0)
 * @param 	String  strSelectedElement		Das Element, welches selektiert wurde
 * @param 	String  strClassNameOptions		Klassenname der weiteren Oprtionen, die ausgeblendet werden sollen
 */
function changeDisplaySelection(strSelectedElement, strElement, strClassNameOptions)
{
	strElement 			= $(strElement);
	strSelectedElement 	= $(strSelectedElement);

	var arrElements 	= $A(strElement.getElementsByClassName(strClassNameOptions));
	if(arrElements.length > 0)
	{
		arrElements.each
		(
			function(aElement)
			{
				if(aElement != strSelectedElement && !aElement.hasClassName('hide'))
				{
					new Effect.BlindUp(aElement, 
					{ 
						duration	: 0.5,
						afterFinish	: function()
						{
							aElement.addClassName('hide');
						}.bind(this)
					});
				}	
			}
		);
	}


	if(strSelectedElement.hasClassName('hide'))
	{
		new Effect.BlindDown(strSelectedElement,{ 
			duration	: 0.5,
			afterFinish	: function()
			{
				
			}.bind(this)
		});
		
		strSelectedElement.removeClassName('hide');
	}
}

/**
 * changeMobileMenu
 * 
 * @author	juh (1.0)
 * @param 	String  strSelectedElement		Name (ID) des Menüs, das angezeigt werden soll, wenn "", dann alle verstecken
 * @param 	String  strClassNameOptions		Klassenname der anderen Menüs, die ausgeblendet werden sollen
 */
function changeMobileMenu(strSelectedElement, strClassNameOptions)
{
	if (strSelectedElement == "")
	{
		var arrElements 	= $A(document.getElementsByClassName(strClassNameOptions));
		if(arrElements.length > 0)
		{
			arrElements.each
			(
				function(aElement)
				{
					aElement.addClassName('hide');
				}
			);
		}
	}
	else
	{
		strSelectedElement 	= $(strSelectedElement);
	
		strSelectedElement.removeClassName('hide');
			
		var arrElements 	= $A(document.getElementsByClassName(strClassNameOptions));
		if(arrElements.length > 0)
		{
			arrElements.each
			(
				function(aElement)
				{
					if(aElement != strSelectedElement && !aElement.hasClassName('hide'))
					{
						aElement.addClassName('hide');
					}	
				}
			);
		}
	}
}


/**
 * Ändert die Sichtbarkeit eines Elementes
 * 
 * @author	pro (1.0)
 * @param 	String  	objElement				Element
 * @param 	Boolean	  	blnShow					Muss das Element angezeigt werden
 * @param 	Boolean	  	blnHide					Muss das Element versteckt werden
 * @param   String		strQueId				Que ID
 * @param 	Boolean	  	blnBlindEffect = true 	Aoll der BlindDown-Effekt verwendet werden
 */
function changeDisplay(objElement, blnShow, blnHide, strQueId, blnBlindEffect)
{
	objElement			= $(objElement);
	
	if(!objElement)
	{
		return false;
	}
	
	var fltDuration		= 0.3;
	var blnShow			= blnShow  || false;
	var blnHide			= blnHide  || false;
	var strQueId		= strQueId ? strQueId : $(objElement).identify();
	var blnBlindEffect  = blnBlindEffect === false ? false : true;
	var arrEffects 		= [];

	/*
	 * Wenn ein Element gerade annimiert wird, darf keine erneute Animation ausgeführt werden
	 */
	if(!this._arrRunning)
	{
		this._arrRunning = [];
	}

	if(this._arrRunning[strQueId])
	{
		return false;
	}

	this._arrRunning[strQueId] = true;

	/*
	 * Bugfix für Animation (padding und margin problematik)
	 */
	var objWrapper = $(document.createElement('div'));
	objWrapper.setStyle({
		height: 	objElement.getHeight() + 'px',
		position : 	objElement.getStyle('position')
	});	
	objElement.insert({before: objWrapper});
	objWrapper.appendChild(objElement);

	if(blnShow == true || objElement.hasClassName('hide') && !blnHide)
	{	
		/*
		 * Soll der Blind-Effekt auch ausgeführt werden
		 */
		if(blnBlindEffect)
		{
			arrEffects.push(new Effect.BlindDown(objWrapper,{sync: true}));
		}

		/*
		 * Appear-Effekt einfügen
		 */
		arrEffects.push
		(
			new Effect.Appear(objWrapper, 
			{
				beforeStart: function()
				{
					changeVisibilityFlash(objElement, false);
					
					objWrapper.hide();
					
					objWrapper.removeClassName('hide');
					objElement.removeClassName('hide');

				}.bind(this),
				afterFinish: function()
				{
					changeVisibilityFlash(objElement, true);
					
					objWrapper.insert({before: objElement});
					objWrapper.remove();

					this._arrRunning[strQueId] = false;
				}.bind(this),
				sync: true,
				from: 0.0, 
				to: 1.0
			})
		);		
	}
	else
	{			
		/*
		 * Soll der Blind-Effekt auch ausgeführt werden
		 */
		if(blnBlindEffect)
		{
			arrEffects.push(new Effect.BlindUp(objWrapper,{sync: true}));			
		}
		
		/*
		 * Appear-Effekt einfügen
		 */
		arrEffects.push
		(
			new Effect.Appear(objWrapper, 
			{
				beforeStart: function()
				{
					changeVisibilityFlash(objElement, false);
				},
				afterFinish: function()
				{
					changeVisibilityFlash(objElement, true);
					
					objElement.addClassName('hide');
					
					objWrapper.insert({before: objElement});
					objWrapper.remove();
					
					this._arrRunning[strQueId] = false;
				}.bind(this),
				sync: true,
				from: 1.0, 
				to: 0.0
			})
		);
	}
	
	/*
	 * Effekte ausführen
	 */
	new Effect.Parallel
	(
		arrEffects, 
		{
			duration: fltDuration,
			queue: 
			{ 
				position:  'end',
				scope: strQueId
			}
		}
	);
}


/**
 * Ändert die Sichtbarkeit eines Elementes
 * 
 * @author	pro (1.0)
 * @param 	String  	objElement1				Element1
 * @param 	String  	objElement1				Element2
 * @param 	Boolean	  	blnShow					Muss das 1. Element angezeigt werden
 * @param 	Boolean	  	blnShow					Muss das 2. Element angezeigt werden
 * @param   String		strQueId				Que ID
 * @param 	Boolean	  	blnBlindEffect = true 	Aoll der BlindDown-Effekt verwendet werden
 */
function changeDisplayMulti(objElement1, objElement2, blnShow1, blnShow2, strQueId, blnBlindEffect)
{
	objElement1			= $(objElement1);
	objElement2			= $(objElement2);
	
	var fltDuration		= 0.3;
	var strQueId		= strQueId ? strQueId : objElement1.identify();
	
	/*
	 * Wenn ein Element gerade annimiert wird, darf keine erneute Animation ausgeführt werden
	 */
	if(!this._arrRunning)
	{
		this._arrRunning = [];
	}
	
	if(this._arrRunning[strQueId])
	{
		return false;
	}
	
	this._arrRunning[strQueId] = true;
	
	var blnShow1		= blnShow1  || false;
	var blnShow2		= blnShow2  || false;
	var blnBlindEffect  = blnBlindEffect === false ? false : true;
	var arrEffects 		= [];


	/*
	 * Welche Box muss wirklich eingeblendet werden?
	 */
	if(!objElement1.hasClassName('hide') || blnShow2)
	{
		var objElement 	= objElement2;
		objElement2 	= objElement1;
		objElement1 	= objElement;
	}
	
	/*
	 * Bugfix für Animation (padding und margin problematik)
	 */
	var objWrapper1 = $(document.createElement('div'));
	objWrapper1.addClassName('hide');
	objWrapper1.setStyle({height: objElement1.getHeight() + 'px'});
	objElement1.insert({before: objWrapper1});
	objWrapper1.appendChild(objElement1);
	
	var objWrapper2 = $(document.createElement('div'));
	objElement2.insert({before: objWrapper2});				
	objWrapper2.appendChild(objElement2);

	/*
	 * Appear-Effekte
	 */
	arrEffects.push(new Effect.Appear(objWrapper1, {sync: true, from: 0.0, to: 1.0}));
	arrEffects.push(new Effect.Appear(objWrapper2, {sync: true, from: 1.0, to: 0.0}));
	
	/*
	 * Blind-Effekte
	 */
	if(blnBlindEffect)
	{
		arrEffects.push(new Effect.BlindDown(objWrapper1, {sync: true}));
		arrEffects.push(new Effect.BlindUp(objWrapper2, {sync: true}));
	}
	
	/*
	 * Effekte ausführen
	 */	
	new Effect.Parallel
	(
		arrEffects,
		{
			beforeStart: function()
			{
				changeVisibilityFlash(objElement1, false);
				changeVisibilityFlash(objElement2, false);
				objWrapper1.hide();
				objWrapper1.removeClassName('hide');
				objElement1.removeClassName('hide');				
			}.bind(this),
			afterFinish: function()
			{
				changeVisibilityFlash(objElement1, true);
				changeVisibilityFlash(objElement2, true);
				objElement2.addClassName('hide');
				
				/*
				 * Bugfix für aufheben
				 */
				objWrapper1.insert({before: objElement1});
				objWrapper1.remove();
				objWrapper2.insert({before: objElement2});
				objWrapper2.remove();	
				
				this._arrRunning[strQueId] = false;			
			}.bind(this),
			duration: fltDuration,
			queue: 
			{ 
				position:  'end',
				scope: strQueId
			}
		}
	);
}

/*
 * Ändert die die Sichtbarkeit aller Flash-Elemente innerhalb eine Containers
 * 
 * @author pro (1.0)
 * @param Object		objElement = document	Container
 * @param Boolean		blnDisplay				Sollen die Elemente angezeigt werden
 */
function changeVisibilityFlash(objElement, blnDisplay)
{
	changeVisibility(objElement, ['object', 'embed'], blnDisplay);
	var UploadButton; 
	if(UploadButton = $(objElement).down('.uploadbox'))
	{
		UploadButton.setStyle({visibility: blnDisplay ? 'visible' : 'hidden'});
	}
}

/**
 * Tauscht die Sichtbarkeit bei allen Elementen eines bestimmten Tags aus
 * 
 * @author pro (1.0)
 * @param Object		objElement = document	Container
 * @param Mixed			mixTagNames				Tags String oder Array
 * @param Boolean		blnDisplay				Sollen die Elemente angezeigt werden
 */
function changeVisibility(objElement, mixTagNames, blnDisplay)
{
	var objElement 	= $(objElement) ? $(objElement) : document;
	var mixTagNames = $A(mixTagNames);
	var anzTags  	= mixTagNames.length;
	
	var blnDisplay 	= (blnDisplay === true || blnDisplay === false) ? blnDisplay : null;
	
	
	for(var i=0; i<anzTags; i++)
	{
		var arrObjects 	= objElement.getElementsByTagName(mixTagNames[i]);
		var anzObjects 	= arrObjects.length;
		
		for(var j=0; j<anzObjects; j++)
		{
			$(arrObjects[j]).setStyle({visibility: blnDisplay ? 'visible' : 'hidden'});
		}	
	}
}



/**
 * Ausblenden eines Objekts mit dem Standard-BlindUp und danach entfernen des Elements aus dem DOM
 * 
 * @author ssc (1.0)
 * @param objElement		Zu entfernendes Element
 * @param callbackFunction	Optionale Funktion die nach beendigung des Effekts und dem Entfernen des Elements ausgeführt werden soll
 */
function removeElement(objElement, callbackFunction)
{
	objElement		= $(objElement);
	var fltDuration	= 0.3;
	var strQueId	= $(objElement).identify();

	new Effect.BlindUp(objElement,
	{
		afterFinish: function(objElement, callbackFunction)
		{
			objElement.remove();
			if(typeof callbackFunction != 'undefined')
			{
				callbackFunction();
			}
		}.bind(this, objElement, callbackFunction),
		duration: fltDuration,
		queue: 
		{ 
			position:  'end',
			scope: strQueId
		}
	});
}



/**
 * Scrollt zu einem Element, wenn es aktuell nicht sichtbar ist
 * 
 * @author 	pro (1.0)
 * @param	Object				Element, zu dem gescrollt werden soll
 * @param	Boolean = false		Soll die Überprüfung, ob das Element sichtbar ist ignoriert werden?
 */
function scrollToElement(objElement, blnIgnore)
{
	if($(objElement))
	{
		var arrPosScroll = $(objElement).cumulativeScrollOffset();
		var arrPos 		 = $(objElement).cumulativeOffset();
		var blnIgnore	 = blnIgnore === true ? true : false;
		var arrPageSize	 = getVisiblePagesize();

		if(blnIgnore || arrPos[1] < arrPosScroll[1] || arrPos[1] > (arrPosScroll[1] + arrPageSize[1]))
		{
			Effect.ScrollTo($(objElement), {duration: 0.3, offset: -80});
		}
	}	
}

function setCursorPosition(aInput,startPos,endPos)
{
	aInput = $(aInput);
	
	if(!endPos)
		startPos = 0;
	
	if(!endPos)
		endPos = startPos;
		
	aInput.activate();	
	if(aInput.setSelectionRange) {
		aInput.setSelectionRange(startPos,endPos);
	}else if(aInput.createTextRange){
		var range = aInput.createTextRange();
		range.collapse(true);
		range.moveEnd('character',endPos);
		range.moveStart('character',startPos);
		range.select();
	}
}

//
//function updateSize(element, maxHeight)
//{
//	
//   var adjustedHeight = $(element).clientHeight;
//
//   if (!maxHeight || maxHeight > adjustedHeight )
//   {
//   	alert($(element).scrollHeight);
//      adjustedHeight = Math.max($(element).scrollHeight, adjustedHeight);
//      if ( maxHeight )
//         adjustedHeight = Math.min(maxHeight, adjustedHeight);
//      if ( adjustedHeight > $(element).clientHeight )
//         $(element).style.height = adjustedHeight + "px";
//   }
//
// 
//}
//
//
//var TextAreaResize = Class.create();
//TextAreaResize.prototype = {
//  initialize: function( element, options ) {
//    element = $( element );
//    this.element = element;
//
//    this.options = Object.extend(
//      {},
//      options || {} );
//
//    Event.observe( this.element, 'keyup',
//      this.onKeyUp.bindAsEventListener( this ) );
//    this.onKeyUp();
//  },
//
//  onKeyUp: function() {
//    // We need this variable because "this" changes in the scope of the
//    // function below.
//    var cols = this.element.cols;
//
//    var linecount = 0;
//    $A( this.element.value.split( "\n" ) ).each( function( l ) {
//      // We take long lines into account via the cols divide.
//      linecount += 1 + Math.floor( l.length / cols );
//    } )
//
//    this.element.rows = linecount;
//    
//    
//  }
//}




/**
 * replaceAll Erweiterung für Strings
 * @author	pro (1.0)
 * @param 	String  Find
 * @param 	String  Replace
 * @return 	String
 */
String.prototype.replaceAll = function(find, replace)
{
  var str = this;
  while (str.indexOf(find) > -1)
	{
    str = str.replace(find, replace);
  }
  return str;
};


/**
 * trim
 * @author	pro (1.0)
 * @param 	String
 * @return 	String
 */
function trim(s)
{
  while (s.substring(0,1) == ' ')
	{
    s = s.substring(1,s.length);
  }
  while (s.substring(s.length-1,s.length) == ' ')
  {
    s = s.substring(0,s.length-1);
  }
  return s;
}


/**
 * linebreakWords
 * @author	pro (1.0)
 * @param 	String		Text
 * @return 	Inteher		Anzahl der Zeichen pro Reihe
 */
function linebreakWords(text, rowLength)
{
	var ret = text;
	
	if(text.length > rowLength)
	{
		var words = text.split(" ");
		var count = words.length;
		var anzRowChars = 0;
		var zeile = 0;

		if(count > 0) ret = "";
			
		for(var i=0; i<count; i++)
		{
			var length = words[i].length;
			if(length > rowLength)
			{
				var oldRow = (rowLength-anzRowChars);
				var word_1 = words[i].slice(0,oldRow);
				var word_2 = words[i].slice(oldRow,length);
				
				ret += word_1+"<br />";
				ret += word_2+" ";
				
				anzRowChars = word_2.length + 1;
			}
			else
			{
				if((anzRowChars + length) > rowLength)
				{
					anzRowChars = length;
				}
				else
				{
					anzRowChars += length + 1;
				}				
				ret += words[i]+" ";
			}
		}
	}

	return ret;
}


/**
 * addslashes
 * @author	pro (1.0)
 * @param 	String
 * @return 	String
 */
function addslashes(str)
{
	str=str.replace(/\'/g,'\\\'');
	str=str.replace(/\"/g,'\\"');
	str=str.replace(/\\/g,'\\\\');
	str=str.replace(/\0/g,'\\0');
	return str;
}


/**
 * stripslashes
 * @author	pro (1.0)
 * @param 	String
 * @return 	String
 */
function stripslashes(str)
{
	str=str.replace(/\\'/g,'\'');
	str=str.replace(/\\"/g,'"');
	str=str.replace(/\\\\/g,'\\');
	str=str.replace(/\\0/g,'\0');
	return str;
}

/**
 * Lädt ein Bild vor
 * 
 * @author 	pro (1.0)
 * @param 	String	strImage Pfad des Bildes
  */
function preloadImage(strImage)
{
	document.Preload 	 = new Image();
	document.Preload.src = strImage;
}

/**
 * Minimiert ein Bild
 * 
 * @author	pro (1.0)
 * @param	Object	objElement	Image-Objekt
 * @param	Integer	width		Maximale Breite
 * @param	Integer	height		Maximale Höhe
 */
function resizeImage(objElement, intWidth, intHeight)
{
	objElement = $(objElement);
	
	var aImage = new Image();
	aImage.observe('load', function()
	{
		/*
		 * Werte berechnen und Bild anzeigen
		 */
		var dimImage = {
			width 	: aImage.width,
			height 	: aImage.height
		}
		
		/*
		 * Muss die Größe angepasst werden 
		 */
		if(dimImage.width > intWidth || dimImage.height > intHeight)
		{
			
			/*
			 * Werte setzen
			 */
			if(dimImage.width > dimImage.height)
			{
				var fltFaktor 		= intWidth / dimImage.width;
				objElement.width  	= intWidth;
				objElement.height 	= dimImage.height * fltFaktor;
			}
			else
			{
				var fltFaktor 		= intHeight / dimImage.height;
				objElement.height 	= intHeight;
				objElement.width  	= dimImage.width * fltFaktor;
			}
		}
		/*
		 * Normale größe verwenden
		 */
		else
		{
			objElement.width	=  dimImage.width;
			objElement.height	=  dimImage.height;						
		}
	});
	aImage.src = objElement.src;	
}


/**
 * Ermittelt die tatsächlice Seitengröße
 * @author	pro (1.0)
 * @return 	Array 		ageWidth, pageHeight, windowWidth, windowHeight
 */
function getPageSize()
{	
	var xScroll, yScroll;
	
	if (window.innerHeight && window.scrollMaxY)
	{	
		xScroll = document.body.scrollWidth;
		yScroll = window.innerHeight + window.scrollMaxY;
	}
	else if (document.body.scrollHeight > document.body.offsetHeight)
	{ 
		xScroll = document.body.scrollWidth;
		yScroll = document.body.scrollHeight;
	}
	else
	{ 
		xScroll = document.body.offsetWidth;
		yScroll = document.body.offsetHeight;
	}
	
	var windowWidth, windowHeight;
	if (self.innerHeight)
	{	
		windowWidth = self.innerWidth;
		windowHeight = self.innerHeight;
	}
	else if (document.documentElement && document.documentElement.clientHeight)
	{ 
		windowWidth = document.documentElement.clientWidth;
		windowHeight = document.documentElement.clientHeight;
	}
	else if (document.body)
	{ 
		windowWidth  = document.body.clientWidth;
		windowHeight = document.body.clientHeight;
	}	
	
	if(yScroll < windowHeight)
	{
		pageHeight = windowHeight;
	}
	else
	{ 
		pageHeight = yScroll;
	}

	if(xScroll < windowWidth)
	{	
		pageWidth = windowWidth;
	}
	else
	{
		pageWidth = xScroll;
	}

	return new Array(pageWidth,pageHeight,windowWidth,windowHeight);
}

/**
 * Ermittelt die sichtbare Seitengröße
 * @author	pro (1.0)
 * @return 	Array 		width, height
 */
function getVisiblePagesize()
{
	var width, height;
	
	if (window.innerWidth)
	{
		width 	= window.innerWidth;
		height 	= window.innerHeight;
	}
	else if (window.document.documentElement && window.document.documentElement.clientWidth)
	{
		width 	= window.document.documentElement.clientWidth;
		height 	= window.document.documentElement.clientHeight;
	}
	else
	{
		width 	= body.offsetWidth;
		height 	= body.offsetHeight;
	}
	
	return new Array(width, height);
}


/**
 * Setzt die Höhe und Breite eine Ifames auf dessen Contentbreite und Höhe
 * @author	pro (1.0)
 * @param	Element		Iframe ID oder Objekt
 */
function updateIframeSize(iframe)
{
	iframe = $(iframe);
	var iframePageSize = getIframePageSize(iframe);
	document.getElementsByName(iframe)[0].style.width 	= iframePageSize[0]+"px";
	document.getElementsByName(iframe)[0].style.height 	= iframePageSize[1]+"px";	
} 
 

/**
 * Ermittelt die Dimensionen eine Iframes
 * @author	pro (1.0)
 * @return 	Array 		page width, page height, window width, window height
 */
function getIframePageSize(iframe)
{
	var xScroll, yScroll;
	
	if (window.frames[iframe].window.innerHeight && window.frames[iframe].window.scrollMaxY)
	{	
		xScroll = window.frames[iframe].window.innerWidth +  window.frames[iframe].window.scrollMaxX;
		yScroll = window.frames[iframe].window.innerHeight +  window.frames[iframe].window.scrollMaxY;
	}
	else
	{
		if (window.frames[iframe].document.body.scrollHeight > window.frames[iframe].document.body.offsetHeight)
		{
			yScroll = window.frames[iframe].document.body.scrollHeight;
		}
		else
		{
			yScroll = window.frames[iframe].document.body.offsetHeight;
		}
		
		if (window.frames[iframe].document.body.scrollWidth > window.frames[iframe].document.body.offsetWidth)
		{
			xScroll = window.frames[iframe].document.body.scrollWidth;		
		}
		else
		{
			xScroll = window.frames[iframe].document.body.offsetWidth;
		}
	}
	
	var windowWidth, windowHeight;
	
	if (self.innerHeight)
	{	
		if(window.frames[iframe].document.documentElement.clientWidth)
		{
			windowWidth = window.frames[iframe].document.documentElement.clientWidth; 
		}
		else
		{
			windowWidth = self.innerWidth;
		}
		windowHeight = self.innerHeight;
	}
	else if (window.frames[iframe].document.documentElement && window.frames[iframe].document.documentElement.clientHeight)
	{ 		// Explorer 6 Strict Mode
		windowWidth 	= window.frames[iframe].document.documentElement.clientWidth;
		windowHeight 	= window.frames[iframe].document.documentElement.clientHeight;
	}
	else if (window.frames[iframe].document.body)
	{ 
		windowWidth 	= window.frames[iframe].document.body.clientWidth;
		windowHeight 	= window.frames[iframe].document.body.clientHeight;
	}

	var pageHeight 	= yScroll;
	var pageWidth 	= xScroll;		

	var arrayPageSize = new Array(pageWidth,pageHeight,windowWidth,windowHeight);
	return arrayPageSize;
}


function array_diff (array)
{
	 var arr_dif = [], i = 1, argc = arguments.length, argv = arguments, key, key_c, found=false, cntr=0;
 
    // loop through 1st array
    for ( key in array ){
        // loop over other arrays
        for (i = 1; i< argc; i++){
            // find in the compare array
            found = false;
            for (key_c in argv[i]) {
                if (argv[i][key_c] == array[key]) {
                    found = true;
                    break;
                }
            }
 
            if(!found){
                //arr_dif[key] = array[key];
                arr_dif[cntr] = array[key];
                cntr++;
            }
        }
    }
 
    return arr_dif;
}


Object.extend(Event, (function() {
  return {
    stopObservingNodes: function(element) {
    	element = $(element);
    	
    	var arrChildren = $(element).descendants();
       	//var arrChildren = $A($(element).getElementsByTagName('a'));
    	arrChildren.each(function(objSelect){
    	  
    	  	objSelect.href="javascript:;";
			objSelect.stopObserving();
			
			if(objSelect.onClick)
			{
				objSelect.removeAttribute('onClick');
			}
    	  	
    	  });
    }
  };
})());

Object.extend(Event, Event.Methods);




/**
 *	MyEvent ermöglicht das Erstellen und Auslösen von eigenen Events
 *	@author	pro
 */
var MyEvent = {};
Object.extend(MyEvent, (function() 
{
	var cache = [];
	
	/**
	 *	Gibt alle registrierten Wrapperfunktinen eines Events zurück
	 *	@autor	pro
	 *	@param 	string	eventName 	Name des Events
	 *	@return	array				Array mit allen Wrapern eine Events
	 */
	function getWrappersForEventName(eventName)
	{
		return cache[eventName] = cache[eventName] || [];
	}
	
	/**
	 *	Registriert einen Wrapperfunktion für einen Event
	 *	@autor	pro
	 *	@param 	string		eventName 	Name des Events
	 *	@param	function	handler		Funktion, die ausgeführt werden soll
	 *	@return function				Wrapperfunktion
	 */
	function createWrapper(eventName, handler)
	{
		var wrappers = getWrappersForEventName(eventName);
		
		var wrapper = function(event)
		{
			handler.apply(this,wrapper.arguments);
		};
		
		wrapper.handler = handler;
		wrappers.push(wrapper);
		return wrapper;
	}
	
	/**
	 *	Prüft, ob eine Wrapperfunktion existiert
	 *	@autor	pro
	 *	@param 	string		eventName 	Name des Events
	 *	@param	function	handler		Funktion, die ausgeführt werden soll
	 *	@return boolean					Gefunden / Nicht gefunden
	 */
	function findWrapper(eventName, handler) 
	{
		var wrappers = getWrappersForEventName(eventName);
		return wrappers.find(function(wrapper)
								{
								  return wrapper.handler == handler;
								});
	}
		
	/**
	 *	Löscht eine Wrapperfunktion für einen Event
	 *	@autor	pro
	 *	@param 	string		eventName 	Name des Events
	 *	@param	function	handler		Funktion, die ausgeführt werden soll
	 */
	function destroyWrapper(eventName, handler)
	{
		if(cache[eventName])
		{
			cache[eventName] = cache[eventName].without(findWrapper(eventName, handler));
		}
	}
	
	/**
	 * Löscht alle registrierten Events
	 * @author	pro
	 */
	function destroyCache() {
		for (var eventName in cache)
		{
			cache[eventName] = null;
		}
	}	
	
	return{
		
		/**
		 *  Setzt einen Eventlistener
		 *	@author	pro
		 *	@param 	string 		Name des Events
		 *	@param	function	Funktion, die Aufgerufen werden soll
		 */
		observe : function(eventName, handler)
		{	
			var wrapper = createWrapper(eventName, handler);
			return wrapper;
		},
		
		/**
		 *  Löscht einen Eventlistener
		 *	@author	pro
		 *	@param 	string 		Name des Events
		 *	@param	function	Funktion, die Aufgerufen wird
		 */
		stopObserving : function(eventName, handler)
		{
			return destroyWrapper(eventName, handler);
		},		
				
		/**
		 *  Löst einen Event aus
		 *	@author	pro
		 *	@param 	string 		Name des Events
		 */
		fire : function()
		{		
			var arrArgs = $A(arguments);
			var wrappers = getWrappersForEventName(arrArgs[0])
			if (wrappers) 
			{
				var anzWrappers = wrappers.length;
				for (var i=0; i<anzWrappers; i++)
				{
					var wrapper = wrappers[i];
					if (wrapper != null)
					{
						wrapper.apply(this,arrArgs);		
					}
				}
			}
		}		
	};
})());


/**
 * Unentliches Nachladen neues Contents
 * 
 * @author ssc (1.0)
 */
var PaginationScroll = {

	more : function(objLink, strLink)
	{
		/*
		 * Zielbox ertellen
		 */
		var TargetBox	= $(document.createElement('div'));
			objLink.parentNode.appendChild(TargetBox);

		/*
		 * Alten Link entfernen
		 */
		objLink.parentNode.removeChild(objLink);

		/*
		 * Request abschicken
		 */
		new Ajax.Updater(TargetBox, strLink);
	}

};

/**
 * UTF8-Konverter
 * 
 * @author ssc
 */
var Utf8 = {
		 
	// public method for url encoding
	encode : function (string) {
		string = string.replace(/\r\n/g,"\n");
		var utftext = "";

		for(var n = 0; n < string.length; n++)
		{
			var c = string.charCodeAt(n);
			if(c < 128)
			{
				utftext += String.fromCharCode(c);
			}
			else if((c > 127) && (c < 2048)) {
				utftext += String.fromCharCode((c >> 6) | 192);
				utftext += String.fromCharCode((c & 63) | 128);
			}
			else
			{
				utftext += String.fromCharCode((c >> 12) | 224);
				utftext += String.fromCharCode(((c >> 6) & 63) | 128);
				utftext += String.fromCharCode((c & 63) | 128);
			}
		}
		return utftext;
	},
 
	// public method for url decoding
	decode : function (utftext) {
		var string = "";
		var i = 0;
		var c = c1 = c2 = 0;
 
		while ( i < utftext.length ) {
 
			c = utftext.charCodeAt(i);
 
			if (c < 128) {
				string += String.fromCharCode(c);
				i++;
			}
			else if((c > 191) && (c < 224)) {
				c2 = utftext.charCodeAt(i+1);
				string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
				i += 2;
			}
			else {
				c2 = utftext.charCodeAt(i+1);
				c3 = utftext.charCodeAt(i+2);
				string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
				i += 3;
			}
 
		}
 
		return string;
	}
}