//#############################################################################
// DiaShowHelper
//#############################################################################
var DiaShowHelper = Class.create( );
DiaShowHelper.prototype = {
	initialize: function( strTargetId ) {
		this.strTargetId = strTargetId;
	},
	getTarget: function( ) {
		if(typeof this.objTarget != "object")
			this.objTarget = $(this.strTargetId);
		return this.objTarget;
	},
	next: function( objLink ) {
		var objThumb	= hs.getExpander(objLink).a.parentNode;
		var objSite		= objThumb.parentNode;
		if( this.isLastInSite( objThumb, objSite ) ) {
			var objNeighbourSite = this.getNeighbourSite( objSite, +1 );
			if( objNeighbourSite ) {
				this.swapDisplayElements( objNeighbourSite, objSite );
				hs.next( );
			}
		} else {
			hs.next();
		}
	},
	previous: function( objLink ) {
		var objThumb	= hs.getExpander(objLink).a.parentNode;
		var objSite		= objThumb.parentNode;
		if( this.isFirstInSite( objThumb, objSite ) ) {
			var objNeighbourSite = this.getNeighbourSite( objSite, -1 );
			if( objNeighbourSite ) {
				this.swapDisplayElements( objNeighbourSite, objSite );
				hs.previous( );
			} else {
				// no more pictures...
			}
		} else {
			hs.previous();
		}
	},
	getNeighbourSite: function( objSite, intDirection ) {
		var arrSites = new Array( );
		var objChild;
		for(var i=0,len=objSite.parentNode.childNodes.length;i<len;++i) {
			objChild = $(objSite.parentNode.childNodes[i]);
			if(objChild.hasClassName
			&& objChild.hasClassName("dia_page")
			){
				arrSites.push(objSite.parentNode.childNodes[i]);
			}
		}
		
		var pos = this.getPosOfElementInArray( objSite, arrSites );
		var neighbourIndex = pos+intDirection;
		if( neighbourIndex >= 0 && neighbourIndex < arrSites.length ) {
			return arrSites[neighbourIndex];
		} else {
			return false;
		}
	},
	isFirstInSite: function( objThumb, objSite ) {
		var pos = this.getPosOfElementInArray( objThumb, objSite.childNodes );
		var len = objSite.childNodes.length;
		if( pos !== 0 ) {
			for(--pos;pos>=0;--pos) {
				if( this.isDiaThumb( objSite.childNodes[pos] )) {
					return false;
				}
			}
		}
		return true;
	},
	isLastInSite: function( objThumb, objSite ) {
		var pos = this.getPosOfElementInArray( objThumb, objSite.childNodes );
		var len = objSite.childNodes.length;
		if( pos != len-1 ) {
			for(++pos;pos<len;++pos) {
				if( this.isDiaThumb( objSite.childNodes[pos] )) {
					return false;
				}
			}
		}
		return true;
	},
	getPosOfElementInArray: function( objElement, objArray ) {
		var i=0, len=objArray.length;
		while( i<len && objArray[i] != objElement ){ ++i; }
		return i;
	},
	isDiaThumb: function( obj ) {
		obj = $(obj);
		return true
			&& obj.hasClassName
			&& obj.hasClassName("dia_thumb")
		;
	},
	swapDisplayElements: function( id_show, id_hide ) {
		$(id_show).style.visibility 	= 'visible';
		$(id_show).style.display 		= 'block';
		
		$(id_hide).style.visibility 	= 'hidden';
		$(id_hide).style.display 		= 'none';
	}
}
//#############################################################################
// TabHelper
//#############################################################################
var TabHelper = Class.create( );
TabHelper.prototype = {
	initialize: function( strMenuId, strMenuContent, arrMenuClickCallbacks ) {
		this.objMenu		= $(strMenuId);
		this.objContent		= $(strMenuContent);
		this.arrMenuClicCallbacks = $A(arrMenuClickCallbacks);
		if( this.objMenu && this.objContent ) {
			this.registerHandler( );
		}
	},
	registerHandler: function( ) {
		if( this.objMenu ) {
			var thisRef = this;
			this.objMenu.observe(
				'click',
				function(event){thisRef.menuClick(event)}
			);
		}
	},
	menuClick: function( event ) {
		var target = Event.element( event );
		if( target.nodeName.toLowerCase() != "li" ) target = target.parentNode;
		if( target.nodeName.toLowerCase() == "li"
		&&  target.className != 'noaction'
		) {
			var strTarget = target.id.split("_").pop();
			this.openTab( strTarget );
			if( this.arrMenuClicCallbacks ) {
				this.arrMenuClicCallbacks.each(
					function(callback) {
						callback( strTarget );
					}
				);
			}
		}
	},
	openTab: function( strTabName ) {
		this.activateInArray( $A(this.objMenu.childNodes),    strTabName );
		this.activateInArray( $A(this.objContent.childNodes), strTabName );
		return false;
	},
	activateInArray: function( arrTarget, strPostfix ) {
		var objTarget;
		for(var i=0,len=arrTarget.length;i<len;++i) {
			objTarget = $(arrTarget[i]);
			if( objTarget.id
			&&  objTarget.id.split("_").pop() == strPostfix
			) {
				objTarget.addClassName("active");
			} else if( objTarget.removeClassName ) {
				objTarget.removeClassName("active");
			}
		}
	}
}

//#############################################################################
// ModalitaetenHelper - Modalitaeten Menu in Artikeldetail
//#############################################################################
var ModalitaetenHelper = Class.create( );
ModalitaetenHelper.prototype = {
	initialize: function( strMenuId, strMenuContent, strDia, arrHideDiaFor ) {
		this.objDia			= $(strDia);
		this.arrDiaHides	= $A(arrHideDiaFor);
		
		var thisRef = this;
		var menuClickCallback = function( strTabname ) {
			thisRef.openDia( strTabname );
		};
		this.objTabHelper	= new TabHelper( strMenuId, strMenuContent, [menuClickCallback] );
	},
	openDia: function( strTabName ) {
		if(this.arrDiaHides.indexOf(strTabName)!=-1) {
			this.objDia.hide( );
		} else {
			this.objDia.show( );
		}
	},
	openTab: function( strTabName ) {
		this.objTabHelper.openTab( strTabName );
		this.openDia( strTabName );
		return false;
	}
}



var startDate 	= new Date();
var wocheHead  	= new Object();
var wochenTag	= new Object();
//#####################################################################################################################################
// Wochentags Array fï¿½r jeweilige Sprache
//#####################################################################################################################################
wocheHead[1] 	= new Array('Mo','Di','Mi','Do','Fr','Sa','So');
wocheHead[10] 	= new Array('Mo','Di','Mi','Do','Fr','Sa','So');
wocheHead[11] 	= new Array('Mo','Di','Mi','Do','Fr','Sa','So');

wocheHead[2] 	= new Array('Mon','Tue','Wed','Thu','Fri','Sat','Sun');
wocheHead[9] 	= new Array('Mon','Tue','Wed','Thu','Fri','Sat','Sun');

wochenTag[1]	= new Array('Sonntag','Montag','Dienstag','Mittwoch','Donnerstag','Freitag','Samstag');
wochenTag[10]	= new Array('Sonntag','Montag','Dienstag','Mittwoch','Donnerstag','Freitag','Samstag');
wochenTag[11]	= new Array('Sonntag','Montag','Dienstag','Mittwoch','Donnerstag','Freitag','Samstag');

wochenTag[2]	= new Array('Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday');
wochenTag[9]	= new Array('Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday');

//#####################################################################################################################################
// Kalender Draw Klasse
//#####################################################################################################################################
var cl = {
	datumsbereiche : new Object(),				// Array Datumsbereiche
	tageClass : new Array(32),					// Array mit den einzelnen Tagen (32 da 31 Tage im Monat mï¿½glich sind)
	jahr  : startDate.getFullYear(),			// +
	monat : startDate.getMonth()+1,			
	lngId : 1,
	flgAktuellerMonat : false,
	flgSixWeeks : false,
	intAnzahlTage : 31,
	strKey : 'key',
	overrides : [
		'jahr',
		'monat',
		'lngId',
		'strKey',
		'flgSixWeeks'
	],
	/**
	* @brief Methode zeichnet den Kalender
	*
	* params array {jahr: '2008',monat: '05',...}
	*/
	draw : function (params){
		
		for (var i = 0; i < cl.overrides.length; i++) {
			var name = cl.overrides[i];
			this[name] = params && typeof params[name] != 'undefined' ?
				params[name] : cl[name];
		}
		
		// überprüfung ob es sich um Aktuellen Monat handelt und der Monat nicht Vergangenheit
		//this.checkMonth();

		// Ermitteln der Tage des Monats
		this.getAnzahlTage();
		
		// Tabelle erstellen
		var table = document.createElement('Table');
		
		//thead = this.drawMonthHead();
		//table.appendChild(thead);
		
		// Zeile erstellen fuer die Wochentage
		thead = this.drawWeekHead();
		table.appendChild(thead);
		
		// TableBody erstellen
		var tbody = document.createElement('TBODY');
		
		//leere Wochentage vom Vormonat auffï¿½llen
		var tr	  = document.createElement('tr');
		i = this.drawEmptyDaysByStart(tr);
		
		// Tag auf 1 setzen
		var tag = 1;
		
		// Datumsbereiche durchlaufen 
		this.getTageWithClass();
		
		var zeile = 1;
		
		// Monat zeichnen
		do{
			do{
				// Spalte für einen Tag erstellen
				td = document.createElement('td');
				//td.setAttribute("align","center");
				
				// Spalte eine Klasse zuweisen
				if(typeof this.tageClass[tag] == 'string'){
					//td.setAttribute("class",this.tageClass[tag]);
					td.className = this.tageClass[tag];
				}

				// Id für den Tag und Text 01 ,02, 14 der Spalte zuweisen
				if(tag < 10){
					txt = document.createTextNode('0'+tag);	
					td.setAttribute("id",this.strKey+'_'+this.jahr+''+this.monat+'0'+tag);
				} else {
					txt = document.createTextNode(tag);	
					td.setAttribute("id",this.strKey+'_'+this.jahr+''+this.monat+''+tag);
				}
				td.appendChild(txt);
				
				// Zeile die Spalte Tag hinzufügen
				tr.appendChild(td);
				
				tag++;
				i++;
				
				if(tag > this.intAnzahlTage){
					break;
				}
			// Wochenweise durchlaufen
			}while(i < 8);
			if(tag <= this.intAnzahlTage){
				// Zeile der Woche der Tabelle hinzufügen
				tbody.appendChild(tr);
				i = 1;
				// neue Zeile für neue Woche erstellen
				tr = document.createElement('tr');
				zeile++;
			}
			
		}while(tag <= this.intAnzahlTage);
		
		

		// Tage die noch fehlen in der Woche auffüllen
		this.drawEmptyDaysByEnd(tr,tag);
		tbody.appendChild(tr);
		
		if(this.flgSixWeeks == true && zeile < 6){
			tr = this.drawEmptyRow();
			tbody.appendChild(tr);
		}
		
		table.appendChild(tbody);
		
		//table.setAttribute("class","erentoCalendar");
		table.className = "erentoCalendar";
		table.setAttribute("id",this.strKey+'_'+this.jahr+''+this.monat);

		// Zeiträume zurücksetzen, da diese immer wieder neu übergeben werden mï¿½ssen
		this.resetDatumsBereich();

		return table;
	},
	/**
	* @brief Methode aktualisert den Kalender
	*/
	update : function (params){
		// Parameter setzen
		for (var i = 0; i < cl.overrides.length; i++) {
			var name = cl.overrides[i];
			this[name] = params && typeof params[name] != 'undefined' ?
				params[name] : cl[name];
		}
		
		this.getAnzahlTage();
		
		
		// Tag 1
		var tag = 1;
		
		// Css Klassen der einzelnen Tage ermitteln
		this.getTageWithClass();
		
		
		do{
			if(tag < 10){
				tag = '0'+tag;	
			}
	
			// Spalte ermitteln		
			td = document.getElementById(this.strKey+'_'+this.jahr+''+this.monat+''+tag);
			
			// Css Klasse setzen fuer den Tag
			if(typeof this.tageClass[tag*1] == 'string'){
				//td.setAttribute("class",this.tageClass[tag*1]);
				td.className = this.tageClass[tag*1];
			} else {
				td.removeAttribute("class");
				td.removeAttribute("className");
			}
			tag = tag *1;
			tag++;
		}while(tag <= this.intAnzahlTage);
		
		
		// Zeitraeume zuruecksetzen
		this.resetDatumsBereich();
	},
	drawMonthHead : function (){
		thead 	= document.createElement('thead');
		
		tr 		= document.createElement('tr');
		//tr.setAttribute("class","year");
		tr.className = "year";
		
		th 		= document.createElement('th');
		th.setAttribute("colspan","7");
		
		txt 	= document.createTextNode(MonatsNamen[this.lngId][this.monat*1-1]+' '+this.jahr);	
		
		th.appendChild(txt);
		tr.appendChild(th);
		
		thead.appendChild(tr);

		return thead;

	},
	/**
	* @brief Methode erstellt den Kopf fï¿½r die Wochentage
	*
	* @param HTMLTableRowElement tr
	*/
	drawWeekHead : function (){
		
		thead 	= document.createElement('thead');
		tr 		= document.createElement('tr');
		//tr.setAttribute("class","weekdays");
		tr.className = "weekdays";
		
		// Wochentage anzeigen
		for(var w = 0, l = wocheHead[this.lngId].length; w < l ; ++w){
			
			th = document.createElement('th');
			th.className = "weekday_"+(w+1);
			txt = document.createTextNode(wocheHead[this.lngId][w]);
			th.appendChild(txt);
			tr.appendChild(th);
		}
		
		thead.appendChild(tr);
		
		return thead;
	},
	/**
	* @brief Methode ermittelt die Spalten die am Anfang des Monats noch fehlen fï¿½r eine 7 Tage Woche
	* 	
	* @param HTMLTableRowElement tr
	*/
	drawEmptyDaysByStart : function (tr){
		
		var date = new Date(this.jahr*1,this.monat*1-1,1);
		var intWochentag = date.getDay();

		// leere Wochentage vom Vormonat
		if(intWochentag == 0){
			for(var i = 1; i < 7; i++){
				td = document.createElement('td');
				//td.setAttribute("class","empty");
				td.className = "empty";
				
				tr.appendChild(td);
			}
		} else {
			for(var i = 1; i < intWochentag; i++){
				td = document.createElement('td');
				//td.setAttribute("class","empty");
				td.className = "empty";
				
				tr.appendChild(td);
			}
		}
		return i;
	},	
	/**
	* @brief Methode ermittelt die Spalten die noch fuer eine 7 Tage Woche fehlen im Monat
	* 	
	* @param HTMLTableRowElement tr
	* @param int tag
	*/
	drawEmptyDaysByEnd : function (tr,tag){
		// Wochentage vom Nachmonat
		date = new Date(this.jahr*1,this.monat*1-1,tag-1);
		var intWochentag = date.getDay();

		// leere Wochentage vom Vormonat
		if(intWochentag > 0){
			for(var i = intWochentag; i < 7; ++i){
				td = document.createElement('td');
				//td.setAttribute("class","empty");
				td.className = "empty";
				
				tr.appendChild(td);
			}
		}
	},
	/**
	* @brief Liefert eine komplett leerre Kalenderzeile
	*/
	drawEmptyRow: function( ) {
		tr = document.createElement('tr');
		for(var i=0; i<7; ++i){
			td = document.createElement('td');
			td.className = "empty";
			tr.appendChild(td);
		}
		return tr;
	},
	/**
	* @brief Methode ueberprueft ob das uebergebene Datum nicht in der Vergangenheit liegt
	* und ob sich um den aktuellen Monat handelt
	*/
	checkMonth : function(){
		if(this.jahr <= startDate.getFullYear()){
			if(this.monat*1-1 < startDate.getMonth()){
				this.jahr 	= startDate.getFullYear();
				this.monat	= startDate.getMonth()+1;
			}
		}

		if(this.jahr == startDate.getFullYear() && this.monat*1-1 == startDate.getMonth()){
			this.flgAktuellerMonat = true;
		}
	},
	/**
	* @brief Methode ermittelt die Anzahl der Tage im Monat
	*/
	getAnzahlTage : function(){
		// Tage auf 31 setzen
		this.intAnzahlTage = 31;
	
		// fuer Monat April , Juni , September, November Tage auf 30 setzen
		if (this.monat*1 == 4 || this.monat*1 == 6 || this.monat*1 == 9 ||this.monat*1 == 11)
			this.intAnzahlTage--;
		// Fuer Monat Februar Tage auf 28 setzen
		if (this.monat*1 == 2) {
			this.intAnzahlTage = this.intAnzahlTage - 3;
			// Schaltjahr Tage um 1 erhoehen ausser bei Modulo 100 
			if (this.jahr % 4 == 0)
			this.intAnzahlTage++;
			if (this.jahr % 100 == 0)
			this.intAnzahlTage--;
			if (this.jahr % 400 == 0)
			this.intAnzahlTage++;
		}
	},
	/**
	* @brief ermittelt aus den gesetzten Zeitraeumen den Start und Endzeitpunkt 
	* mit der zugehoerigen CSS Klasse 
	*
	*/
	getTageWithClass : function(){
		// Alle verschiedenen Css Klassen durchlaufen bei den Zeitraeumen
		for(var CssClass in this.datumsbereiche) {
			// Alle definierten Zeitraeume zur Css Klasse durchlaufen 
			// Beispiel Zeitraum('2008-05-01','2008-05-10','s1');Zeitraum('2008-05-11','2008-05-14','s2');Zeitraum('2008-05-15','2008-05-20','s1');
			for(var i = 0, l = this.datumsbereiche[CssClass].length; i < l ; ++i){
				tmp_start = this.datumsbereiche[CssClass][i]['start'].split('-');
				var objDateStart = new Date(tmp_start[0]*1,tmp_start[1]*1-1,tmp_start[2]*1,12);
				
				tmp_ende = this.datumsbereiche[CssClass][i]['end'].split('-');
				var objDateEnd = new Date(tmp_ende[0]*1,tmp_ende[1]*1-1,tmp_ende[2]*1,14);
				
				var flgForce = this.datumsbereiche[CssClass][i]['force'];
				
				// Startzeit und Endzeit sowie Css Klasse an this.getTage uebergeben
				this.getTage(objDateStart.getTime(),objDateEnd.getTime(),CssClass,flgForce);
			}
		}
	},
	getTage : function (startTime,endTime,CssClass,flgForce){
		// Start Zeit Monat
		var objDate		= new Date(this.jahr*1,this.monat*1-1,1);
		var startMonth  = objDate.getTime();
		
		// End Zeit Monat
		var objDate		= new Date(this.jahr*1,this.monat*1-1,this.intAnzahlTage,23,59,0);
		var endMonth  	= objDate.getTime();
		
		
		// den Monat Tageweise durchlaufen 
		do{
			// Zeitraum ueberpruefen, ob dieser im Monat fuellt
			if(startTime >= startMonth && startTime <= endMonth){
				// Date Object erstellen fuer aktuellen Zeitpunkt um den Tag zu ermitteln
				var ObjDate = new Date(startTime);
				// Ist eine Css Klasse dem Tag schon zugeordnet wird das Class Attribute erweitert um die zusaetzliche Klasse
				if(typeof this.tageClass[ObjDate.getDate()] == 'string'){
					if(flgForce == true){
						this.tageClass[ObjDate.getDate()] = CssClass;
					} else {
						if(this.tageClass[ObjDate.getDate()] != CssClass){
							this.tageClass[ObjDate.getDate()] = this.tageClass[ObjDate.getDate()]+"_"+CssClass;
						}
					}
				// Css Klasse setzen fuer den Tag
				} else {
					this.tageClass[ObjDate.getDate()] = CssClass;
				}
			}
			// naechster Tag 
			startTime = startTime + 24 * 60 * 60 * 1000;
			
			// Monat zu Ende Schleife kann abgebrochen werden
			if(startTime > (endMonth + 24 * 60 * 60 * 1000)){
				break;
			}
		// Solange der Zeitraum gesetzt ist 
		}while(startTime <= endTime);
		
	},
	/**
	* @brief Methode setzt einen Datumsbereich fuer den KalenderMonat
	*
	* @param date 	start (ISO)
	* @param date 	end (ISO)
	* @param string class 
	*/
	setDatumsBereich : function(start,end,CssClass,flgForce){
		// Css Klasse noch nicht vorhanden im Array neues Array fuer Css Klasse erstellen
		if(!this.datumsbereiche[CssClass]){
			this.datumsbereiche[CssClass] = new Array();
		}
		
		// aktuelle Laenge des Array's ermitteln
		z = this.datumsbereiche[CssClass].length;
		
		// Zeitraum setzen start - end
		this.datumsbereiche[CssClass][z] 			= new Object();
		this.datumsbereiche[CssClass][z]['start'] 	= start;
		this.datumsbereiche[CssClass][z]['end'] 	= end;
		this.datumsbereiche[CssClass][z]['force'] 	= flgForce;
	},
	/**
	* @brief Methode setzt den zeitraum fuer den Kalender Draw zurueck
	*
	*/
	resetDatumsBereich : function(){
		this.tageClass = new Array(32);
		this.datumsbereiche = new Object();
	}
}

