// Browsererkennung
var DHTML = 0, DOM = 0, MS = 0, NS = 0, OP = 0;
function LayerInit(){
	if (window.opera){OP = 1;}
	if(document.getElementById){DHTML = 1; DOM = 1;}
 	if(document.all && !OP){DHTML = 1; MS = 1;}
	if(document.layers && !OP){DHTML = 1;NS = 1;}
}
LayerInit()
//*****************************************************************************************************************************
// Objektinitialisierung
// DynamicLayers (c)2000-2003 brater.com
//*****************************************************************************************************************************
function DynamicLayer(){
	// Id 
	this.id = DynamicLayer.arguments[0]
	// Parent Layer ?? 
	this.parentobj = ((DynamicLayer.arguments.length==2)||(DynamicLayer.arguments.length==6))? DynamicLayer.arguments[1]:false
	// Dynamische erstellung des Layers...
	//falls 5 oder 6 --- nicht vorhanden --- Layer als Div-Tag erzeugen:
	if (DynamicLayer.arguments.length>=5){
		param_left = (DynamicLayer.arguments.length==5)? DynamicLayer.arguments[1]:DynamicLayer.arguments[2]
		param_top = (DynamicLayer.arguments.length==5)? DynamicLayer.arguments[2]:DynamicLayer.arguments[3]
		param_width = (DynamicLayer.arguments.length==5)? DynamicLayer.arguments[3]:DynamicLayer.arguments[4]
		param_height = (DynamicLayer.arguments.length==5)? DynamicLayer.arguments[4]:DynamicLayer.arguments[5]
		
		this.clipx1 = 0
		this.clipy1 = 0
		this.clipx2 = param_width
		this.clipy2 = param_height
	
		if (DOM){			//--------------------------------- Layer erzeugung nach DOM
			var Elementknoten = document.createElement("DIV");
	  		var Textknoten = document.createTextNode("---");
			Elementknoten.id = this.id
			Elementknoten.style.position = 'absolute';
			Elementknoten.style.overflow = 'hidden';
			Elementknoten.style.visibility = 'hidden';
			Elementknoten.style.top = param_top + 'px';
			Elementknoten.style.left = param_left + 'px';
			Elementknoten.style.width = param_width + 'px';
			Elementknoten.style.height = param_height + 'px';
			Elementknoten.appendChild(Textknoten);
			// Einhängen in Elementstruktur
			if (!this.parentobj) document.body.appendChild(Elementknoten);
			else document.getElementById(this.parentobj.id).appendChild(Elementknoten);
		}
		else if (NS){			//--------------------------------- Layer erzeugung nach NS4.x
			var NeuerLayer = (DynamicLayer.arguments.length==5)? document.layers[this.id] = new Layer(param_width):eval("document."+this.parentobj.id+".document."+this.id+" = new Layer(param_width, document."+this.parentobj.id+")")
			eval("document."+this.id+" = NeuerLayer")
			NeuerLayer.left = param_left
			NeuerLayer.top = param_top
			if (param_height!=null) NeuerLayer.clip.height = param_height
			NeuerLayer.visibility = 'hide'
		}
		else if (MS){		//--------------------------------- Layer erzeugung nach MS 4.x
			var str = '\n<DIV id='+this.id+' style="position:absolute; left:'+param_left+'; top:'+param_top+'; width:'+param_width
			if (param_height!=null){
				str += '; height:'+param_height
				str += '; clip:rect(0,'+param_width+','+param_height+',0)'
			}
			str += '; visibility:'+ "hidden" 
			str += ';"></DIV>'
			if (DynamicLayer.arguments.length==5) document.body.insertAdjacentHTML("BeforeEnd",str)
			if (DynamicLayer.arguments.length==6) document.getElementById(this.parentobj.id).insertAdjacentHTML("BeforeEnd",str)
		}
	}
	// Layereigenschaften speichern...........................................................................................................
	
	// Element Objekt
	if(DOM)	this.elm = document.getElementById(this.id)		// für alle neuen Browser
	else if(MS)	this.elm = document.all[this.id]			// Für IE4.x
	else if(NS){											// Für NS4 isses nur durch Recursion zu lösen
		if (!this.parentobj){	// Wenn kein Parent vorhanden
			this.path="document."+ this.id;		this.elm = eval("document." + this.id)}
		else{	// Sonst Pfad basteln
			this.path = this.parentobj.path+".document."+this.id; this.elm = eval (this.path)}
	}
	
	// CSS Styles
	if(DOM||MS) this.css = this.elm.style		// Für alle neuen Browser
	else if(NS) this.css = this.elm				// Für NS4.x
	
	// Selbstreferenz
	this.obj = this.id + "Ref"			// z.B: Layer1Ref								// Referenzbelegung auf sich selbst (Recursionsfehler bei NS ausgetrickst)
	eval(this.obj + "=this")			// -->   Layer1Ref=this							// mit neuem Objekt das ein Unterobjekt des Objektes selbst ist

	// Interne Speichervariablen
	if (DOM && !OP){ //MS & NS6
		this.xpos = this.css.left.slice(0,this.css.left.length-2)
		this.ypos = this.css.top.slice(0,this.css.top.length-2)
	
	}
	else {	// Opera und NS4
		this.xpos 		= this.css.left
		this.ypos 		= this.css.top
	}
	
	if (NS) {// Netscape 4 macht die Breite bei selbsterzeugten Layern Falsch! Daher händisch hier nochmal
		if (DynamicLayer.arguments.length>=5) this.css.clip.right =  param_width
	} 
	
	
	this.moveing 				 = false
	this.movestop				= false
	this.movetimer			    = new Array() 		// Timer für mehrere Moves
	this.dragable 				 = false			// immer noch dragable?
	this.draglayer				 = this				// der tatsächlich zu verschiebende Layer (normalerweise der Eigene)
	this.draginside				= false			   	// innerhalb verschieben?
	this.dropevent				=""					// zu evaluierendes Event wenn Drop
	this.draglimited			=false			   	// gibts ein Limit?
	this.dragx1 = 0							   		// Maximale Verschiebbarkeit falls dragabel
	this.dragy1 = 0									// Wird berechnet wenn object Dragable wird.
	this.dragx2 = 0
	this.dragy2 = 0
	//this.dragtargeted 		   = false			// hats einen Zielpunkt?
	this.zorig				= this.css.zIndex
	this.znow				= this.css.zIndex	


}
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------Z-Index
DynamicLayer.prototype.SetZindex = LayerSetZindex
function LayerSetZindex(i){
	this.css.zIndex=i
}
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------Show
DynamicLayer.prototype.Show = LayerShow
DynamicLayer.prototype.ShowNow = LayerShowNow
function LayerShow(delay){setTimeout (this.obj + ".ShowNow()", delay)}
function LayerShowNow(){this.css.visibility = "visible"}
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------Hide
DynamicLayer.prototype.Hide = LayerHide
DynamicLayer.prototype.HideNow = LayerHideNow
function LayerHide(delay){setTimeout (this.obj + ".HideNow()", delay)}
function LayerHideNow(){this.css.visibility = "hidden"}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------Set
DynamicLayer.prototype.Set = LayerSet
DynamicLayer.prototype.SetNow = LayerSetNow
function LayerSet(delay,x,y,inside){
		inside=(inside)? true:false
		setTimeout (this.obj+".SetNow(" + x + "," + y + "," + inside + ")", delay)
}
function LayerSetNow(x2,y2,inside){
		inside=(inside)? true:false
		if (inside){
			x1 = this.xpos;y1 = this.ypos
			cx1 = this.clipx1;cy1 = this.clipy1;cx2 = this.clipx2;cy2 = this.clipy2
			this.ClipNow(cx1+(x1-x2),cy1+(y1-y2),cx2+(x1-x2),cy2+(y1-y2)) 
		}
        this.xpos = x2;this.ypos = y2
		this.css.left = this.xpos;this.css.top = this.ypos
}				
//----------------------------------------------------------------------------------------------------------------------------------------------------------------LayerWrite (geht nicht auf Opera!!!)
DynamicLayer.prototype.LayerWrite = LayerWrite
function LayerWrite(content){
		if (DOM){
			//this.elm.innerHTML =content	// So werden Bilder interpretiert
			this.elm.innerHTML =content	// So werden Bilder interpretiert
			
			//this.elm.firstChild.nodeValue = content	// So wirds als text reingeschrieben
		}
		else if (NS){
			this.elm.document.open();
			this.elm.document.write(content);
			this.elm.document.close();
		}
        else if (IE){
			this.doc.innerHTML = content
		}	
}