//##############################################################################################################################################
// Kalender Core Klasse
//##############################################################################################################################################
var clCore = new Class.create( );
clCore.prototype = {
	initialize: function() {
		this.arrZeitraum 			= new Array();
		this.arrEventListner		= new Object();
	},
	/**
	* @brief Methode legt einen Zeitraum an
	*
	* @param date start (ISO YYYY-MM-DD)
	* @param date end (ISO YYYY-MM-DD)
	* @param string cssClass
	*/
	setZeitraum : function(start,end,cssClass,flgForce){
			var z = this.arrZeitraum.length;
			this.arrZeitraum[z] = new Array(3);
			this.arrZeitraum[z][0] = start;
			this.arrZeitraum[z][1] = end;
			this.arrZeitraum[z][2] = cssClass;
			this.arrZeitraum[z][3] = flgForce;
	},
	getZeiraumArray : function(){
		return this.arrZeitraum;
	},
	getLastZeitraum : function (){
		return this.arrZeitraum[this.arrZeitraum.length-1];
	},
	/**
	* @brief Methode entfernt den letzten Zeitraum
	* fuer den makierten Zeitraum
	*
	*/
	resetLastZeitraum : function (){
		this.arrZeitraum.pop();	
	},
	/**
	* @brief Methode registriert einen EventHaendler mit CallBack Function 
	* 
	* 
	* @param string cssClass
	* @param string event
	* @param function fn
	*/
	registerEventListner : function(cssClass, event, fn, fn2){
		
	
		if(!this.arrEventListner[cssClass]){
			this.arrEventListner[cssClass] = new Array();
			var z = this.arrEventListner[cssClass].length;
			this.arrEventListner[cssClass][z] = new Object();
			this.arrEventListner[cssClass][z]['event'] = event;
			this.arrEventListner[cssClass][z]['func'] 	= fn;
		} else {
			var z = this.arrEventListner[cssClass].length;
			this.arrEventListner[cssClass][z] = new Object();
			this.arrEventListner[cssClass][z]['event'] = event;
			this.arrEventListner[cssClass][z]['func'] 	= fn;
		}
		
		this.arrEventListner[cssClass][z]['funcse']	= new Array();
		if(arguments.length > 3){
			k = this.arrEventListner[cssClass][z]['funcse'].length;
			for(i = 3, l = arguments.length; i < l;++i){
				this.arrEventListner[cssClass][z]['funcse'][k] = arguments[i];
				k++;
			}
		}
		
	},
	/**
	* @brief Methode registriert einen EventHaendler fuer ein HTML Element
	* 
	* @param obj HTMLObject bsp. Table des Kalender
	* @param string event
	*/
	registerEvent : function (obj,event){
		if(event == 'click'){
	 		Event.observe(obj.id,event,this.getClickElement.bindAsEventListener(this));
		}else if(event == 'mouseover'){
			Event.observe(obj.id,event,this.getOverElement.bindAsEventListener(this));	
		}else if(event == 'mouseout'){
			Event.observe(obj.id,event,this.getOutElement.bindAsEventListener(this));
		}
	},
	/**
	* @brief Methode hoert auf den Event onclick
	*
	*/
	getClickElement : function (event){
		// Tag Element ermitteln
		var elem = Event.findElement(event,'TD');
		
		if(elem != document){
			// Css Klasse ermitteln
			var strClass = elem.className;
		
			if(strClass == ''){
				strClass = null;
			}
			
			// ueberpruefen ob im Attribute Class mehr als eine Klasse defeniert ist
			if(typeof strClass == 'string'){
				if(strClass.indexOf("_") > -1){
					var tmpStrClass = strClass.split("_");
					// erste defenierte Klasse als referenz der Callback Function uebernehmen
					strClass = tmpStrClass[0];
				}
			}
			
			
			// ueberpruefen ob Callback Function definiert ist fuer Element mit Css Klasse 
			if(this.arrEventListner[strClass]){
				for(var i = 0, l = this.arrEventListner[strClass].length; i < l; ++i){
					if(this.arrEventListner[strClass][i]['event'] == 'click'){
						if(this.arrEventListner[strClass][i]['func'] != "" && typeof this.arrEventListner[strClass][i]['func'] == 'function'){
							// Callback function aufrufen
							this.arrEventListner[strClass][i]['func'](elem);
						}
						// Wenn weitere CallBackFunktionen deklariert wurden
						if(this.arrEventListner[strClass][i]['funcse'].length > 0){
							for(f = 0 , k = this.arrEventListner[strClass][i]['funcse'].length; f < k ; ++f){
								eval(this.arrEventListner[strClass][i]['funcse'][f]);
							}
						}
					}	
				}
			}
		}
	},
	/**
	* @brief Methode hoert auf den Event mouseover
	*
	*/
	getOverElement : function (event){
		// Tag Element ermitteln
		var elem = Event.findElement(event,'TD');
		
		if(elem == undefined){ return; }
		
		if (elem != document){
			//alert(elem);
			// Css Klasse ermitteln
			var strClass 		= elem.className;
			var strTmpClass		= '';
		
			if(strClass == ''){
				strClass = null;
			}
		
			// ueberpruefen ob im Attribute Class mehr als eine Klasse defeniert ist
			if(typeof strClass == 'string'){
				if(strClass.indexOf("_") > -1){
					var tmpStrClass = strClass.split("_");
					// defenierte Klasse ohne aktiv als referenz der Callback Function uebernehmen
					for(var i = 0, l = tmpStrClass.length; i < l ; ++i){
						if(tmpStrClass[i] != 'aktiv'){
							strTmpClass += tmpStrClass[i]+'_';
						}
					}
					
					strClass = strTmpClass.substr(0,strTmpClass.length-1);
					
					
					//strClass = tmpStrClass[0];
				}
			}
			// ueberpruefen ob Callback Function definiert ist fuer Element mit Css Klasse 
			if(this.arrEventListner[strClass]){
				for(var i = 0, l = this.arrEventListner[strClass].length; i < l; ++i){
					if(this.arrEventListner[strClass][i]['event'] == 'mouseover'){
						if(this.arrEventListner[strClass][i]['func'] != "" && typeof this.arrEventListner[strClass][i]['func']){
							// Callback function aufrufen
							this.arrEventListner[strClass][i]['func'](elem);
						}
					}			
				}
			}
		}
	},	
	/**
	* @brief Methode hoert auf den Event mouseout
	*
	*/
	getOutElement : function (event){
		// Tag Element ermitteln
		var elem = Event.findElement(event,'TD');
		
		if(elem == undefined){ return; }
		
		if (elem != document){
			// Css Klasse ermitteln
			var strClass 		= elem.className;
			var strTmpClass		= '';
			if(strClass == ''){
				strClass = null;
			}
			
			// ueberpruefen ob im Attribute Class mehr als eine Klasse defeniert ist
			if(typeof strClass == 'string'){
				if(strClass.indexOf("_") > -1){
					var tmpStrClass = strClass.split("_");
					// defenierte Klasse ohne aktiv als referenz der Callback Function uebernehmen
					for(var i = 0, l = tmpStrClass.length; i < l ; ++i){
						if(tmpStrClass[i] != 'aktiv'){
							strTmpClass += tmpStrClass[i]+'_';
						}
					}
					
					strClass = strTmpClass.substr(0,strTmpClass.length-1);
				}
			}
		
			// ueberpruefen ob Callback Function definiert ist fuer Element mit Css Klasse 
			if(this.arrEventListner[strClass]){
				for(var i = 0, l = this.arrEventListner[strClass].length; i < l; ++i){
					// ist fï¿½r die CSS Klasse Event definiert und CallBack Methode registriert
					if(this.arrEventListner[strClass][i]['event'] == 'mouseout'){
						if(this.arrEventListner[strClass][i]['func'] != "" && typeof this.arrEventListner[strClass][i]['func']){
							// Callback function aufrufen
							this.arrEventListner[strClass][i]['func'](elem);
						}
					}			
				}
			}
		}
	},
	/**
	* @brief Methode ruft den Kalender Draw auf um den Kalender zu Zeichnen
	*
	*/
	drawCalendar : function(strKey,monat,jahr,lngId,flgSixWeeks){
		if(this.arrZeitraum.length > 0){
			for(var i = 0 , l = this.arrZeitraum.length; i < l; ++i){
				// Bei Saison wird kein Jahr angegeben deshalb bei zeichnen das Jahr setzen
				if(this.arrZeitraum[i][0].length < 10){
					cl.setDatumsBereich(jahr+'-'+this.arrZeitraum[i][0],jahr+'-'+this.arrZeitraum[i][1],this.arrZeitraum[i][2],this.arrZeitraum[i][3]);	
				} else {
					cl.setDatumsBereich(this.arrZeitraum[i][0],this.arrZeitraum[i][1],this.arrZeitraum[i][2],this.arrZeitraum[i][3]);
				}
			}
		}
		calender = cl.draw({jahr: jahr,monat: monat, lngId: lngId,strKey: strKey,flgSixWeeks: flgSixWeeks});
		return calender;
	},
	/**
	* @brief Methode updatet den Kalender
	*
	*/
	updateCalendar : function(strKey,monat,jahr,lngId){
		for(var i = 0,  l = this.arrZeitraum.length; i < l; ++i){
			// Bei Saison wird kein Jahr angegeben deshalb bei zeichnen das Jahr setzen
			if(this.arrZeitraum[i][0].length < 10){
				cl.setDatumsBereich(jahr+'-'+this.arrZeitraum[i][0],jahr+'-'+this.arrZeitraum[i][1],this.arrZeitraum[i][2],this.arrZeitraum[i][3]);	
			} else {
				cl.setDatumsBereich(this.arrZeitraum[i][0],this.arrZeitraum[i][1],this.arrZeitraum[i][2],this.arrZeitraum[i][3]);
			}
		}
		cl.update({jahr: jahr,monat: monat, lngId: lngId,strKey: strKey});
	}
}

//##############################################################################################################################################
// Kalender Basket
//##############################################################################################################################################
var Basket = {
	updateDate : function(){
		var objDateNow = new Date();
		var tagNow 		= objDateNow.getDate();
		var monatNow 	= objDateNow.getMonth()+1;
		var jahrNow 	= objDateNow.getFullYear();
		var stdNow		= objDateNow.getHours()*1+1;
		
		if(tagNow < 10){
			tagNow = '0'+tagNow;
		}
		
		if(monatNow < 10){
			monatNow = '0'+monatNow;
		}
		
		if(stdNow < 10){
			stdNow = '0'+stdNow;	
		}
		
		strKeyNow = jahrNow+''+monatNow+''+tagNow+''+stdNow;
	
		var day 	= $('from_day').value;
		var month	= $('from_month').value.substr(0,2);
		var year	= $('from_month').value.substr(3,4);
		var hour	= $('from_hour').value.substr(0,2);
		
		var strKeyDateStart = year+''+month+''+day+''+hour;
		
		var day 	= $('to_day').value;
		var month	= $('to_month').value.substr(0,2);
		var year	= $('to_month').value.substr(3,4);
		var hour	= $('to_hour').value.substr(0,2);
		
		var strKeyDateEnde = year+''+month+''+day+''+hour;
		
		
		if(strKeyDateStart*1 < strKeyDateEnde*1 && strKeyDateStart > strKeyNow){
			var arrDate = getDateArrayFromKey(strKeyDateStart);
			showHiddenBoxDate(arrDate,$('from_hour').value,'from');
				
			var arrDate = getDateArrayFromKey(strKeyDateEnde);
			showHiddenBoxDate(arrDate,$('to_hour').value,'to');
		} else {
			resetTextHiddenBoxDate($('to'));
			resetTextHiddenBoxDate($('from'));
		}
	},
	getPriceForBasket : function (strFormName){
	
		if(document.forms[strFormName].from.value != '' && document.forms[strFormName].to.value != ''){
			var params = 'formSend=PriceQuestion&from='+document.forms[strFormName].from.value;
			var params= params + '&to='+document.forms[strFormName].to.value;
			if(document.forms[strFormName]['artikelnummer[]'].length > 1){
				for(var i=0 , l = document.forms[strFormName]['artikelnummer[]'].length;i < l; ++i){
					params  = params + '&artikelnummer[]='+document.forms[strFormName]['artikelnummer[]'][i].value;
					params  = params + '&location[]='+document.forms[strFormName]['location[]'][i].value;
					params  = params + '&anzahl[]='+document.forms[strFormName]['anzahl[]'][i].value;
				}
			}else {
				params  = params + '&artikelnummer[]='+document.forms[strFormName]['artikelnummer[]'].value;
				params  = params + '&location[]='+document.forms[strFormName]['location[]'].value;
				params  = params + '&anzahl[]='+document.forms[strFormName]['anzahl[]'].value;
			}
		
		
			var url 	= strUrlShop+'/price.json';
		
			if(	document.getElementById('block_kalender_infobox') && 
						document.getElementById('warte_bild_kalender_infobox') && 
						document.getElementById('requestDataBody') 
			){
			
				var pos = cumulativeOffset(document.getElementById('requestDataBody'));
				
				var hoehe 	= document.getElementById('requestDataBody').offsetHeight;
				var breite 	= document.getElementById('requestDataBody').offsetWidth;
				
				document.getElementById('block_kalender_infobox').style.top 				= '0px';
				document.getElementById('block_kalender_infobox').style.left 				= '0px';
				
				document.getElementById('block_kalender_infobox').style.width   			= breite+'px';
				document.getElementById('block_kalender_infobox').style.height  			= hoehe+'px';
				
				document.getElementById('warte_bild_kalender_infobox').style.top 			= (hoehe/2-10)+'px';
				document.getElementById('warte_bild_kalender_infobox').style.left 			= (breite/2-10)+'px';
				
				document.getElementById('block_kalender_infobox').style.display 			= 'block';
				document.getElementById('block_kalender_infobox').style.visibility 			= 'visible';
				
				document.getElementById('warte_bild_kalender_infobox').style.display 		= 'block';
				document.getElementById('warte_bild_kalender_infobox').style.visibility 	= 'visible';
				
			}
	
			var objThis = this;
			var myAjax = new Ajax.Request(
			url, 
			{
				method: 'get', 
				parameters: params,
				onComplete: function(transport){
					if(200 == transport.status){
						objThis.setPriceBasket(transport.responseJSON);	
					}
				}
			});
		} else {
			showErrorContainer(strSetDate.unescapeHTML());
		}
	},
	setPriceBasket:function(strJson){

		if(document.getElementById('block_kalender_infobox')){
			document.getElementById('block_kalender_infobox').style.display 			= 'none';
			document.getElementById('block_kalender_infobox').style.visibility 			= 'hidden';
		}
		
		if(document.getElementById('warte_bild_kalender_infobox')){
			document.getElementById('warte_bild_kalender_infobox').style.display 		= 'none';
			document.getElementById('warte_bild_kalender_infobox').style.visibility 	= 'hidden';
		}

	
		if(strJson.message){
			showErrorContainer(strJson.message.unescapeHTML());
			$('from').value = '';
			$('to').value = '';
			
			return;
		}
	
		strError = '';
	
		for(artikelnummer in  strJson.arrPrice){
			strArticle = '';
			if(typeof(strJson.arrPrice[artikelnummer].price) == 'object'){
				arrayElem = $('list_'+artikelnummer).getElementsByClassName('price');
				
				for(var i = 0, l = arrayElem[0].childNodes.length; i < l ; ++i){
					if(arrayElem[0].childNodes[i].className == 'integral'){
						arrayElem[0].childNodes[i].innerHTML = strJson.arrPrice[artikelnummer].price.strIntegral;
					}
					if(arrayElem[0].childNodes[i].className == 'decimal'){
						arrayElem[0].childNodes[i].innerHTML = strJson.arrPrice[artikelnummer].price.strDecimal;
					}
				}
				
				
				arrayElem = $('list_'+artikelnummer).getElementsByClassName('duration');
				for(var i = 0, l = arrayElem.length; i < l ; ++i){
					if(arrayElem[i].className == 'duration'){
						arrayElem[i].innerHTML = strJson.arrPrice[artikelnummer].price.duration.unescapeHTML();		
					}
				}
				
			}else {
				arrElements = $('list_'+artikelnummer).getElementsByClassName('title');
				
				for(var i = 0, l = arrElements.length; i < l ; ++i){
					for(var e = 0 , k = arrElements[i].childNodes.length; e < k ; ++e){
						if(arrElements[i].childNodes[e].nodeName == 'A'){
							strArticle = arrElements[i].childNodes[e].firstChild.nodeValue;
						}
					}
				}
				if(strArticle != ''){
					strError += strArticle.unescapeHTML() + ' - ' + strJson.arrPrice[artikelnummer].message.unescapeHTML() + '<br />';
				}
			}
		}
		
		if(strError != ''){
			$('from').value = '';
			$('to').value = '';
			
			showErrorContainer(strError);
		}
	},
	setBasket : function(artikelnummer,key){
		var url 	= strUrlShop+'/basketSave.json';
		
		var daten 	= 'artikelnummer='+artikelnummer+'&key='+key;
		
		var objThis = this;
		var myAjax = new Ajax.Request(
		url, 
		{
			method: 'get', 
			parameters: daten,
			onComplete: function(transport){
				if(200 == transport.status){
					objThis.setAnzahlBasket(transport.responseJSON,key,artikelnummer);	
				}
			}
		});
	},
	setAnzahlBasket : function(strJson,key,artikelnummer){
		
		if(strJson.anzahlBasket != undefined){
			$('basketIntItems').innerHTML = strJson.anzahlBasket;
			if(key == 'remove'){
				if(document.getElementById('list_'+artikelnummer)){
					elem = document.getElementById('list_'+artikelnummer).parentNode;
					elem.removeChild(document.getElementById('list_'+artikelnummer));
					
					arr = elem.getElementsByClassName('articleLine');
					if(arr.length < 1){
						window.location = strUrlShop;
					}
	
				}
				
			} else {
				if(document.getElementById('basketMessage')) {
					$('basketMessage').style.visibility = 'visible';
					$('basketMessage').style.display 	= 'block';
				}
			}
		} else if (strJson.message != undefined){
			showErrorContainer(strJson.message.unescapeHTML());
		}
	}
}