//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------Move
DynamicLayer.prototype.Move = LayerMove
DynamicLayer.prototype.MoveNow = LayerMoveNow
DynamicLayer.prototype.MoveLoop = LayerMoveLoop
function LayerMove(start,stop,x2,y2,how,inside){
		inside=(inside)? true:false
		if (!how) how=4
		duration = stop-start
		this.movetimer[this.movetimer.length] = window.setTimeout (this.obj+".MoveNow(" + (duration) + "," + x2 + "," + y2 + "," + how + "," + inside + ")",start)		
}
function LayerMoveNow(duration,x2,y2,how,inside){
		inside=(inside)? true:false
		if (!how) how=4
		if (this.moveing == false){
			this.moveing = true;
			time = new Date();
			starttime = time.getTime();
			this.MoveLoop(starttime, duration, this.xpos, this.ypos, x2, y2, how, inside)
		}				
		else{window.setTimeout (this.obj+".MoveNow("+duration+","+x2+","+y2+","+how+","+inside+")",50)}	//Moved noch...nochmal später probieren
}				
function LayerMoveLoop (starttime,duration,x1,y1,x2,y2,how,inside){
		time = new Date();
		now = time.getTime()
		if (this.movestop == false){
			if (now <= starttime + duration ){
				factor = ease(starttime,now,duration,how)
				x = x1 + (x2-x1)*factor;	y = y1 + (y2-y1)*factor
				this.SetNow(x,y,inside)
				window.setTimeout (this.obj+".MoveLoop("+starttime+","+duration+","+x1+","+y1+","+x2+","+y2+","+how+","+inside+")",30)
			}
			else {this.SetNow(x2,y2,inside);this.moveing = false}		 // Fertig
		}
		else {this.movestop = false;this.moveing = false}		// Stopped !
}