//##############################################################################################################################################
// Kalender Artikelliste 
//##############################################################################################################################################
var CalenderArticleList = {
	objClCore : new clCore(),
	monat : new Object(),						// Member Variable Monat
	jahr : new Object(),						// Member Variable Jahr
	arrKey : 'list',							// Keys des / der Kalender
	from_datum 	: 'SearchNavi_wann',
	from		: 'from',
	to_datum	: 'to_datum',
	to			: 'to',
	time_from   : '09:00:00',
	time_to     : '09:00:00',
	dauer       : 'SearchNavi_dauer',
	kalender_gif_1 : 'kalender_gif_1',
	kalender_gif_2 : 'kalender_gif_2',
	div_kalender_gif_1_reset : 'deleteDate_list',
	posTop : 0,
	posLeft : 0,
	anz : 1,									// Anzahl der Kalender
	first : 0,									// Member Variable first des Kalenders (start der Markierung)
	second : 0,									// Member Variable first des Kalenders (ende der Markierung)
	lngId : 1,									// Language des Kalenders
	strKeyStartEnde : '',						// Welche Kalender wird gerade angezeigt start oder ende
	strShowDateText : '',
	arrEvents: [
	'click'
	],
	overrides: [
	'from_datum',
	'from',
	'dauer',
	'to_datum',
	'to',
	'time_from',
	'time_to',
	'arrKey',
	'kalender_gif_1',
	'kalender_gif_2',
	'div_kalender_gif_1_reset',
	'posTop',
	'posLeft',
	'lngId'
	],	
	setParameter : function(params){
		for (var i = 0; i < CalenderArticleList.overrides.length; i++) {
			var name = CalenderArticleList.overrides[i];
			this[name] = params && typeof params[name] != 'undefined' ?
				params[name] : CalenderArticleList[name];
		}
	},	
	/**
	* @brief Methode setzt einen Zeitraum fï¿½r den Kalender
	*
	* @param date start (ISO YYYY-MM-DD)
	* @param date end (ISO YYYY-MM-DD)
	* @param string cssClass
	*/
	setZeitraum : function(dateStart,dateEnd,strClass){
		if(dateStart != undefined){
			this.objClCore.setZeitraum(dateStart,dateEnd,strClass,false);	
		}
		
	},
	/**
	* @brief Methode gibt den letzten gesetzten Zeitraum des Core zurï¿½ck
	*
	* @return array (start (ISO),ende (ISO), cssClass)
	*/
	getLastZeitraum : function (){
		return this.objClCore.getLastZeitraum();
	},
	/**
	* @brief Methode erstellt zusï¿½tzlich den Monats Kopf sowie die Eventlistner zum Blï¿½ttern
	* des Kalenders sofern diese noch nicht vorhanden sind
	* zeichnet zu jedem definierten Key einen Kalender
	*
	* @param string monat
	* @param string jahr
	* @param int lngId
	*/
	showCl : function(monat,jahr,lngId){
		if(this.lngId == 0){
			this.lngId = lngId;
		}
		
		
		key = this.arrKey;
		
		// Anzahl der Kalender
		for(var i = 0 ; i < this.anz; ++i){
			
			if(this.jahr[key] == undefined){
				// Div SingleCalendar erstellen
				window['div_single_'+key+'_'+i] = document.createElement('div');
				//window['div_single_'+key+'_'+i].setAttribute("class","erentoCalendarSingle");
				window['div_single_'+key+'_'+i].className = "erentoCalendarSingle";
				
			}
			
			// array (0 => YYYY, 1 => MM, 2 => DD)
			arrMonatJahr = getMonatJahr(monat,jahr,i);
			
			// Calendar zeichnen
			calendar = this.objClCore.drawCalendar(key,arrMonatJahr[0],arrMonatJahr[1],this.lngId);
			
			// Head fuer Calendar erstellen und dem Div fï¿½r einen Calendar hinzufuegen
			createHead(arrMonatJahr[1],arrMonatJahr[0],key,window['div_single_'+key+'_'+i],i,CalenderArticleList);
			
			if(this.jahr[key] != undefined){
				arrMonatJahrOld = getMonatJahr(this.monat,this.jahr,i);
				tmp = window['div_single_'+key+'_'+i].getElementsByTagName('table');
				
				for(var e = 0, p = tmp.length; e < p; ++e){
					window['div_single_'+key+'_'+i].removeChild(tmp[e]);	
				}
				
				//window['div_single_'+key+'_'+i].appendChild(calendar);
				window['div_single_'+key+'_'+i].insertBefore(calendar,document.getElementById("close_"+key));
			}else {
			
			
				// erstellten Calendar dem Div fuer einen Calendar hinzufuegen
				window['div_single_'+key+'_'+i].appendChild(calendar);
				
				// Div Block erentoCalendarSingle hinzufuegen
				document.getElementById('auswahl_kalender_'+key).appendChild(window['div_single_'+key+'_'+i]);
			}
			
			
			// schliessen Div erstellen
			if(this.jahr[key] == undefined){
				this.createFooter(key,window['div_single_'+key+'_'+i]);
				$('close_'+key).onclick 		= new Function("CalenderArticleList.hideDiv('"+key+"');");
				$('deleteDate_'+key).onclick 	= new Function("CalenderArticleList.hideDiv('"+key+"');CalenderArticleList.reset('"+key+"');");
				Event.observe(key+'_next','click',this.getClickNewMonth.bindAsEventListener(this));
				Event.observe(key+'_back','click',this.getClickNewMonth.bindAsEventListener(this));
			}
			
			
			
			// Registrieren der EventListner fï¿½r den neuen Kalender (click,mouseover,...)
			for(var z = 0 ,l = this.arrEvents.length; z < l; ++z){
				
				this.objClCore.registerEvent(calendar,this.arrEvents[z]);
			}
		}
		
		// Jahr Monat und Key als MemberVars setzen
		this.jahr[key] 		= jahr;
		this.monat[key] 	= monat;
		
	},
	createFooter : function(key,htmlObject){
		
		var txt_close 	= document.createTextNode(strClose.unescapeHTML());
		var txt_date 	= document.createTextNode(strReset.unescapeHTML());
		
		var div_close 	= document.createElement('div');
		var div_date 	= document.createElement('div');
		
		div_close.className = "CalendarClose";
		div_date.className = "CalendarDate";
		
		div_close.setAttribute("id","close_"+key);
		div_date.setAttribute("id","deleteDate_"+key);
		
		div_close.appendChild(txt_close);
		div_date.appendChild(txt_date);
		
		htmlObject.appendChild(div_close);
		htmlObject.appendChild(div_date);
	},
	
	/**
	* @brief setzen des inaktiven Zeitraums
	* 
	* @param object inaktiv (JSON String)
	*/
	setInaktivZeitraum : function (inaktiv){
		this.arrInaktiv = getInaktiv(inaktiv);
		
		for(var i = 0,  l= this.arrInaktiv.length; i < l; ++i){
			start 		= this.arrInaktiv[i][0];
			end			= this.arrInaktiv[i][1];
			cssClass	= this.arrInaktiv[i][2];
			flgForce	= this.arrInaktiv[i][3];
			
			this.objClCore.setZeitraum(start,end,cssClass,flgForce);	
		}
	},
	/**
	* @brief Methode setzt eine Callback Function im CalendarCore fï¿½r das Event Click
	* fuer eine CSS Klasse (Bsp. s1 -> Saison 1) 
	*
	* @param string cssClass
	*/
	registerClickListner : function(cssClass,funcName){
		
		me_list_dauer = this;
		
		if(arguments.length > 1){
			me_list_dauer.objClCore.registerEventListner(cssClass, 'click', me_list_dauer.getListClick,arguments[1]);
		}else {
			// Callback Function registrieren
			me_list_dauer.objClCore.registerEventListner(cssClass, 'click', me_list_dauer.getListClick);
		}
		
	},	
	/**
	* @brief Methode wurde als Callback Function registriert 
	* fuer eine CSS Klasse (Bsp. s1 -> Saison 1) 
	*
	* @param string cssClass
	*/
	getListClick : function (elem){
		
		// Klasse ermitteln die das Element hat
		var strClass = elem.className;
		
		if(strClass == ''){
			strClass = null;
		}
		
		// ueberpruefen ob die Css Klasse vom Typ String ist
		if(typeof strClass == 'string'){
			// ueberpruefen ob im Attribute Class des Elements mehr als eine Klasse angegeben wurde
			if(strClass.indexOf("_") > -1){
				// Erste Klasse aus dem Attribute Class des Elements ermitteln
				var tmpStrClass = strClass.split("_");
				strClass = tmpStrClass[0];
			}
		}
		// ist ID beim Element vergeben dann setze Makierung
		if(elem.id != ''){
			var tmp = elem.id.split('_');
			if(is_numeric(tmp[tmp.length-1])){
				if(checkDateInFuture(tmp[tmp.length-1])){
					me_list_dauer.setMarkierung(tmp[tmp.length-1],strClass);
				}
			}
		}
	},
	getClickNewMonth : function(event){
		// Element Button  ermitteln
		elem = Event.findElement(event,'Button');
		
		// Id ermitteln des Elements
		var tmp = elem.id.split('_');
		
		// Richtung in die geblï¿½ttert werden soll ermitteln
		var richtung = tmp[tmp.length-1];
		
		// Aktuelles Jahr ermitteln
		jahr = this.jahr[tmp[tmp.length-2]];
		
		// Monat des neu angezeigten Kalender ermitteln
		if(richtung == 'next'){
			monat = this.monat[tmp[tmp.length-2]]*1+1;
			if(monat < 10){
				monat = '0'+monat;
			}else if(monat > 12){
				monat = '01';
				jahr = jahr*1+1;
			}
			// Kalender neu zeichnen mit den neuen Parametern
			this.showCl(monat,jahr,tmp[tmp.length-2]);
		}
		
		// Monat des neu angezeigten Kalender ermitteln
		if(richtung == 'back'){
			monat = this.monat[tmp[tmp.length-2]]*1-1;
			
			// ueberpruefen ob es sich um den aktuellen Monat
			var objDateNow = new Date();
			var timeNow = objDateNow.getTime();
			
			var objDateCl = new Date(jahr, monat, 1);
			var timeCl = objDateCl.getTime();
			
			if(timeCl > timeNow){
				if(monat < 1){
					monat = '12';
					jahr = jahr*1-1;
				}
				if(monat < 10){
					monat = '0'+monat;
				}
				// Kalender neu zeichnen mit den neuen Parametern
				this.showCl(monat,jahr,tmp[tmp.length-2]);
			}
		}
	},
	/**
	* @brief Methode setzt einen neuen Zeitraum der dann im Kalender als 
	* makiert Sichtbar wird
	* 
	* @param string Key_date
	*/
	setMarkierung : function(strKeyDate,strClass){
		
		// Css Klasse aktiv fuer makiert
		strClass = "aktiv";
		
		// Es wurde schon ein Zeitraum im Kalender makiert diesen vorher zuruecksetzen
		if(this.first > 0){
			this.objClCore.resetLastZeitraum();
		}
		
		if(this.strShowDateText == '' && document.getElementById('strDateShow')){
			this.strShowDateText = document.getElementById('strDateShow').innerHTML;
		}
	
		// Erster Markierungspunkt
		if(this.strKeyStartEnde == 'start'){
			this.first = strKeyDate*1;
			
			var arrDateStart 	= getDateArrayFromKey(this.first);
			
			showTextBoxDate(arrDateStart,this.from_datum,this.lngId);
			
			// Second ermitteln
			var objDateFrom = new Date(arrDateStart[0]*1,arrDateStart[1]*1-1,arrDateStart[2]*1);
			var intTimeFrom = objDateFrom.getTime();
			
			var dauer = document.getElementById(this.dauer).value;
			
			var intTimeTo   = intTimeFrom + ( dauer * 60 * 60 * 1000);
			var objDateTo   = new Date(intTimeTo);
			
			var arrDateEnde = new Array(3);
			arrDateEnde[0]  = objDateTo.getFullYear();
			arrDateEnde[1]  = objDateTo.getMonth()+1;
			arrDateEnde[2]  = objDateTo.getDate();
			
			if(arrDateEnde[1] < 10) {
				arrDateEnde[1] = '0' + arrDateEnde[1];
			}
			
			if(arrDateEnde[2] < 10) {
				arrDateEnde[2] = '0' + arrDateEnde[2];
			}
			
			
			// Zeitraum setzen
			this.setZeitraum(arrDateStart[0]+'-'+arrDateStart[1]+'-'+arrDateStart[2],arrDateEnde[0]+'-'+arrDateEnde[1]+'-'+arrDateEnde[2],strClass);
			
			if(this.div_kalender_gif_1_reset != ''){
				$('deleteDate_list').observe('click',function(){CalenderArticleList.reset();});
			}
			
			
		}
		
		
		
		var key = this.arrKey;
		this.hideDiv(key);
		
		
		// alle Kalender des Moduls updaten
		
		key = this.arrKey;
		for(var i = 0 ; i < this.anz; ++i){
			arrMonatJahr = getMonatJahr(this.monat[key],this.jahr[key],i);
			// Kalender updaten
			this.objClCore.updateCalendar(key,arrMonatJahr[0],arrMonatJahr[1],this.lngId);
		}
		
		
		this.strKeyStartEnde = '';
	},
	/**
	* @brief Methode zeigt den angeforderten Kalender an
	* und zeigt den block_all div an
	*
	* @param string key (key des Kalenders)
	*/
	showDiv : function(key){
		this.strKeyStartEnde = key;
		
		var key_calender = this.arrKey;
		
		document.getElementById('auswahl_kalender_'+key_calender).style.left 	= this.posLeft+'px';
		document.getElementById('auswahl_kalender_'+key_calender).style.top 	= this.posTop+'px';
		
		if(document.getElementById('mehr_suchkriterien')){
			var ua = navigator.userAgent.toLowerCase();
			
			if(ua.indexOf('msie') > -1){
				document.getElementById('auswahl_kalender_'+key_calender).style.left 	=pos[0]-420+'px';
				document.getElementById('auswahl_kalender_'+key_calender).style.top 	=pos[1]-290+'px';
			}
		}
		
		
		document.getElementById('auswahl_kalender_'+key_calender).style.display 	= 'block';
		document.getElementById('auswahl_kalender_'+key_calender).style.visibility 	= 'visible';
		
		
	},
	/**
	* @brief Methode versteckt den Kalender und den Div block_all
	*
	* @param string key (key des Kalenders)
	*/
	hideDiv : function(key){
		document.getElementById('auswahl_kalender_'+key).style.display 		= 'none';
		document.getElementById('auswahl_kalender_'+key).style.visibility 	= 'hidden';
	},
	reset : function(){
		if(this.first > 0){
			this.objClCore.resetLastZeitraum();
		}
		
		this.first = 0;
		this.second = 0;
		
		// alle Kalender des Moduls updaten
		key = this.arrKey;
		for(var i = 0 ; i < this.anz; ++i){
			arrMonatJahr = getMonatJahr(this.monat[key],this.jahr[key],i);
			// Kalender updaten
			this.objClCore.updateCalendar(key,arrMonatJahr[0],arrMonatJahr[1],this.lngId);
		}
		
		if(document.getElementById('strDateShow')){
			document.getElementById('strDateShow').innerHTML = this.strShowDateText;
		}
		
		resetTextHiddenBoxDate(this.from_datum);
	},
	updateZeitraum : function(){
		if(this.first > 0){
			this.strKeyStartEnde = 'start';
			this.setMarkierung(this.first);
		}
	}
}

//##############################################################################################################################################
// Kalender Modul  Detail
//##############################################################################################################################################

var ModulDetail = {
	objClCore 	: new clCore(),					// Core Object 
	arrSeason 	: new Array(),
	arrInaktiv 	: new Array(),
	arrBusy		: new Array(),
	arrAnreise	: new Array(),
	monat : new Object(),						// Member Variable Monat
	jahr : new Object(),						// Member Variable Jahr
	arrKey : new Array('detail'),				// Member Variable Key des Kalenders
	mindest : false,							// MindestZeitraum wurde makiert
	flgStartDate: true,							// Start Datum Standard setzen 7 Tage in der Zukunft ersten beiden freien Tage
	anz : 8,									// Anzahl der Kalender
	first : 0,									// Member Variable first des Kalenders (start der Markierung)
	second : 0,									// Member Variable first des Kalenders (ende der Markierung)
	lngId : 0,									// Language des Kalenders
	fehlerAnzahlPersonen : false,				// Fehler bei Anzahl Personen
	checkBusy : true,
	arrEvents: [
	'click',
	'mouseover',
	'mouseout'
	],											// Callback fuer folgende EventListner registrieren
	overrides : [
	'anz',
	'flgStartDate',
	'checkBusy',
	],
	setParameter : function(params){
		for (var i = 0; i < ModulDetail.overrides.length; i++) {
			var name = ModulDetail.overrides[i];
			this[name] = params && typeof params[name] != 'undefined' ?
				params[name] : ModulDetail[name];
		}
		
	},	
	/**
	* @brief Methode setzt einen Zeitraum fuer den Kalender
	*
	* @param date start (ISO YYYY-MM-DD)
	* @param date end (ISO YYYY-MM-DD)
	* @param string cssClass
	*/
	setZeitraum : function(dateStart,dateEnd,strClass,flgForce){
		
		if (dateStart != undefined && (flgForce == true || flgForce == false)) {
			this.objClCore.setZeitraum(dateStart,dateEnd,strClass,flgForce);	
		}else if(dateStart != undefined && flgForce == undefined){
			this.objClCore.setZeitraum(dateStart,dateEnd,strClass,false);	
		}
		
	},
	/**
	* @brief Methode gibt den letzten gesetzten Zeitraum des Core zurueck
	*
	* @return array (start (ISO),ende (ISO), cssClass)
	*/
	getLastZeitraum : function (){
		return this.objClCore.getLastZeitraum();
	},
	/**
	* @brief Methode erstellt zusätzlich den Monats Kopf sowie die Eventlistner zum Blaettern
	* des Kalenders sofern diese noch nicht vorhanden sind
	* zeichnet zu jedem definierten Key einen Kalender
	*
	* @param string monat
	* @param string jahr
	* @param int lngId
	*/
	showCl : function(monat,jahr,lngId){
		
		if(this.lngId == 0){
			this.lngId = lngId;
		}
		
		for(var k = 0, p = this.arrKey.length; k < p; ++k){
			key = this.arrKey[k];
			var container = document.getElementById('kalender_hidden_'+key);
			for(var i=container.childNodes.length-1;i>=0;--i) {
				container.removeChild(container.childNodes[i]);
			}
			
			var vorhanden = false;
			
			// Anzahl der Kalender
			for(var i = 0 ; i < this.anz; ++i){
				vorhanden = false;
			
				if(window['div_single_'+key+'_'+i] === undefined){
					// Div SingleCalendar erstellen
					window['div_single_'+key+'_'+i] = document.createElement('div');
					//window['div_single_'+key+'_'+i].setAttribute("class","erentoCalendarSingle");
					window['div_single_'+key+'_'+i].className = "erentoCalendarSingle";
					
					// array (0 => YYYY, 1 => MM, 2 => DD)
					arrMonatJahr = getMonatJahr(monat,jahr,i);
					
					// Calendar zeichnen
					calendar = this.objClCore.drawCalendar(key,arrMonatJahr[0],arrMonatJahr[1],this.lngId,true);
					
					// Head fuer Calendar erstellen und dem Div fuer einen Calendar hinzufï¿½gen
					this.createHead(arrMonatJahr[1],arrMonatJahr[0],key,window['div_single_'+key+'_'+i],i);
					
					// erstellten Calendar dem Div fuer einen Calendar hinzufï¿½gen
					window['div_single_'+key+'_'+i].appendChild(calendar);
				} else {
					vorhanden = true;
				}
				
				// Div Block erentoCalendarSingle hinzufuegen
				document.getElementById('kalender_hidden_'+key).appendChild(window['div_single_'+key+'_'+i]);
				
				
				
				if(vorhanden == false){
					// Registrieren der EventListner fuer den neuen Kalender (click,mouseover,...)
					for(var z = 0 , l = this.arrEvents.length; z < l ; ++z){
						
						this.objClCore.registerEvent(calendar,this.arrEvents[z]);
					}
				}
			}
			
			// Jahr Monat und Key als MemberVars setzen
			this.jahr[key] 		= jahr;
			this.monat[key] 	= monat;
		}
		
		if(this.flgStartDate == true && this.first == 0){
			this.makiereBeiStart();
		}
	},
	/**
	* @brief Methode erstellt den Kopf des Kalenders
	*
	* @param int 		lngId
	* @param int 		jahr
	* @param string 	monat
	* @param string 	key     	   // Kalender Key
	* @param object 	htmlObject     
	*/
	createHead : function(jahr,monat,key,htmlObject,i){
		
		
		// Monat und Jahr fuer Head erstellen
		strMonth = getMonthHead(monat);
		
		// Head erstellen fuer Kalender Monat Jahr
		window['div_jahr_monat_'+key+'_'+i] = document.createElement('div');
		window['div_jahr_monat_'+key+'_'+i].className = "year";
			
		txt = document.createTextNode(strMonth+" "+jahr);
		
		window['div_jahr_monat_'+key+'_'+i].appendChild(txt);
		
		// Float Left loeschen
		div_clear_both = document.createElement('div');
		div_clear_both.className = "clear_both";
		
		
		div = document.createElement('div');
		
		// sofern Head noch nicht vorhanden 
		div.appendChild(window['div_jahr_monat_'+key+'_'+i]);
		div.appendChild(div_clear_both);
		
		
		htmlObject.appendChild(div);
	},
	/**
	* Methode setzt die Season Zeitrï¿½ume
	*
	* @param object season (JSON object)
	*/ 
	setSeasonZeitraum : function (season){
		
		this.arrSeason = getSeason(season);
		
		for(var i = 0, l = this.arrSeason.length; i < l; ++i){
			start 		= this.arrSeason[i][0];
			end			= this.arrSeason[i][1];
			cssClass	= this.arrSeason[i][2];
			flgForce	= this.arrSeason[i][3];
			this.objClCore.setZeitraum(start,end,cssClass,flgForce);	
		}
		
	},
	/**
	* Methode setzt die belegten Zeitrï¿½ume
	*
	* @param object busy (JSON object)
	*/ 
	setBelegtenZeitraum : function(busy){
		this.arrBusy = getBusyDays(busy);
		
		
		for(var i = 0 , l = this.arrBusy.length; i < l; ++i){
			start 		= this.arrBusy[i][0];
			end			= this.arrBusy[i][1];
			cssClass	= this.arrBusy[i][2];
			flgForce	= this.arrBusy[i][3];
			this.objClCore.setZeitraum(start,end,cssClass,flgForce);	
		}
	},
	/**
	* Methode setzt die Anreise Zeitrï¿½ume
	*
	* @param object busy (JSON object)
	*/ 
	setAnreiseZeitraum : function(anreise){
		this.arrAnreise = getAnreiseDays(anreise);
	
		for(var i = 0 , l = this.arrAnreise.length; i < l; ++i){
			start 		= this.arrAnreise[i][0];
			end			= this.arrAnreise[i][1];
			cssClass	= this.arrAnreise[i][2];
			flgForce	= this.arrAnreise[i][3];
			this.objClCore.setZeitraum(start,end,cssClass,flgForce);	
		}
	},
	/**
	* Methode setzt einen inaktiven Zeitraum
	*
	* @param object inaktiv (JSON object)
	*/ 
	setInaktivZeitraum : function (inaktiv){
		this.arrInaktiv = getInaktiv(inaktiv);
		
		for(var i = 0 , l = this.arrInaktiv.length; i < l; ++i){
			start 		= this.arrInaktiv[i][0];
			end			= this.arrInaktiv[i][1];
			cssClass	= this.arrInaktiv[i][2];
			flgForce	= this.arrInaktiv[i][3];
			this.objClCore.setZeitraum(start,end,cssClass,flgForce);	
		}
	},
	/**
	* Methode setzt einen MindestMietzeitraum
	*
	* @param object mindest (JSON object)
	*/ 
	setMindestZeitraum : function (mindest){
		this.arrMindest = getMindest(mindest);
		
		for(var i = 0 , l = this.arrMindest.length; i < l; ++i){
			start 		= this.arrMindest[i][0];
			end			= this.arrMindest[i][1];
			cssClass	= this.arrMindest[i][2];
			period		= this.arrMindest[i][3];
		}
	},
	
	/**
	* @brief Methode setzt eine Callback Function im CalendarCore fuer das Event Click
	* fuer eine CSS Klasse (Bsp. s1 -> Saison 1) 
	*
	* @param string cssClass
	*/
	registerClickListner : function(cssClass){
		//alert(cssClass);
	
		me_detail = this;
		// Callback Function registrieren
		me_detail.objClCore.registerEventListner(cssClass, 'click', me_detail.getDetailClick);
	},
	/**
	* @brief Methode setzt eine Callback Function im CalendarCore fuer das Event mouseover
	* fuer eine CSS Klasse (Bsp. s1 -> Saison 1) 
	*
	* @param string cssClass
	*/
	registerMouseOverListner : function(cssClass){
		//alert(cssClass);
	
		me_detail = this;
		// Callback Function registrieren
		me_detail.objClCore.registerEventListner(cssClass, 'mouseover', me_detail.getDetailMouseOver);
	},
	/**
	* @brief Methode setzt eine Callback Function im CalendarCore fuer das Event mouseout
	* fuer eine CSS Klasse (Bsp. s1 -> Saison 1) 
	*
	* @param string cssClass
	*/
	registerMouseOutListner : function(cssClass){
		//alert(cssClass);
	
		me_detail = this;
		// Callback Function registrieren
		me_detail.objClCore.registerEventListner(cssClass, 'mouseout', me_detail.getDetailMouseOut);
	},
	/**
	* @brief Methode wurde als Callback Function registriert 
	* fuer eine CSS Klasse (Bsp. s1 -> Saison 1) 
	*
	* @param string cssClass
	*/
	getDetailClick : function (elem){
	
		// Klasse ermitteln die das Element hat
		var strClass = elem.className;
		
		if(strClass ==''){
			strClass = null;
		}
		
		// ueberpruefen ob die Css Klasse vom Typ String ist
		if(typeof strClass == 'string'){
			// ueberpruefen ob im Attribute Class des Elements mehr als eine Klasse angegeben wurde
			if(strClass.indexOf("_") > -1){
				// Erste Klasse aus dem Attribute Class des Elements ermitteln
				var tmpStrClass = strClass.split("_");
				strClass = tmpStrClass[0];
			}
		}
		// ist ID beim Element vergeben dann setze Makierung
		if(elem.id != ''){
			var tmp = elem.id.split('_');
			if(is_numeric(tmp[tmp.length-1])){
				if(checkDateInFuture(tmp[tmp.length-1])){
					me_detail.setMarkierung(tmp[tmp.length-1],strClass);
				}
			}
		}
	},
	/**
	* @brief Methode wurde als Callback Function registriert 
	* fuer eine CSS Klasse (Bsp. s1 -> Saison 1) 
	*
	* @param string cssClass
	*/
	getDetailMouseOver : function (elem){
		// Klasse ermitteln die das Element hat
		var strClass = elem.className;
		
		if(strClass ==''){
			strClass = null;
		}
		
		// ueberpruefen ob die Css Klasse vom Typ String ist
		if(typeof strClass == 'string'){
			// ueberpruefen ob im Attribute Class des Elements mehr als eine Klasse angegeben wurde
			if(strClass.indexOf("_") > -1){
				// Erste Klasse aus dem Attribute Class des Elements ermitteln
				var tmpStrClass = strClass.split("_");
				strClass = '';
				for(var i = 0, l = tmpStrClass.length; i < l; ++i){
					if(tmpStrClass[i] != 'aktiv'){
						strClass+= tmpStrClass[i]+'_';
					}
				}
				
				strClass = strClass.substr(0,strClass.length-1);
				//strClass = tmpStrClass[0];
			}
		}
			
		// ist ID beim Element vergeben dann setze Makierung
		if(elem.id != ''){
			var tmp = elem.id.split('_');
			if(is_numeric(tmp[tmp.length-1])){
				if(checkDateInFuture(tmp[tmp.length-1])){
					Tooltip.showToolTip(strClass);
				}
			}
		}
		
	},
	/**
	* @brief Methode wurde als Callback Function registriert 
	* fuer eine CSS Klasse (Bsp. s1 -> Saison 1) 
	*
	* @param string cssClass
	*/
	getDetailMouseOut : function (elem){
		Tooltip.hideTooltip();
	},
	/**
	* @brief Methode setzt einen neuen Zeitraum der dann im Kalender als 
	* makiert Sichtbar wird
	* 
	* @param string Key_date
	*/
	setMarkierung : function(strKeyDate,strClass){
		
		// Css Klasse aktiv fuer makiert
		strClass = "aktiv";
		
		// Es wurde schon ein Zeitraum im Kalender makiert diesen vorher zurï¿½cksetzen
		if(this.first > 0){
		
			this.objClCore.resetLastZeitraum();
			if(this.mindest === true){
				this.objClCore.resetLastZeitraum();
				this.mindest = false;
			}
		}
	
		
	
		// Erster Markierungspunkt
		if(this.first == 0 || this.second != 0){
			this.second = 0;
			this.first = strKeyDate*1;
			
			var arrDate = getDateArrayFromKey(this.first);
			this.setZeitraum(arrDate[0]+'-'+arrDate[1]+'-'+arrDate[2],arrDate[0]+'-'+arrDate[1]+'-'+arrDate[2],strClass,false);

			var arrDateFromEnde = false;
			
			
			
			// MindestZeitraum ermitteln wenn angegeben
			if(this.arrMindest != undefined && this.second == 0){
				arrDateFromEnde = getMindestMietzeitraumMakierung(this.arrMindest,this.first,this.second);
				//alert(arrDateFromEnde);
				if(arrDateFromEnde != false){
					this.setZeitraum(arrDateFromEnde[0][0]+'-'+arrDateFromEnde[0][1]+'-'+arrDateFromEnde[0][2],arrDateFromEnde[1][0]+'-'+arrDateFromEnde[1][1]+'-'+arrDateFromEnde[1][2],'inaktiv',true);
					this.mindest = true;
				}
			}
			resetTextHiddenBoxDate($('to'));
			
			
			if(document.getElementById('from_hour')){
				showHiddenBoxDate(arrDate,$('from_hour').value,'from');
	
				// SelectBox Day
				showSelectBoxDateDay(arrDate,$('from_day'));
					
				// SelectBox Month
				showSelectBoxDateMonth(arrDate,$('from_month'));
				
			}else if(document.getElementById('bookingslot_durations')){
				
				showHiddenBoxDate(arrDate,'09:00:00','from');
			}
			
			
		// Zweiter Markierungspunkt
		}else if(this.first > 0){
			this.second = strKeyDate*1;
			if(this.first > this.second){
				var tmp 	= this.second;
				this.second = this.first;
				this.first	= tmp;
			}
			
			var arrDateStart 	= getDateArrayFromKey(this.first);
			var arrDateEnd 		= getDateArrayFromKey(this.second);
			
			// MindestZeitraum ermitteln wenn angegeben
			if(this.arrMindest != undefined && this.second > 0){
				arrDateFromEnde = getMindestMietzeitraumMakierung(this.arrMindest,this.first,this.second);
				//alert(arrDateFromEnde);
				if(arrDateFromEnde != false && this.second <= (arrDateFromEnde[1][0]+''+arrDateFromEnde[1][1]+''+arrDateFromEnde[1][2])*1){
					this.setZeitraum(arrDateStart[0]+'-'+arrDateStart[1]+'-'+arrDateStart[2],arrDateStart[0]+'-'+arrDateStart[1]+'-'+arrDateStart[2],strClass,false);
					this.setZeitraum(arrDateFromEnde[0][0]+'-'+arrDateFromEnde[0][1]+'-'+arrDateFromEnde[0][2],arrDateFromEnde[1][0]+'-'+arrDateFromEnde[1][1]+'-'+arrDateFromEnde[1][2],'inaktiv',true);
					this.second = 0;
					this.mindest = true;
					
				}
				
			}
			
			if(this.mindest != true){
				if(document.getElementById('from_hour')){
					// Hidden Field From
					showHiddenBoxDate(arrDateStart,$('from_hour').value,'from');
					
					// SelectBox Day FROM
					showSelectBoxDateDay(arrDateStart,$('from_day'));
					
					// SelectBox Month From 
					showSelectBoxDateMonth(arrDateStart,$('from_month'));
					
					// Hidden Field To
					showHiddenBoxDate(arrDateEnd,$('to_hour').value,'to');

					// SelectBox Day To
					showSelectBoxDateDay(arrDateEnd,$('to_day'));
					
					// SelectBox Month To
					showSelectBoxDateMonth(arrDateEnd,$('to_month'));
			
					this.setZeitraum(arrDateStart[0]+'-'+arrDateStart[1]+'-'+arrDateStart[2],arrDateEnd[0]+'-'+arrDateEnd[1]+'-'+arrDateEnd[2],strClass,false);
				
				}else if(document.getElementById('bookingslot_durations')){
					showHiddenBoxDate(arrDateEnd,'09:00:00','to');
					
					this.setZeitraum(arrDateStart[0]+'-'+arrDateStart[1]+'-'+arrDateStart[2],arrDateEnd[0]+'-'+arrDateEnd[1]+'-'+arrDateEnd[2],strClass,false);
				}
			}

		}
		
		
		
		// alle Kalender des Moduls updaten
		for(var k = 0 , p = this.arrKey.length;  k < p; ++k){
			key = this.arrKey[k];
			for(var i = 0 ; i < this.anz; ++i){
				arrMonatJahr = getMonatJahr(this.monat[key],this.jahr[key],i);
				// Kalender updaten
				this.objClCore.updateCalendar(key,arrMonatJahr[0],arrMonatJahr[1],this.lngId);
			}
		}
		
		var fehler = false;
		
		// ueberpruefen ob Zeitraum nicht belegt
		if(checkForBusy(ModulDetail) == false && this.checkBusy == true){
			this.first 	= 0;
			this.second = 0;
			this.objClCore.resetLastZeitraum();
			alert(strNotAviable.unescapeHTML());
			
			for(var z = 0, l = this.arrKey.length; z < l; ++z){
				key = this.arrKey[z];
				for(var q = 0 , r = this.anz; q < r; ++q){
					arrMonatJahr = getMonatJahr(this.monat[key],this.jahr[key],q);
					// Kalender updaten
					this.objClCore.updateCalendar(key,arrMonatJahr[0],arrMonatJahr[1],this.lngId);
				}
			}
			
			resetTextHiddenBoxDate($('to'));
			resetTextHiddenBoxDate($('from'));
			
			fehler = true;
		}
		
		if(fehler != true && this.first > 0 && this.second > 0){
			this.ermittlePreis();
		}
	},
	updateDate : function(){
		if(this.first > 0){
			this.objClCore.resetLastZeitraum();
		}
		this.first = 0;
		this.second = 0;
		
		var fehlerMindest = false;
		
		var objDateNow = new Date();
		var tagNow 		= objDateNow.getDate();
		var monatNow 	= objDateNow.getMonth()+1;
		var jahrNow 	= objDateNow.getFullYear();
		var stdNow		= objDateNow.getHours()*1+1;
		
		if(tagNow < 10){
			tagNow = '0'+tagNow;
		}
		
		if(monatNow < 10){
			monatNow = '0'+monatNow;
		}
		
		if(stdNow < 10){
			stdNow = '0'+stdNow;	
		}
		
		strKeyNow = jahrNow+''+monatNow+''+tagNow+''+stdNow;
	
		var day 	= $('from_day').value;
		var month	= $('from_month').value.substr(0,2);
		var year	= $('from_month').value.substr(3,4);
		var hour	= $('from_hour').value.substr(0,2);
		
		var strKeyDateStart = year+''+month+''+day+''+hour;
		
		var day 	= $('to_day').value;
		var month	= $('to_month').value.substr(0,2);
		var year	= $('to_month').value.substr(3,4);
		var hour	= $('to_hour').value.substr(0,2);
		
		var strKeyDateEnde = year+''+month+''+day+''+hour;
		
		
		if(strKeyDateStart*1 <= strKeyNow*1 || strKeyDateEnde*1 <  strKeyNow*1 || strKeyDateStart*1 >= strKeyDateEnde*1){
			resetTextHiddenBoxDate($('to'));
			resetTextHiddenBoxDate($('from'));
			
			if(this.first > 0 || this.second > 0){
				this.objClCore.resetLastZeitraum();
				this.first = 0;
				this.second = 0;
			}
			
			if(document.getElementById('preisanzeige_preis')){
				$('preisanzeige_preis').innerHTML = '- - -';
				$('preisanzeige_dauer').innerHTML = '';
			}
			return;
		}
		
		if(this.arrMindest != undefined){
			strKeyDateStart = strKeyDateStart.substr(0,8);
			strKeyDateEnde	= strKeyDateEnde.substr(0,8);
			arrDateFromEnde = getMindestMietzeitraumMakierung(this.arrMindest,strKeyDateStart,strKeyDateStart);
			if(arrDateFromEnde != false){
				if(strKeyDateEnde*1 <= (arrDateFromEnde[1][0]+arrDateFromEnde[1][1]+arrDateFromEnde[1][2])*1){
					if(document.getElementById('fehler_preis')){
						document.getElementById('fehler_preis').style.display 		= 'none';
						document.getElementById('fehler_preis').style.visibility 	= 'hidden';
					}
					
					document.getElementById('fehler_mindestdauer').style.display 	= 'block';
					document.getElementById('fehler_mindestdauer').style.visibility = 'visible';
					document.getElementById('mindest_tage').innerHTML 				= arrDateFromEnde[2];
					document.getElementById('mindest_tage_border').innerHTML 		= arrDateFromEnde[2];
					
					if(document.getElementById('preis_dauer_moda')){
						document.getElementById('preis_dauer_moda').style.display 		= 'none';
						document.getElementById('preis_dauer_moda').style.visibility 	= 'hidden'; 
					}
					
					if(document.getElementById('infobox_preis_duration')){
						document.getElementById('infobox_preis_duration').style.display 		= 'none';
						document.getElementById('infobox_preis_duration').style.visibility 		= 'hidden';
					}
					
					fehlerMindest = true;
				}
			}
		}
		
		if(fehlerMindest == false){
			document.getElementById('fehler_mindestdauer').style.display 	= 'none';
			document.getElementById('fehler_mindestdauer').style.visibility = 'hidden';
		
			if(document.getElementById('kalender_hidden_detail')){
				this.setMarkierung(strKeyDateStart,'aktiv');
				this.setMarkierung(strKeyDateEnde,'aktiv');
			}else {
				var arrDate = getDateArrayFromKey(strKeyDateStart);
				showHiddenBoxDate(arrDate,$('from_hour').value,'from');
				
				var arrDate = getDateArrayFromKey(strKeyDateEnde);
				showHiddenBoxDate(arrDate,$('to_hour').value,'to');
				
				this.ermittlePreis();
			}
		}else{
			this.first 	= strKeyDateStart;
			this.second = 0;
			this.setMarkierung(strKeyDateStart,'aktiv');
			resetTextHiddenBoxDate($('to'));
		}
	},
	setTime : function (key,time) {
		if(key == 'start'){
			$('from_hour').value 	= time;
		} else if(key == 'ende') {
			$('to_hour').value 		= time;
		}
	},
	updateSlots : function(feld){
		if(document.getElementById(feld).value != ""){
			tmpStartEnde = document.getElementById(feld).value.split('-');
			
			tmpStart = tmpStartEnde[0].split('.');
			tmpEnde = tmpStartEnde[1].split('.');
			
			
			this.setMarkierung(tmpStart[2]+''+tmpStart[1]+''+tmpStart[0],'aktiv','start');
			this.setMarkierung(tmpEnde[2]+''+tmpEnde[1]+''+tmpEnde[0],'aktiv','ende');
		
			//this.ermittlePreis();
		}
	},
	selectSlots : function(feld,duration,feld_slots,from,to){
		if(document.getElementById(feld)){
			document.getElementById(feld).value = duration;
			getSlots(feld);
		}
		
		if(document.getElementById(feld_slots)){
			for(var i = 0, l = document.getElementById(feld_slots).options.length; i < l; ++i){
				if(document.getElementById(feld_slots).options[i].value == from+'-'+to){		
					document.getElementById(feld_slots).options[i].selected = true;
					document.getElementById(feld_slots).value = from+'-'+to;
				
				}
			}
		}
	},
	makiereBeiStart : function(){
		var objDate = new Date();
		//var objDateNow = new Date(objDate.getFullYear,objDate.getMonth,objDate.getDate(),12);
		var TimeNow = objDate.getTime();
		var start = TimeNow + (24 * 60 * 60 * 1000)*7;
		
		
		var dauer = 24;
		
		if(this.arrMindest != undefined ){
			dauer = getMindestMietzeitraum(this.arrMindest,start);
		}
		
		var ende = start + (dauer * 60 * 60 * 1000);
		
		var arrZeitraeume = this.objClCore.getZeiraumArray();
			
		var belegt = false;
		
		// belegten Tage durchlaufen
		for(var i = 0 , l = this.arrBusy.length; i < l; ++i){
			belegt = false;
			
			// Startzeit von belegten Zeitraum
			var tmp_start = this.arrBusy[i][0].split('-');
			
			// Endzeit von belegten Zeitraum
			var tmp_ende = this.arrBusy[i][1].split('-');
			
			var startBelegt = new Date(tmp_start[0],tmp_start[1]*1-1,tmp_start[2]*1,0,0,1);
			var endeBelegt 	= new Date(tmp_ende[0],tmp_ende[1]*1-1,tmp_ende[2]*1,23,59,59);		
			
			var TimeStartBelegt = startBelegt.getTime();
			var TimeEndeBelegt 	= endeBelegt.getTime();
			
			tmpDate = new Date(start);
			if(start >= TimeStartBelegt && start <= TimeEndeBelegt){
				start = TimeEndeBelegt+(24 * 60 * 60 * 1000);
				ende  = start+(dauer * 60 * 60 * 1000);
				belegt = true;
			}
			if(belegt == false){
				if(ende >= TimeStartBelegt && ende <= TimeEndeBelegt){
					start = TimeEndeBelegt+(24 * 60 * 60 * 1000);
					ende  = start+(dauer * 60 * 60 * 1000);
					belegt = true;
				}
				if(start <= TimeEndeBelegt && ende >= TimeEndeBelegt){
					start = TimeEndeBelegt+(24 * 60 * 60 * 1000);
					ende  = start+(dauer * 60 * 60 * 1000);
					belegt = true;
				}
			}
			if(TimeStartBelegt > ende && belegt == false){
				break;
			}
		}
		
		
		
		objDateStartMarkiert = new Date(start);
		var tag 	= objDateStartMarkiert.getDate();
		var monat 	= objDateStartMarkiert.getMonth()+1; 
		var jahr 	= objDateStartMarkiert.getFullYear();
		
		if(tag < 10){
			tag = '0'+tag;
		}
		
		if(monat < 10){
			monat = '0'+monat;
		}
		
		this.setMarkierung(jahr+''+monat+''+tag,'aktiv','start');
		
		objDateEndeMarkiert = new Date(ende);
		tag 	= objDateEndeMarkiert.getDate();
		monat 	= objDateEndeMarkiert.getMonth()+1; 
		jahr 	= objDateEndeMarkiert.getFullYear();
				
		if(tag < 10){
			tag = '0'+tag;
		}
		
		if(monat < 10){
			monat = '0'+monat;
		}
				
		this.setMarkierung(jahr+''+monat+''+tag,'aktiv','ende');
		
	},
	ermittlePreis : function(){
		
		if($('from').value != '' && $('to').value != ''){
			
			
			tmp_datum_zeit_von = $('from').value.split(' ');
			tmp_datum_zeit_bis = $('to').value.split(' ');
		
			
			tmp_datum_von = tmp_datum_zeit_von[0].split('-');
			tmp_datum_bis = tmp_datum_zeit_bis[0].split('-');
			
			jahr_von 	= tmp_datum_von[0];
			monat_von	= tmp_datum_von[1];
			tag_von		= tmp_datum_von[2];
			stunde_von	= tmp_datum_zeit_von[1].substr(0,2);
			
			jahr_bis 	= tmp_datum_bis[0];
			monat_bis	= tmp_datum_bis[1];
			tag_bis		= tmp_datum_bis[2];
			stunde_bis	= tmp_datum_zeit_bis[1].substr(0,2);
			
			tmp 	= window.location.href.split('.');
			tmp2 	= window.location.href.split('/');
			
			var objDateStart = new Date(jahr_von,monat_von*1-1,tag_von*1,stunde_von*1);
			var TimeStart = objDateStart.getTime();
			
			var objDateEnde = new Date(jahr_bis,monat_bis*1-1,tag_bis*1,stunde_bis*1);
			var TimeEnde = objDateEnde.getTime();
			
			var objDateNow 	= new Date();
			var TimeNow		= objDateNow.getTime();
			
			if(TimeEnde >= TimeStart && TimeNow < TimeStart){
			
			
				if(	document.getElementById('block_kalender') && 
					document.getElementById('warte_bild_kalender') && 
					document.getElementById('embeddedArticleCalendar') 
				){
				
					var pos = cumulativeOffset(document.getElementById('embeddedArticleCalendar'));
					
					var hoehe 	= document.getElementById('embeddedArticleCalendar').offsetHeight;
					var breite 	= document.getElementById('embeddedArticleCalendar').offsetWidth;
					
					document.getElementById('block_kalender').style.top 				= '0px';
					document.getElementById('block_kalender').style.left 				= '0px';
					
					document.getElementById('block_kalender').style.width   			= breite+'px';
					document.getElementById('block_kalender').style.height  			= hoehe+'px';
					
					document.getElementById('warte_bild_kalender').style.top 			= (hoehe/2-10)+'px';
					document.getElementById('warte_bild_kalender').style.left 			= (breite/2-10)+'px';
					
					document.getElementById('block_kalender').style.display 			= 'block';
					document.getElementById('block_kalender').style.visibility 			= 'visible';
					
					document.getElementById('warte_bild_kalender').style.display 		= 'block';
					document.getElementById('warte_bild_kalender').style.visibility 	= 'visible';
					
				}
				
				if(	document.getElementById('block_kalender_infobox') && 
						document.getElementById('warte_bild_kalender_infobox') && 
						document.getElementById('requestDataBody') 
				){
				
					var pos = cumulativeOffset(document.getElementById('requestDataBody'));
					
					var hoehe 	= document.getElementById('requestDataBody').offsetHeight;
					var breite 	= document.getElementById('requestDataBody').offsetWidth;
					
					document.getElementById('block_kalender_infobox').style.top 				= '0px';
					document.getElementById('block_kalender_infobox').style.left 				= '0px';
					
					document.getElementById('block_kalender_infobox').style.width   			= breite+'px';
					document.getElementById('block_kalender_infobox').style.height  			= hoehe+'px';
					
					document.getElementById('warte_bild_kalender_infobox').style.top 			= (hoehe/2-10)+'px';
					document.getElementById('warte_bild_kalender_infobox').style.left 			= (breite/2-10)+'px';
					
					document.getElementById('block_kalender_infobox').style.display 			= 'block';
					document.getElementById('block_kalender_infobox').style.visibility 			= 'visible';
					
					document.getElementById('warte_bild_kalender_infobox').style.display 		= 'block';
					document.getElementById('warte_bild_kalender_infobox').style.visibility 	= 'visible';
					
				}
				
				
				
				var url = strUrlShop+'/price.json';
				
				var standort = document.forms[strFormName]['location[]'].value;
				
				var artikel = document.forms[strFormName]['artikelnummer[]'].value;
				
				var anzahl = $('anzahl').value;
				
				var daten = 'formSend=PriceQuestion&artikelnummer='+artikel+'&location='+standort+'&anzahl='+anzahl;
				daten+= '&from='+encodeURIComponent($('from').value)+'&to='+encodeURIComponent($('to').value);
				
				
				var objThis = this;
				var myAjax = new Ajax.Request(
				url, 
				{
					method: 'get', 
					parameters: daten,
					onComplete: function(transport){
						if(200 == transport.status){
							objThis.setPreis(transport.responseJSON);	
						}
					}
				});
			}else {
				if(document.getElementById('price')){
					$('price').value		= '';
				}
				if(this.flgDetail == true && document.getElementById('preisanzeige_preis')){
					$('preisanzeige_preis').innerHTML = '- - -';
					$('preisanzeige_dauer').innerHTML = '';
				}
				
				
				
				$('from').value = '';
				$('to').value 	= '';
			}
		}
	},
	setPreis : function(strJsonPrice){
		if(document.getElementById('preisanzeige')){
		
			$('error_message').innerHTML = '';
			
			$('error_message').style.display 	= 'none';
			$('error_message').style.visibility = 'hidden';
			
			$('preisanzeige_preis').innerHTML = '';
			$('preisanzeige_dauer').innerHTML = '';
			
			if(strJsonPrice.message != undefined){
				$('error_message').innerHTML = strJsonPrice.message.unescapeHTML();
				$('error_message').style.display 	= 'block';
				$('error_message').style.visibility = 'visible';
				
				$('from').value = '';
				$('to').value 	= '';
				
			}else {
				var PriceRequest = new Object();
			
				for(str in strJsonPrice.arrPrice){
					PriceRequest[str] = strJsonPrice.arrPrice[str];
				}
				
				
				$('preisanzeige_preis').innerHTML = PriceRequest['strIntegral'].unescapeHTML()+','+PriceRequest['strDecimal'].unescapeHTML();
				$('preisanzeige_dauer').innerHTML = PriceRequest['duration'].unescapeHTML();
			}
		}
		
		
		
		/*if(ua.indexOf('safari') > -1 && meldung == 'null'){
			meldung = '';
		}*/

		if(document.getElementById('block_kalender')){
			document.getElementById('block_kalender').style.display 	= 'none';
			document.getElementById('block_kalender').style.visibility 	= 'hidden';
		}
		
		if(document.getElementById('warte_bild_kalender')){
			document.getElementById('warte_bild_kalender').style.display 	= 'none';
			document.getElementById('warte_bild_kalender').style.visibility = 'hidden';
		}
		
		if(document.getElementById('block_kalender_infobox')){
			document.getElementById('block_kalender_infobox').style.display 	= 'none';
			document.getElementById('block_kalender_infobox').style.visibility 	= 'hidden';
		}
		
		if(document.getElementById('warte_bild_kalender_infobox')){
			document.getElementById('warte_bild_kalender_infobox').style.display 	= 'none';
			document.getElementById('warte_bild_kalender_infobox').style.visibility = 'hidden';
		}
	}
}
//##############################################################################################################################################
// Kalender Modul  Detail Ende
//##############################################################################################################################################