//------------------------------------------------------------------------------------------------------------------------------------------------------------------------Move Inside!
DynamicLayer.prototype.SetInside = LayerSetInside
DynamicLayer.prototype.SetInsideNow = LayerSetInsideNow
DynamicLayer.prototype.MoveInside = LayerMoveInside
DynamicLayer.prototype.MoveInsideNow = LayerMoveInsideNow
function LayerSetInside(delay,x2,y2){
		this.Set(x2,y2,true)
}
function LayerSetInsideNow(x2,y2){
		this.SetNow(x2,y2,true)
}
function LayerMoveInside(start,stop,x2,y2,how){
		if (!how) how=4
		this.Move(start,stop,x2,y2,how,true)
}
function LayerMoveInsideNow(duration,x2,y2,how){
		if (!how) how=4
		this.MoveNow(duration,x2,y2,how,true)
}
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------Stop!
DynamicLayer.prototype.Stop = LayerStop
function LayerStop(){
 	if (this.movetimer.length > 0){				
		//alert(this.movetimer.length)
		for(i = 0; i <= this.movetimer.length-1; i++){window.clearTimeout(this.movetimer[i])} // alle Timer löschen
	}
	if (this.moveing == true){this.movestop = true}	// wenn grad unterwegs dann anhalten
}
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------Clip
DynamicLayer.prototype.Clip = LayerClip
DynamicLayer.prototype.ClipNow = LayerClipNow
function LayerClip(delay,x1,y1,x2,y2) {	window.setTimeout (this.obj + ".ClipNow(" + x1 + "," + y1 + "," + x2 + "," + y2 + ")",delay)		}
function LayerClipNow(x1,y1,x2,y2) {
        this.clipy1 = y1;this.clipx2 = x2;this.clipy2 = y2;this.clipx1 = x1 
		if (NS) {this.css.clip.top = y1;	this.css.clip.right = x2; this.css.clip.bottom = y2; this.css.clip.left = x1}
        else if (MS || DOM){this.css.clip = "rect("+y1+"px "+ x2 +"px "+ y2 +"px "+x1+"px)"}				
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------MouseDrag
DynamicLayer.prototype.Drag = LayerDrag
function LayerDrag(){
	// Neuberechnung der Maximalverschiebung (inclusive parent, draglayer und eigenem Clipping) auf Screengröße
	b=(MS)? document.body.offsetWidth:window.innerWidth;		h=(MS)? document.body.offsetHeight:window.innerHeight
	
	//alert(this.GetAbsposX())
	
	this.dragx1=this.draglayer.xpos-this.GetAbsposX()-this.clipx1;		this.dragy1=this.draglayer.ypos-this.GetAbsposY()-this.clipy1
	this.dragx2=this.dragx1+b-this.clipx2+this.clipx1;					this.dragy2=this.dragy1+h-this.clipy2+this.clipy1
	this.dragable=true
	Mouse.DragObjects[Mouse.DragObjects.length]=this	// neues Objekt wird an Liste angehängt
}
//----------------------------------------------------------------------------------------------------------------------------------------------------------------------Abspos
// Berechnet die Absolute Position des Layers auf dem Schirm (mit allen Parents) und gibt den Wert in px zurück.
// Ruft seinerseits diese Funktion für die entsprechenden Parents auf.
DynamicLayer.prototype.GetAbsposX = LayerGetAbsposX
DynamicLayer.prototype.GetAbsposY = LayerGetAbsposY
function LayerGetAbsposX(){return (!this.parentobj)? parseInt(this.xpos) : this.parentobj.GetAbsposX()+parseInt(this.xpos)}
function LayerGetAbsposY(){return (!this.parentobj)? parseInt(this.ypos) : this.parentobj.GetAbsposY()+parseInt(this.ypos)}
//----------------------------------------------------------------------------------------------------------------------------------------------------------------------Loadsource
// Layer-Loader
DynamicLayer.prototype.LoadSource = LayerLoadsource
function LayerLoadsource(url) {
		if (isNS4) {		
				//alert("load")
				this.css.load(url,600)
		}
        else if (isIE4){
				bufferFrame.document.location = url
		}
}
function LoadSourceFinish(id){
	if (isIE4) document.all[id].innerHTML = bufferFrame.document.body.innerHTML
}
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------Ease
function ease(starttime,now,duration,mode){
		switch(mode){
			case 1: factor = (now - starttime)/duration												;break;				//Linear
			case 2: factor = Math.sin(((now - starttime)/duration) * (0.5*Math.PI))					;break;				//Ease out
			case 3: factor = 1-(Math.cos(((now - starttime)/duration) * (0.5*Math.PI)))				;break;				//Ease in
			case 4: factor = (Math.cos((((now - starttime)/duration) * Math.PI)+Math.PI)+1)/2 		;break;				//Ease in & out
			case 5: factor = Math.sin(((now - starttime)/duration) * 2)*1.1							;break;				//Ease out mit bounce
			case 6: factor = ((Math.sin((((now - starttime)/duration) * 4)-2)*1.1)+1)/2				;break;				//Ease in & out mit bounce
			
			default: factor = (now - starttime)/duration											;break;				//Linear
		}
		return factor;
}
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------