//##############################################################################################################################################
// LibModule
//##############################################################################################################################################
	
	
	//##############################################################################################################################################
	// Create Table Head Calendar
	//##############################################################################################################################################
	/**
	* @brief Methode erstellt den Kopf des Kalenders
	*
	* @param int 		lngId
	* @param int 		jahr
	* @param string 	monat
	* @param string 	key     	   // Kalender Key
	* @param object 	htmlObject     
	*/
	function createHead(jahr,monat,key,htmlObject,i,ClClass){
		
		
		// Monat und Jahr fuer Head erstellen
		strMonth = getMonthHead(monat);
		
		if(ClClass.jahr[key] == undefined){
			// Head erstellen fuer Kalender Monat Jahr
			window['div_jahr_monat_'+key+'_'+i] = document.createElement('div');
			//window['div_jahr_monat_'+key+'_'+i].setAttribute("class","year");
			window['div_jahr_monat_'+key+'_'+i].className = "year";
			
				
			txt = document.createTextNode(strMonth+" "+jahr);
			
			window['div_jahr_monat_'+key+'_'+i].appendChild(txt);
			
			// Float Left loeschen
			div_clear_both = document.createElement('div');
			//div_clear_both.setAttribute("class","clear_both");
			div_clear_both.className = "clear_both";
			
			div = document.createElement('div');
			
			div_wechsler_back = getButtonBack(key);
			div_wechsler_next = getButtonNext(key);
			
			// Alles in den Head packen
			div.appendChild(div_wechsler_back);
			div.appendChild(div_wechsler_next);
			
			// sofern Head noch nicht vorhanden 
			div.appendChild(window['div_jahr_monat_'+key+'_'+i]);
			div.appendChild(div_clear_both);
			
			htmlObject.appendChild(div);
		}else {
			window['div_jahr_monat_'+key+'_'+i].innerHTML = strMonth+" "+jahr;
		}
	}
	
	function createFooter(key,htmlObject){
			var txt_close = document.createTextNode(strClose.unescapeHTML());
		
		var div = document.createElement('div');
		//div.setAttribute("class","close");
		div.className = "close";
		
		div.setAttribute("id","close_"+key);
		
		div.appendChild(txt_close);
		
		htmlObject.appendChild(div);
	}
	
	/**
	* @brief Methode erstellt den Button back
	*
	*/
	function getButtonBack(key){
		// Wechsler back erstellen
		var div_wechsler_back = document.createElement('div');
		//div_wechsler_back.setAttribute("class","head_left");
		div_wechsler_back.className = "head_left";
		
		var button_back = document.createElement('button');
		//button_back.setAttribute("class","wechsler");
		button_back.className = "wechsler";
		
		var button_back_txt = document.createTextNode("«");
		button_back.appendChild(button_back_txt);
		button_back.setAttribute("id",key+"_back");
		button_back.setAttribute("type","button");
		
		div_wechsler_back.appendChild(button_back);
		
		return div_wechsler_back;	
	}
	/**
	* @brief Methode erstellt den Button next
	*
	*/
	function getButtonNext(key){
		// Wechsler next erstellen
		var div_wechsler_next = document.createElement('div');
		//div_wechsler_next.setAttribute("class","head_right");
		div_wechsler_next.className = "head_right";
		
		var button_next = document.createElement('button');
		//button_next.setAttribute("class","wechsler");
		button_next.className = "wechsler";
		
		var button_next_txt = document.createTextNode("»");
		button_next.appendChild(button_next_txt);
		button_next.setAttribute("id",key+"_next");
		button_next.setAttribute("type","button");
		
		div_wechsler_next.appendChild(button_next);
		
		return div_wechsler_next;
	}
	
	
	//##############################################################################################################################################
	// Klasse ToolTip
	//##############################################################################################################################################	
	var Tooltip = {
		arrToolTip : new Object(),
		
		setToolTip : function(ToolTipJson){
			for(sn in ToolTipJson.tool){
				//this.arrToolTip[sn] = ToolTipJson.tool[sn].price+ ' '+ ToolTipJson.tool[sn].text;
				this.arrToolTip[sn] = ToolTipJson.tool[sn];
			}
		},
		showToolTip : function(cssClass){
			if(this.arrToolTip[cssClass] != undefined){
				return overlib(this.arrToolTip[cssClass],CSSCLASS,FGCLASS,'overlibFG',BGCLASS,'overlibBG',TEXTFONTCLASS,'overlibText',WRAP);
			}
			return false;
		},
		hideTooltip : function (){
			return nd();
		}
	}
	
	//##############################################################################################################################################
	// Anzahl der Kalender im Detail erhoehen
	//##############################################################################################################################################
	function setAnzahlCalendarDetail(anzahl,strKey){
		ModulDetail.anz = anzahl*1;
		for(var k = 0, p = ModulDetail.arrKey.length; k < p; ++k){
			key = ModulDetail.arrKey[k];
			ModulDetail.showCl(ModulDetail.monat[key],ModulDetail.jahr[key],ModulDetail.lngId);
		}
		
		if(strKey == 'more'){
			document.getElementById('more_calendar').style.display 		= 'none';
			document.getElementById('more_calendar').style.visibility 	= 'hidden';
			
			document.getElementById('less_calendar').style.display 		= 'inline';
			document.getElementById('less_calendar').style.visibility 	= 'visible';
			
		} else {
			document.getElementById('less_calendar').style.display 		= 'none';
			document.getElementById('less_calendar').style.visibility 	= 'hidden';
			
			document.getElementById('more_calendar').style.display 		= 'inline';
			document.getElementById('more_calendar').style.visibility 	= 'visible';
		}
		
		return false;
	}
	
	/**
	* @brief Funktion liefert den Monat fuer den Kalender Head zurueck
	*
	* @param int lngId
	* @param string monat
	*/
	function getMonthHead(monat){
		return ArrayMonths[monat*1-1].unescapeHTML();
	}
	
	/**
	* @brief Funktion liefert den Monat für in kurzform zurueck
	*
	* @param int lngId
	* @param string monat
	*/
	function getMonthShort(monat){
		return ArrayMonthsShort[monat*1-1].unescapeHTML().replace('.','');
	}
	
	/**
	* @brief Funktion ermittelt aus dem Datums-String ein ZeitArray
	*
	* @param string string YYYYMMDD
	* @return array arrDate[0] = YYYY, arrDate[1] = MM, arrDate[2] = DD
	*/
	function getDateArrayFromKey(string){
		var arrDate = new Array();
		
		string = string+'';
		
		arrDate[0] = string.substr(0,4);					// YYYY
		arrDate[1] = string.substr(4,2);					// MM
		arrDate[2] = string.substr(6,2);					// DD
		
		
		return arrDate;
	}
	
	/**
	* @brief Funktion ueberprueft ob der Datums-String in der Zukunft liegt
	*
	* @param string string YYYYMMDD
	*/
	function checkDateInFuture(string){
		// Immer false sofern nicht in Zukunft
		var bool = false;
	
		// Aktuelles Zeitobjekt
		var objDateNow = new Date();
	
		// Zeitarray fuer uebegebenen String
		var arrDate = new Array();
		
		string = string+'';
		
		arrDate[0] = string.substr(0,4);					// YYYY
		arrDate[1] = string.substr(4,2);					// MM
		arrDate[2] = string.substr(6,2);					// DD
		
		var objDateParam = new Date(arrDate[0],arrDate[1]*1-1,arrDate[2]);
		
		var paramTime 	= objDateParam.getTime();
		var nowTime 	= objDateNow.getTime();
		
		// uebergebenes Datum groesser als aktuelles Datum
		if(paramTime > nowTime){
			bool = true;
		}
		
		return bool;
	}
	
	/**
	* @brief Funktion ueberprueft ob im markierten Zeitraum ein belegter Tag enthalten ist
	* sofern belegter Tag vorhanden im Zeitraum wird false zurueckgegeben
	* 
	* @param object KalenderModul
	* @return boolean
	*/
	function checkForBusy(objModulKalender){
		var bool = true;
	
	
		if(objModulKalender.first > 0 && objModulKalender.second > 0){
			var arrDateStart 	= getDateArrayFromKey(objModulKalender.first);
			var arrDateEnde 	= getDateArrayFromKey(objModulKalender.second);
			
			// Anfang der Markierung als Zeitstempel
			var objDateStart = new Date(arrDateStart[0]*1,arrDateStart[1]*1-1,arrDateStart[2]*1,12,0,0);
			var timeStart = objDateStart.getTime();
			
			// Ende der Markierung als Zeitstempel
			var objDateEnde = new Date(arrDateEnde[0]*1,arrDateEnde[1]*1-1,arrDateEnde[2]*1,12,0,0);
			var timeEnde = objDateEnde.getTime();
			
			
			var belegt = true;
			
			
			if(objModulKalender.arrBusy != undefined){
				// belegten Tage durchlaufen
				do{
					for(var i = 0 , l = objModulKalender.arrBusy.length; i < l; ++i){
						
					
						// Startzeit von belegten Zeitraum
						var tmp_start = objModulKalender.arrBusy[i][0].split('-');
						
						// Endzeit von belegten Zeitraum
						var tmp_ende = objModulKalender.arrBusy[i][1].split('-');
						
						var startBelegt = new Date(tmp_start[0],tmp_start[1]*1-1,tmp_start[2]*1,12);
						var endeBelegt 	= new Date(tmp_ende[0],tmp_ende[1]*1-1,tmp_ende[2]*1,12);		
						
						var TimeStartBelegt = startBelegt.getTime();
						var TimeEndeBelegt 	= endeBelegt.getTime();
						
						if(timeStart >= TimeStartBelegt && timeStart <= TimeEndeBelegt){
							belegt = false;
							break;
						}
						if(timeStart < TimeStartBelegt){
							break;
						}
						
					}
					timeStart = timeStart + (24 * 60 * 60 * 1000);
					if(belegt == false){
						break;
					}
				}while(timeStart <= timeEnde);
			}
		}
		
		return belegt;
	}
	
	function getMindestMietzeitraum(arrMindestMietZeitraum,start){
		TimeStart = start
		
		var objDate = new Date();
		
		var MindestPeriod = 24;
		
		for(var i = 0, l = arrMindestMietZeitraum.length; i < l; ++i ){
			
			if(arrMindestMietZeitraum[i][0] == false){
					MindestPeriod = arrMindestMietZeitraum[i][3];
			} else {
				
				var tmp_start = arrMindestMietZeitraum[i][0].split('-');
				
				
				var objMindestStart = new Date(objDate.getFullYear(),tmp_start[0]*1-1,tmp_start[1]*1,0,0,1);
				var MindestStartTime = objMindestStart.getTime();
				
				var tmp_ende = arrMindestMietZeitraum[i][1].split('-');
				var objMindestEnde = new Date(objDate.getFullYear(),tmp_ende[0]*1-1,tmp_ende[1]*1,23,59,59);
				var MindestEndeTime = objMindestEnde.getTime();
				
				var testzeit = TimeStart + (arrMindestMietZeitraum[i][3] * 1000 * 60 * 60);
				
				if(MindestStartTime <=  TimeStart && MindestEndeTime >= TimeStart){
					if(testzeit < MindestEndeTime && testzeit > MindestStartTime){
						MindestPeriod = 24;				
					}
				}
			}
		}
		
		return MindestPeriod;
	}
	
	function getMindestMietzeitraumMakierung(arrMindestMietZeitraum,start,ende){
		var MindestPeriod = '';
		
		
		arrStart = getDateArrayFromKey(start);
		
		var objDate = new Date();
		
		var objDateStart = new Date(arrStart[0],arrStart[1]*1-1,arrStart[2]*1,0,0,1);
		TimeStart = objDateStart.getTime();
		
		
		for(var i = 0, l = arrMindestMietZeitraum.length; i < l; ++i ){
			if(arrMindestMietZeitraum[i][0] == false){
					MindestPeriod = arrMindestMietZeitraum[i][3];
			} else {
				var tmp_start = arrMindestMietZeitraum[i][0].split('-');
				
				
				var objMindestStart = new Date(objDateStart.getFullYear(),tmp_start[0]*1-1,tmp_start[1]*1,0,0,1);
				var MindestStartTime = objMindestStart.getTime();
				
				var tmp_ende = arrMindestMietZeitraum[i][1].split('-');
				var objMindestEnde = new Date(objDateStart.getFullYear(),tmp_ende[0]*1-1,tmp_ende[1]*1,23,59,59);
				var MindestEndeTime = objMindestEnde.getTime();
				
				
				var testzeit = TimeStart + (arrMindestMietZeitraum[i][3] * 1000 * 60 * 60);
				
				if(TimeStart >= MindestStartTime && TimeStart <= MindestEndeTime){
					fehler = true;
					MindestPeriod = false;	
				}
			}
		}

		TimeEnde = TimeStart + (MindestPeriod * 1000 * 60 * 60) - (24 *60 * 60 * 1000);
		
		TimeStart = TimeStart + (24 *60 * 60 * 1000);
		
		if(TimeStart < TimeEnde && MindestPeriod != false){
			objDateEnde = new Date(TimeEnde);
	
			var jahrEnde = objDateEnde.getFullYear();
			var monatEnde = objDateEnde.getMonth()+1;
			var tagEnde = objDateEnde.getDate();

			if(monatEnde < 10){
				monatEnde = '0'+monatEnde;
			}
	
			if(tagEnde < 10){
				tagEnde = '0'+tagEnde;
			}
	
			objDateStart = new Date(TimeStart);
	
			var jahrStart 	= objDateStart.getFullYear();
			var monatStart 	= objDateStart.getMonth()+1;
			var tagStart 	= objDateStart.getDate();

			if(monatStart < 10){
				monatStart = '0'+monatStart;
			}
	
			if(tagStart < 10){
				tagStart = '0'+tagStart;
			}

			arrDateFromEnde = new Array(3);
			
			arrDateFromEnde[0] = new Array(3);
			arrDateFromEnde[1] = new Array(3);

			arrDateFromEnde[0][0] = jahrStart;
			arrDateFromEnde[0][1] = monatStart;
			arrDateFromEnde[0][2] = tagStart;

			arrDateFromEnde[1][0] = jahrEnde;
			arrDateFromEnde[1][1] = monatEnde;
			arrDateFromEnde[1][2] = tagEnde;
			
			arrDateFromEnde[2] = MindestPeriod/24;

			return arrDateFromEnde;
			
		}
	
			return false;
	}
	
	/**
	* @brief Funktion ermittelt aus einem JSON String den Zeitraum belegte Saison Zeitraeume
	*
	* @param object MyJsObject (JSON String)
	*
	* @return array arrSeason
	*/
	function getSeason(MyJsObject){
		var arrSeason = new Array();
		
		for(sn in MyJsObject.season){
			z = arrSeason.length;
			
			for(var i =0 , l = MyJsObject.season[sn].length ; i < l ; ++i){
				if(MyJsObject.season[sn][i].start.year){
					start_year 		= MyJsObject.season[sn][i].start.year;
				}else {
					start_year 		= null;
				}
				
				start_month 		= MyJsObject.season[sn][i].start.month;
				start_day 			= MyJsObject.season[sn][i].start.day;
				
				if(MyJsObject.season[sn][i].ende.year){
					end_year 		= MyJsObject.season[sn][i].ende.year;
				}else {
					end_year 		= null;
				}
				
				end_month 			= MyJsObject.season[sn][i].ende.month;
				end_day 			= MyJsObject.season[sn][i].ende.day;
				
				cssClass			= sn;
				flgForce			= MyJsObject.season[sn][i].flgForce;
				
				if(start_month*1 < 10){
					start_month = '0'+start_month;
				}
				
				if(end_month*1 < 10){
					end_month = '0'+end_month;
				}
				
				if(start_day*1 < 10){
					start_day = '0'+start_day;
				}
				
				if(end_day*1 < 10){
					end_day = '0'+end_day;
				}
						
				arrSeason[z] 	= new Array();
				if(start_year != null){
					arrSeason[z][0]	= start_year+'-'+start_month+'-'+start_day;
				}else {
					arrSeason[z][0]	= start_month+'-'+start_day;	
				}
				
				if(end_year != null){
					arrSeason[z][1]	= end_year+'-'+end_month+'-'+end_day;
				}else {
					arrSeason[z][1]	= end_month+'-'+end_day;	
				}
				arrSeason[z][2]	= cssClass;
				arrSeason[z][3]	= flgForce;
				
				z++;
			}
		}
		
		return arrSeason;
	}
	
	/**
	* @brief Funktion ermittelt aus einem JSON String den Zeitraum belegte Zeitraeume
	*
	* @param object busy (JSON String)
	*
	* @return array arrBusyDays
	*/
	function getBusyDays(busy){
		var arrBusyDays = new Array();
		
		
		z = arrBusyDays.length;
		
		if(busy.busy !== null){
		
			for(var i = 0 , l =  busy.busy.length; i < l ; ++i){
				arrBusyDays[z] 		= new Array();
				arrBusyDays[z][0] 	= busy.busy[i].start;
				arrBusyDays[z][1] 	= busy.busy[i].ende;
				arrBusyDays[z][2] 	= busy.busy[i].CssClass;
				arrBusyDays[z][3] 	= busy.busy[i].flgForce;
					
				z++;
			}
		}
		
		return arrBusyDays;
	}
	
	function getAnreiseDays(anreise){
		var arrAnreiseDays = new Array();
		
		
		z = arrAnreiseDays.length;
		
		if(anreise.anreise !== null){
		
			for(var i = 0 , l =  anreise.anreise.length; i < l ; ++i){
				arrAnreiseDays[z] 		= new Array();
				arrAnreiseDays[z][0] 	= anreise.anreise[i].start;
				arrAnreiseDays[z][1] 	= anreise.anreise[i].ende;
				arrAnreiseDays[z][2] 	= anreise.anreise[i].CssClass;
				arrAnreiseDays[z][3] 	= anreise.anreise[i].flgForce;
					
				z++;
			}
		}
		
		return arrAnreiseDays;
	}
	
	/**
	* @brief Funktion ermittelt aus einem JSON String den Zeitraum inaktiv
	*
	* @param object inaktiv (JSON String)
	*
	* @return array arrInaktiv
	*/
	function getInaktiv(inaktiv){
	
		var arrInaktiv = new Array();
		
		z = arrInaktiv.length;
		
		for(var i = 0, l = inaktiv.inaktiv.length ; i < l ; ++i){
			
			arrInaktiv[z] 		= new Array();
			arrInaktiv[z][0] 	= inaktiv.inaktiv[i].start;
			arrInaktiv[z][1] 	= inaktiv.inaktiv[i].ende;
			arrInaktiv[z][2] 	= inaktiv.inaktiv[i].CssClass;
			arrInaktiv[z][3] 	= inaktiv.inaktiv[i].flgForce;
			
			z++;
		}
		
		return arrInaktiv;
	}
	
	/**
	* @brief Funktion ermittelt aus einem JSON String den Zeitraum Mindestmietzeitraum
	*
	* @param object mindest (JSON String)
	*
	* @return array arrMindest
	*/
	function getMindest(mindest){
	
		var arrMindest = new Array();
		
		z = arrMindest.length;
		
		if(mindest.mindest != null){
			for(var i = 0, l = mindest.mindest.length ; i < l ; ++i){
				
				arrMindest[z] 		= new Array();
				arrMindest[z][0] 	= mindest.mindest[i].start;
				arrMindest[z][1] 	= mindest.mindest[i].ende;
				arrMindest[z][2] 	= mindest.mindest[i].CssClass;
				arrMindest[z][3] 	= mindest.mindest[i].intPeriod;
				
				z++;
			}
		}
		return arrMindest;
	}

	/**
	* @brief Funktion ermittelt Jahr und Monat vom uebergebenen Jahr und Monat + i Monate
	*
	* @param string monat (MM)
	* @param string jahr (YYYY)
	* @param int i 
	*
	* @return array arrMonatJahr (0 => monat, 1 => jahr)
	*/
	function getMonatJahr(monat,jahr,i){
		arrMonatJahr = new Array();
		
		monat = monat*1+i;
		if(monat > 12){
			monat = monat*1 -12;
			jahr++;		
		}
		
		if(monat < 10){
			monat = '0'+monat; 
		}
		
		arrMonatJahr[0] = monat;
		arrMonatJahr[1] = jahr;
		
		
		return arrMonatJahr;
	}
	
	/**
	* @brief Methode setzt das Datum in einem Hiddenfeld 
	*
	* @param array arrDate (0 => YYYY, 1 => MM, 2 => DD )
	* @param string time (H:m:s)
	* @param string elemId (HTML Object ID)
	*/
	function showHiddenBoxDate(arrDate,time,elemId){
		if(arrDate.length > 0){
			$(elemId).value = arrDate[0]+'-'+arrDate[1]+'-'+arrDate[2]+' '+time;
		} else {
			$(elemId).value = '';
		}
	}
	
	function showSelectBoxDateDay(arrDate,elemId){
		$(elemId).value = arrDate[2];
	}
	
	function showSelectBoxDateMonth(arrDate,elemId){
		$(elemId).value = arrDate[1]+'-'+arrDate[0];
	}
	
	
	function showTextBoxDate(arrDate,elemId,lngId){
		
		if(arrDate.length > 0){
			if(lngId == 1 || lngId == 10 || lngId == 11){
				$(elemId).value = arrDate[2]+'.'+arrDate[1]+'.'+arrDate[0];
			}else if(lngId == 2 || lngId == 9){
				$(elemId).value = arrDate[2]+'.'+arrDate[1]+'.'+arrDate[0];
			}
		} else {
			$(elemId).value = '';
		}
	}
	
	/**
	* @brief Funktion setzt den value zurueck vom Html Element
	*/
	function resetTextHiddenBoxDate(elemId){
		$(elemId).value = '';
	}


function setFormFieldValue(strFormName,strFormFieldName,mixFormFieldValue) {
	for(var i=0, l = document.forms[strFormName].elements.length ;i < l;++i) {
		if(document.forms[strFormName].elements[i].name == strFormFieldName) {
			if(document.forms[strFormName].elements[i].type == 'radio') {
				if(document.forms[strFormName].elements[i].value == mixFormFieldValue){
					document.forms[strFormName].elements[i].checked = true;
				}
			} else {
				document.forms[strFormName].elements[i].value = mixFormFieldValue;
			}
		}
	}
}

function showElement( id, boolUseDefault){
	try {
		$(id).style.visibility	= 'visible';
		if( boolUseDefault ) {
			$(id).style.display	= '';
		} else {
			$(id).style.display	= 'block';
		}
	} catch(e) {
		//alert(e);
	}
}

function hideElement(id){
	try {
		$(id).style.visibility	= 'hidden';
		$(id).style.display		= 'none';
	} catch(e) {
		//alert(e);
	}
}

function showHelp(id,id_help) {
	// default id
	if( id_help == '' ) {
		id_help = 'help_'+id;
	}
	
	var objTrigger	= $( id );
	var objTarget	= $( id_help );
	// width of trigger
	var arrDimension	= objTrigger.getDimensions();
	var intWidth		= arrDimension.width;
	if(isNaN( intWidth )) {
		intWidth = 0;
	}
	// position of trigger
	var arrPosTrigger	= objTrigger.cumulativeOffset();
	// move it
	objTarget.style.left	= (arrPosTrigger[0]+intWidth+5)+'px';
	objTarget.style.top		= (arrPosTrigger[1])+'px';
	// reimplant it if nessecary
	var objBody = document.getElementsByTagName('BODY')[0];
	if(objTarget.parentNode!=objBody){
		objTarget.parentNode.removeChild( objTarget );
		objBody.appendChild( objTarget );
	}
	// show it
	showElement( id_help );
}

function hideHelp(id,id_help) {

	//elem = 'help_'+id;
	if(id_help == '') {
		elem = 'help_'+id;
	} else {
		elem = id_help;
	}
	
	hideElement(elem);
}

function CheckInput(strFormName){
	if(document.forms[strFormName].from.value == '' || document.forms[strFormName].to.value == ''){
		showErrorContainer(strSetDate.unescapeHTML());
		return false;
	}
	
	if(document.forms[strFormName]['artikelnummer[]'].length > 1){
		for(var i=0 , l = document.forms[strFormName]['artikelnummer[]'].length;i < l; ++i){
			if(document.forms[strFormName]['location[]'][i].value == ''){
				showErrorContainer(strLocationWrong.unescapeHTML());
				return false;
			}
			if(document.forms[strFormName]['anzahl[]'][i].value == ''){
				showErrorContainer(strAnzahlWrong.unescapeHTML());
				return false;
			} else if(document.forms[strFormName]['anzahl[]'][i].value != ''){
				if(!is_numeric(document.forms[strFormName]['anzahl[]'][i].value)){
					showErrorContainer(strAnzahlWrong.unescapeHTML());
					return false;
				}
			}
		}
	} else {
		if(document.forms[strFormName]['location[]'].value == ''){
			showErrorContainer(strLocationWrong.unescapeHTML());
			return false;
		}
		if(document.forms[strFormName]['anzahl[]'].value == ''){
			showErrorContainer(strAnzahlWrong.unescapeHTML());
			return false;
		} else if(document.forms[strFormName]['anzahl[]'].value != ''){
			if(!is_numeric(document.forms[strFormName]['anzahl[]'].value)){
				showErrorContainer(strAnzahlWrong.unescapeHTML());
				return false;
			}
		}
	}
	
	return true;
}
// Error Container Anzeigen
function showErrorContainer( message ){
	if(document.getElementById('from_month')){
		pos = cumulativeOffset(document.getElementById('from_month'));
		posTop 	= pos[1];
		posLeft = pos[0];
		
		document.getElementById('globalError').style.top = posTop+'px';
		document.getElementById('globalError').style.left = posLeft+200+'px';
		document.getElementById('globalErrorMessageClose').onclick = new Function("hideElement('globalError');");
		
	}else {
		posTop 	= (window.outerHeight)/2;
		posLeft = (window.outerWidth)/2;
		
		document.getElementById('globalError').style.top = posTop-100+'px';
		document.getElementById('globalError').style.left = posLeft-150+'px';
		document.getElementById('globalErrorMessageClose').onclick = new Function("hideElement('globalError');");
	}
	
	document.getElementById('globalErrorMessage').innerHTML = message;
	showElement('globalError');
}



var cumulativeOffset = function(element) {
		
	var valueT = 0, valueL = 0;
	
	do {
		
			valueT += element.offsetTop  || 0;
			
			valueL += element.offsetLeft || 0;
			
			element = element.offsetParent;
		
	} while (element);
	
	return [valueL, valueT];
	
}

function is_string( mixValue ) {
    return (typeof( mixValue ) == 'string');
}

function is_object( mixValue ) {
    if(mixValue instanceof Array) {
        return false;
    } else {
        return (mixed_var !== null) && (typeof( mixValue ) == 'object');
    }
}
/// mixNodeOld - ID des Nodes (string) oder Node (object)
/// mixNodeNew - ID des Nodes (string) oder Node (object)
function replaceNodes( mixNodeOld, mixNodeNew ) {

	var objNodeOld = null;
	var objNodeNew = null;

	if(is_string(mixNodeOld)) {
		objNodeOld = $(mixNodeOld);
	} else if(is_object(objNodeNew)) {
		objNodeOld = mixNodeOld;
	}

	if(is_string(mixNodeNew)) {
		objNodeNew = $(mixNodeNew);
	} else if(is_object(objNodeNew)) {
		objNodeNew = mixNodeNew;
	}

	if(objNodeNew && objNodeOld) {
		objNodeOld.parentNode.replaceChild(objNodeNew,objNodeOld);
		return true;
	}
	
	return false;
}
/// mixNode - ID des Nodes (string) oder Node (object)
function switchVisibility( mixNode ) {
	var objNode = null;
	if(is_string(mixNode)) {
		objNode = $(mixNode);
	} else if(is_object(mixNode)) {
		objNode = mixNode;
	}
	if(objNode) {
		if(objNode.style.visibility == 'hidden') {
			objNode.style.visibility = 'visible';
			objNode.style.display    = 'block';
		} else {
			objNode.style.visibility = 'hidden';
			objNode.style.display    = 'none';
		}
		return true;
	}
	return false;
}
/// mixNode - ID des Nodes (string) oder Node (object)
/// strAttr - Names des Attributes
function removeAttribute( mixNode, strAttr ) {
	var objNode = null;
	if(is_string(mixNode)) {
		objNode = $(mixNode);
	} else if(is_object(mixNode)) {
		objNode = mixNode;
	}
	if(objNode) {
		objNode.removeAttribute(strAttr);
		return true;
	}
	return false;
}
/// mixNode  - ID des Nodes (string) oder Node (object)
/// strAttr  - Names des Attributes
/// strValue - Wert des Attributes
function setAttribute( mixNode, strAttr, strValue ) {
	var objNode = null;
	if(is_string(mixNode)) {
		objNode = $(mixNode);
	} else if(is_object(mixNode)) {
		objNode = mixNode;
	}
	if(objNode) {
		objNode.setAttribute(strAttribute,strValue);
		return true;
	}
	return false;
}

function SearchNavi_newSearch( mixNodeOld, mixNodeNew ) {
	replaceNodes(mixNodeOld,mixNodeNew);
	removeAttribute(mixNodeNew,'disabled');
}

/**
* @brief Funktion ueberprueft ob die uebergebene Variable eine Zahl ist
*
* @param string mixed_var
*/
function is_numeric( mixed_var ) {
   return !isNaN( mixed_var );
}

/**
* @brief wechseln des Standortes für den Artikel
*/
function changeLocation(strParameter,strField){
	if(strUrlDetail.indexOf('?') > -1){
		strUrlDetail+= '&'+strParameter+'='+$(strField).value;
	} else {
		strUrlDetail+= '?'+strParameter+'='+$(strField).value;
	}
	
	window.location = strUrlDetail;
}

//#############################################################################
// smooth scrolling
//#############################################################################
// Changes links that link to other parts of this page to scroll
// smoothly to those links rather than jump to them directly, which
// can be a little disorienting.
//
// sil, http://www.kryogenix.org/
//
// v1.0 2003-11-11
// v1.1 2005-06-16 wrap it up in an object
// 
// use 
//   ss.addEvent(window,"load",ss.fixAllLinks);
// at the head or run
//   ss.fixAllLinks( );
// at end of page
//#############################################################################
var ss = {
	STEPS: 25, // konfiguration der schrittanzahl
	fixAllLinks: function() {
		// Get a list of all links in the page
		var allLinks = document.getElementsByTagName('a');
		// Walk through the list
		for (var i=0;i<allLinks.length;i++) {
			var lnk = allLinks[i];
			if( lnk.href && lnk.href.indexOf('#') != -1
			&&	lnk.href.indexOf('#')+1 < lnk.href.length ) {
				// fixin pathnames for opera
				var lpath	= lnk.pathname;
				var qmi		= lpath.indexOf('?');
				if( qmi != -1 ) {
					lpath=lpath.slice(0,qmi);
				}
				if(( lpath == location.pathname || '/'+lpath == location.pathname )
				&& (lnk.search == location.search) ) {
					// If the link is internal to the page (begins in #)
					// then attach the smoothScroll function as an onclick
					// event handler
					ss.addEvent(lnk,'click',ss.smoothScroll);
				}
			}
		}
	},
	smoothScroll: function(e) {
		// This is an event handler; get the clicked on element,
		// in a cross-browser fashion
		if (window.event) {
			target = window.event.srcElement;
		} else if (e) {
			target = e.target;
		} else return;
		
		// Make sure that the target is an element, not a text node
		// within an element
		if (target.nodeType == 3) {
			target = target.parentNode;
		}
		
		// Paranoia; check this is an A tag
		if (target.nodeName.toLowerCase() != 'a') {
			return;
		}
		
		// Find the <a name> tag corresponding to this href
		// First strip off the hash (first character)
		anchor = target.hash.substr(1);
		// Now loop all A tags until we find one with that name
		var allLinks = document.getElementsByTagName('a');
		var allDivs = document.getElementsByTagName('div');
		var all = [allLinks, allDivs];
		var destinationLink = null;
		for (var j=0; j<all.length; j++) {
			for (var i=0;i<all[j].length;i++) {
				var lnk = all[j][i];
				if (lnk.name && (lnk.name == anchor)) {
					destinationLink = lnk;
					break;
				} else if (lnk.id && (lnk.id == anchor)){
					destinationLink = lnk;
					break;
				}
			}
		}
		
		// If we didn't find a destination, give up and let the browser do
		// its thing
		if (!destinationLink) {
			return true;
		}
		
		var arrOffset = Position.cumulativeOffset( destinationLink );
		var destx = arrOffset[0];
		var desty = arrOffset[1];
		
		// Stop any current scrolling
		clearInterval(ss.INTERVAL);
		
		cypos = ss.getCurrentYPos();
		ss_stepsize = parseInt((desty-cypos)/ss.STEPS);
		ss.INTERVAL = setInterval('ss.scrollWindow('+ss_stepsize+','+desty+',"'+anchor+'")',10);
		
		// And stop the actual click happening
		if (window.event) {
			window.event.cancelBubble = true;
			window.event.returnValue = false;
		}
		if (e && e.preventDefault && e.stopPropagation) {
			e.preventDefault();
			e.stopPropagation();
		}
	},
	scrollWindow: function(scramount,dest,anchor) {
		wascypos = ss.getCurrentYPos();
		isAbove = (wascypos < dest);
		window.scrollTo(0,wascypos + scramount);
		iscypos = ss.getCurrentYPos();
		isAboveNow = (iscypos < dest);
		if ((isAbove != isAboveNow) || (wascypos == iscypos)) {
			// if we've just scrolled past the destination, or
			// we haven't moved from the last scroll (i.e., we're at the
			// bottom of the page) then scroll exactly to the link
			window.scrollTo(0,dest);
			// cancel the repeating timer
			clearInterval(ss.INTERVAL);
			// and jump to the link directly so the URL's right
			location.hash = anchor;
		}
	},
	getCurrentYPos: function() {
		if (document.body && document.body.scrollTop)
			return document.body.scrollTop;
		if (document.documentElement && document.documentElement.scrollTop)
			return document.documentElement.scrollTop;
		if (window.pageYOffset)
			return window.pageYOffset;
		return 0;
	},
	addEvent: function(elm, evType, fn, useCapture) {
		// addEvent and removeEvent
		// cross-browser event handling for IE5+,  NS6 and Mozilla
		// By Scott Andrew
		if (elm.addEventListener){
			elm.addEventListener(evType, fn, useCapture);
			return true;
		} else if (elm.attachEvent){
			var r = elm.attachEvent("on"+evType, fn);
			return r;
		} else {
			alert("Handler could not be removed");
		}
	} 
}

