// --------------------
// Funktion zur Anzeige der BrowserInfos
//
// function whoAmI
//
// Die BrowserInfos (und das Betriebsystem) werden in das Dokument geschrieben
//

function whoAmI(){
	var browserInfo = "<ul>";
	for(var i in cD){
		browserInfo += "<li>client." + i + " = " + cD[i] + "</li>";
	}
	browserInfo += "</ul>";
	document.write(browserInfo);
}


// --------------------
// Funktion zur Anzeige einer Objektstruktur in einem alert
// nuetzlich zum debuggen :-)
//
// function showObjTree
// param obj : Objekt, dessen Struktur angezeigt werden soll
// param objName : Name des Objekts (beliebiger String - nicht unbedingt notwendig)
//

function showObjTree(obj, objName){
	var count = 0;
	var result = ""
	for(var i in obj){
		result += objName + "." + i + " = " + obj[i] + "\n";
		count++;
	}
	alert( result );
	return result
}


// --------------------
// Funktion zur Anzeige einer Objektstruktur im document
//
// function showObjTree
// param obj : Objekt, dessen Struktur angezeigt werden soll
// param objName : Name des Objekts (beliebiger String)
//

function showObjTreeInDoc(obj, objName){
	var count = 0;
	var result = ""
	for(var i in obj){
		result += objName + "." + i + " = " + obj[i] + "<br>";
		count++;
	}
	document.write(result);
}


// --------------------
// Funktion zur Erkennung des Browsers
// die informationen sind im objekt cD verfuegbar
//
// function clientDetection
//

function clientDetection(){
	var agt = navigator.userAgent.toLowerCase();
	
	this.platform = navigator.platform.toLowerCase();
	this.name = agt;
	
	this.major = parseInt(navigator.appVersion);
	this.minor = parseFloat(navigator.appVersion);
	
	this.nav  = ((agt.indexOf('mozilla')!=-1) && ((agt.indexOf('spoofer')==-1) && (agt.indexOf('compatible') == -1)));
	this.nav2 = (this.nav && (this.major == 2));
	this.nav3 = (this.nav && (this.major == 3));
	this.nav4 = (this.nav && (this.major == 4));
	this.nav6 = (this.nav && (this.major == 5));
	
	this.ie   = (agt.indexOf("msie") != -1);
	this.ie3  = (this.ie && (this.major == 2));
	this.ie4  = (this.ie && (this.major == 4));
	
	this.opera = (agt.indexOf("opera") != -1);
	
	this.nav6up = this.nav && (this.major >= 5);
	this.ie4up  = this.ie  && (this.major >= 4);
}

var cD = new clientDetection();


// --------------------
// Funktion zum Finden eines Objekts/Layers
//
// function getElt
// param id : Id des gesuchten Objekts
// param doc : document-Objekt, in dem (bei Netscape 4.x) begonnen werden soll, nach dem objekt/layer zu suchen
//
// return : das Objekt mit der Id id
//

function getElt(id, doc){
	if(cD.nav4){
		var currentLayer;
		var currentDoc;
		if(!doc){
			currentDoc = document;
		}
		else{
			currentDoc = doc;
		}
		currentLayer = currentDoc.layers[id];
		for(var i=0;!currentLayer && i < currentDoc.layers.length;i++){
			currentLayer = getElt(id, currentDoc.layers[i].document);
		}
		return currentLayer;
	}
	else if(cD.ie4up) {
		var elt = eval('document.all.' + id);
		return(elt);
	}
	else if(cD.nav6up || cD.opera){
		var elt = document.getElementById(id);
		return(elt);
	}
}



// --------------------
// Funktion zur Festlegung der Sichtbarkeit eines Objekts/Layers
//
// function setEltVisibility
// param elt : Objekt, dessen Sichtbarkeit geändert wird
// param value : Sichtbarkeit des Objekts -> 'visible','hidden'
//

function setEltVisibility(elt, value){
	if(cD.nav4) elt.visibility = value;
	else if(cD.ie4up || cD.nav6up || cD.opera) elt.style.visibility = value;
}

// --------------------
// Funktion zur Abfrage der Sichtbarkeit eines Objekts/Layers
//
// function getEltVisibility
// param elt : Objekt, dessen Zustand abgefragt wird
//
// return : Zustand der Sichtbarkeit des Objekts/Layers -> 'visible','hidden'
//

function getEltVisibility(elt){
	if(cD.nav4){
		var value = elt.visibility;
		if(value == "show") return "visible";
		else if(value == "hide") return "hidden";
		else return value;
	}
	else if(cD.ie4up || cD.nav6up || cD.opera) return elt.style.visibility;
}

// --------------------
// Funktion zur Abfrage der ABSOLUTEN vertikalen Position eines Objekts/Layers
// bei getEltTop gab es Probleme im IE
//
// function getEltPosTop
// param elt : Objekt, dessen vertikale Position abgefragt wird
//
// return : vertikale ABSOLUTE Position des Objekts/Layers ab Dokumentoberkante
//
 
function getEltPosTop(elt){
    if(cD.nav4) return (elt.pageY);
    else if(cD.ie4up){
        return (elt.offsetParent) ? elt.offsetTop+getEltPosTop(elt.offsetParent) : elt.offsetTop;
    }
    else if(cD.nav6up || cD.opera) return (elt.offsetTop);
}
 
function getEltTopNew(elt){
//if(elt.offsetTop){
//return elt.offsetTop;
//}
if(elt){
      return (elt.offsetParent) ? elt.offsetTop+getEltTopNew(elt.offsetParent) : elt.offsetTop;
}
}
// --------------------
// Funktion zur Abfrage der ABSOLUTEN horizontalen Position eines Objekts/Layers//
// bei getEltLeft gab es Probleme im IE
// function getEltPosLeft
// param elt : Objekt, dessen vertikale Position abgefragt wird
//
// return : horizontale ABSOLUTE Position des Objekts/Layers ab Dokumentoberkante
//
 
function getEltPosLeft(elt){
    if(cD.nav4) return (elt.pageX);
    else if(cD.ie4up){
        return (elt.offsetParent) ? elt.offsetLeft+getEltPosLeft(elt.offsetParent) : elt.offsetLeft;
    }
    else if(cD.nav6up || cD.opera) return (elt.offsetLeft);
}

// --------------------
// Funktion zur Festlegung der vertikalen Position eines Objekts/Layers
//
// function setEltTop
// param elt : Objekt, dessen vertikale Position festgelegt wird
// param y : vertikale Position des Objekts/Layers ab Dokumentoberkante
//

function setEltTop(elt, y){
	if(cD.nav4) elt.top=y;
	else if(cD.ie4up) elt.style.pixelTop=y;
	else if(cD.nav6up) elt.style.top=y+"px";
	else if(cD.opera) elt.style.top=y;
}

// --------------------
// Funktion zur Abfrage der vertikalen Position eines Objekts/Layers
//
// function getEltTop
// param elt : Objekt, dessen vertikale Position abgefragt wird
//
// return : vertikale Position des Objekts/Layers ab Dokumentoberkante
//

function getEltTop(elt){
	if(cD.nav4) return (elt.top);
	else if(cD.ie4up) return (elt.style.pixelTop);
	else if(cD.nav6up || cD.opera) return (parseInt(elt.offsetTop));
}


// --------------------
// Funktion zur Festlegung der horizontalen Position eines Objekts/Layers
//
// function setEltLeft
// param elt : Objekt, dessen horizontale Position festgelegt wird
// param x : horizontale Position des Objekts/Layers ab Dokumentoberkante
//

function setEltLeft(elt, x){
	if(cD.nav4) elt.left=x;
	else if(cD.ie4up) elt.style.pixelLeft=x;
	else if(cD.nav6up) elt.style.left=x + "px";
	else if(cD.opera) elt.style.left=x;
}


// --------------------
// Funktion zur Abfrage der horizontalen Position eines Objekts/Layers
//
// function getEltLeft
// param elt : Objekt, dessen vertikale Position abgefragt wird
//
// return : horizontale Position des Objekts/Layers ab Dokumentoberkante
//

function getEltLeft(elt){
	if(cD.nav4) return (elt.left);
	else if(cD.ie4up) return (elt.style.pixelLeft);
	else if(cD.nav6up || cD.opera) return (parsseInt(elt.style.left));
}


// --------------------
// Funktion zur Festlegung der absoluten Position eines Objekts/Layers
//
// function moveEltTo
// param elt : Objekt, dessen absolute Position festgelegt wird
// param x : horizontale Position des Objekts/Layers ab Dokumentoberkante
// param y : vertikale Position des Objekts/Layers ab Dokumentoberkante
//

function moveEltTo(elt, x, y){
	if(cD.nav4) elt.moveTo(x, y);
	else if(cD.ie4up){
		elt.style.pixelLeft = x;
		elt.style.pixelTop = y;
	}
	else if(cD.nav6up){
		elt.style.left = x + "px";
		elt.style.top = y + "px";
	}
	else if(cD.opera){
		elt.style.left = x;
		elt.style.top = y;
	}
}


// --------------------
// Funktion zur Festlegung der relativen Position eines Objekts/Layers
//
// function moveEltBy
// param elt : Objekt, dessen relative Position festgelegt wird
// param x : horizontale Bewegung des Objekts/Layers
// param y : vertikale Bewegung des Objekts/Layers
//

function moveEltBy(elt, x, y){
	if(cD.nav4) elt.moveBy(x, y);
	else if(cD.ie4up || cD.opera){
		elt.style.pixelLeft += x;
		elt.style.pixelTop  += y;
	}
	else if(cD.nav6up){
		moveEltTo(elt, parseInt(elt.style.left) + x, parseInt(elt.style.top) + y);
	}
}


// --------------------
// Funktion zur Abfrage der Breite eines Objekts/Layers
//
// function getEltWidth
// param elt : Objekt, dessen Breite abgefragt wird
//
// return : Breite des Objekts/Layers in Pixel
//

function getEltWidth(elt){
	if(cD.nav4) return(elt.width);
	else if(cD.ie4up || cD.opera) return(elt.style.pixelWidth);
	else if(cD.nav6up) return(elt.style.width);
}


// --------------------
// Funktion zur Abfrage der Höhe eines Objekts/Layers
//
// function getEltHeight
// param elt : Objekt, dessen Höhe abgefragt wird
//
// return : Höhe des Objekts/Layers in Pixel
//

function getEltHeight(elt){
	if(cD.nav4) return (elt.height);
	else if(cD.ie4up || cD.opera) return (elt.style.pixelHeight);
	else if(cD.nav6up) return (elt.style.height);
}


// --------------------
// Funktion zur Abfrage der Breite des Inhalts des Browserfensters
//
// function getClientWidth
//
// return : Breite des Browserfensters in Pixel
//

function getClientWidth(){
	if(cD.nav4) return(window.innerWidth);
	else if(cD.ie4up) return(document.body.clientWidth);
	else if(cD.nav6up || cD.opera) return(window.innerWidth);
}


// --------------------
// Funktion zur Abfrage der Höhe des Browserfensters
//
// function getClientHeight
//
// return : Breite des Browserfensters in Pixel
//

function getClientHeight(){
	if(cD.nav4) return(window.innerHeight);
	else if(cD.ie4up) return(document.body.clientHeight);
	else if(cD.nav6up || cD.opera) return(window.innerHeight);
}


// --------------------
// Funktion zum erzeugen eines Layers 
//
// function createLayer
// param name : id des Layers
// param html : der Inhalt des Layers
// param css  : die css-Klasse des Layers
//

function createLayer(name, html, css){
    with(document){
        write("<div id='"+name+"' class='"+css+"'>"+html+"</div>");
    }
} 

// --------------------
// Funktion zum neufuellen eines Layers 
//
// function writeIntoLayer
// param elt : Objekt, dessen Inhalt neu gefuellt wird
// param text : HTML-Text, der in den Layer geschrieben werden soll
//
// Netscape4 und Netscape6 sind darauf angewiesen, dass der Layer in den geschrieben wird
// absolut positioniert ist. Soll er dennoch an einer bestimmten Stelle des Dokumentes
// angezeigt werden, muss er in einen zweiten Layer eingebettet werden, der wiederum relativ
// positioniert ist. Fein!
// Beispiel:
// <style type="text/css">
// #hilf_mir {position:relative}
// #beschreib_mich {position:absolute}
// </style>
// <table><tr><td>
//     <div id="hilf_mir"><div id="beschreib_mich"></div></div>
// </td></tr></table>
//
// Opera 6.0 Pre interpretiert diese Funktion nicht! Der Opera-Spec ist nichts zu entnehmen, was Aufschluss
// darüber gibt ob das in Zukunft anders werden wird.

function writeIntoLayer(elt, text)
{
if(elt)
{
if(cD.nav4)
{
with(elt.document)
{
open();
write(text);
close();
}
}
if(cD.ie4up || cD.nav6up)
{
elt.innerHTML = text;
}
if (cD.opera){
return false;
}
}
}

// --------------------
// Funktion zur Festlegung des z-index eines Objekts/Layers
//
// function setEltZIndex
// param elt : Objekt, dessen z-index festgelegt wird
// param z : z-index
//

function setEltZIndex(elt, z){
	if(cD.nav4) elt.zIndex = z;
	else if(cD.ie4up) elt.style.zIndex = z;
	else if(cD.opera) elt.style.zIndex = z;
	else if(cD.nav6up) elt.style.zIndex = z;
}


// --------------------
// Funktion zur Abfrage des z-index eines Objekts/Layers
//
// function getEltZIndex
// param elt : Objekt, dessen z-index abgefragt wird
//
// return : der z-index des Objekts/Layers
//

function getEltZIndex(elt){
	if(cD.nav4) return(elt.zIndex);
	else if(cD.ie4up) return (elt.style.zIndex);
	else if(cD.nav6up) return (elt.style.zIndex);
	else if(cD.opera) return (elt.style.zIndex);
}


//Die folgenden Funktionen sind noch nicht Opera-Kompatibel

// --------------------
// Funktion zum Erzeugen eines EventListeners
//
// function addEltEventListener
// param elt : Element, das mit dem Handler belegt wird
// param event : Das Event (MOUSEUP | MOUSEDOWN | MOUSEMOVE)
// param func : Die Funktion, die aufgerufen werden soll
//

function addEltEventListener(myElt, myEvent, myFunc){
	if(cD.nav4 || cD.ie4up){
		var isThis = "";
		if(cD.nav4){
			isThis = "this.";
		}
		eval("myElt.on" + myEvent.toLowerCase() + "=" + isThis + myFunc);
	}
	else if(cD.nav6up){
		eval("myElt.addEventListener('" + myEvent.toLowerCase() + "', " + myFunc + ", false)");
	}
}


// --------------------
// Funktion zum Erzeugen eines EventListeners
//
// function addEltEventListener2
// param elt : Element, das mit dem Handler belegt wird
// param event : Das Event (MOUSEUP | MOUSEDOWN | MOUSEMOVE)
// param func : Die Funktion, die aufgerufen werden soll
//

function addEltEventListener2(myElt, myEvent, myFunc){
	if(cD.nav4 || cD.ie4up){
		if(cD.nav4){
			eval("myElt.captureEvents(Event." + myEvent + ")");
		}
		eval("myElt.on" + myEvent.toLowerCase() + "=" + myFunc);
	}
	else if(cD.nav6up){
		eval("myElt.addEventListener('" + myEvent.toLowerCase() + "', " + myFunc + ", false)");
	}
}

// --------------------
// Funktion zum Erzeugen eines EventListeners für das Fenster
//
// function addWinEventListener
// param event : Das Event (MOUSEUP | MOUSEDOWN | MOUSEMOVE)
// param func : Die Funktion, die aufgerufen werden soll
//

function addWinEventListener(myEvent, myFunc){
	if(cD.nav4 || cD.ie4up){
		if(cD.nav4){
			eval("captureEvents(Event." + myEvent + ")");
			eval("on" + myEvent.toLowerCase() + "=" + myFunc);
		}
		else{
			eval("document.on" + myEvent.toLowerCase() + "=" + myFunc);
		}
	}
	else if(cD.nav6up){
		eval("addEventListener('" + myEvent.toLowerCase() + "', " + myFunc + ", false)");
	}
}

//Jetzt sollte es auch der Opera wieder tun!

// --------------------
// Funktion zum Öffnen eines zentrierten PopUp-Fensters
//
// function openWinCenter
// param url : URL, die im Fenster geöffnet werden soll
// param w : Breite des Fensters (width)
// param h : Höhe des Fensters (height)
// param winName : Name des Fensters
// param winDescr : Weitere Parameter, die an das neue Fenster übergeben werden sollen
//

function openWinCenter(url, w, h, winName, winDescr) {
	if(!winName){
		winName = '';
	}
	if(!winDescr){
		winDescr = '';
	}
	else{
		winDescr = ',' + winDescr;
	}
	var x = Math.round((screen.availWidth - w) / 2);
	var y = Math.round((screen.availHeight - h) / 2);
	winDescr = 'left=' + x + ',top=' + y + ',width=' + w + ',height=' + h + winDescr;
	var ww = open (url, winName, winDescr);
	return ww;
}


// --------------------
// Funktion zum neuladen des Fensters, wenn die fenstergroesse geaendert wird
// dies ist sinnvoll, wenn die groesse des fensters bei netscape veraendert wird, weil dann js-code und css zerschossen wird
//
// function reloadOnResize
//

function reloadOnResize() {
	addWinEventListener('RESIZE', 'reloadLocation');
}

// --------------------
// Funktion zum neuladen des fensters
//
// function reloadLocation
//

function reloadLocation() {
	location.reload();
}

// --------------------
// Funktion zum Öffnen einer seite aus einem Popup heraus
//
// function openFromPopup
// param url : URL, die im parent-Fenster geöffnet werden soll
// param closeMe : parameter, der bestimmt, ob popup weiter offen ist oder geschlossen wird (1 -> popup wird geschlossen, 0 -> popup bleibt im hintergrund bestehen)
//
 
function openFromPopup(url, closeIt) {
    if(opener){
        opener.location.href=url;
        opener.focus();
        if(closeIt){
            self.close();
        }
    }
}
                                                                                
// -------------------- 
// Funktion zum Herausfinden der aktuellen vertikalen Scrollposition
// 
// function getScrollTop 
// 
// return: die y-Scroll-Position 
//

function getScrollTop(){
    if(cD.nav4 || cD.nav6up || cD.opera){
        return window.pageYOffset;
    }
    if(cD.ie){
        return document.body.scrollTop;
    }
}

// -------------------- 
// Funktion zum Automatischen mitscrollen eines Elements
// 
// function scrollElement 
// 

function scrollElement() {
    var myElt = getElt(scrollElementName);
    var Dif = parseInt((getScrollTop()+topMenuPos-getEltTop(myElt))*fadeValue);
    if (isNaN(Dif)){
        Dif=0;
    }
    if(Math.abs(Dif) < 1 && (getScrollTop()+topMenuPos-getEltTop(myElt) != 0)){
        if(getScrollTop()+topMenuPos-getEltTop(myElt) > 0){
            Dif = 1;
        }
        else{
            Dif = -1;
        }
    }
    if(Math.abs(Dif) > 0){
        setEltTop(myElt, getEltTop(myElt) + Dif);
    }
}

// -------------------- 
// Funktion zum Initialisieren des Scrollelements
// 
// function loadScrollElement 
// 

function loadScrollElement() {
    if(cD.nav6up || cD.ie){
        setEltTop(getElt(scrollElementName), topMenuPos);
    }
    window.setInterval("scrollElement()",20)
}


// --------------------
// Dynamische Navigation
// start
//

// Variablendeklaration
// Wird beim Verlassen eines Menue-DIV's mit einer TimeOutId versehen und beim Betreten gelöscht
var TIMEOUTID;
// Flag ist gesetzt, wenn sich Mauszeiger über einem Menue befindet
var overFlag = 0;
var killAll = 0;
// Variable, die mit einem zu veränderndem Objekt gefüllt wird
var myElt;
// Erster Teil des Bildnamens bei einem Rollover-Effekt
var imgName = '';
// Erster Teil des Bildnamens bei einem Rollover-Effekt
var imgMapName = '';                                                            
// Name des aktuell sichtbar gemachten Menues 
var menuNumber = 0;
// Name des aktuell sichtbar gemachten Bildes (Rollover) 
var imgNumber = -1;
// Länge der Verzögerung des Wiedererscheinens oder Verschwindens der Menues
var timeoutLength = 200;
// Array in dem die Menuenamen gespeichert werden, die sichtbar sein muessen
var levelArr = new Array();
// Array mit Bildern, die bei einem Rollover sichtbar werden sollen
var imgOnArr = new Array();
// Array mit Bildern, die bei einem Rollout sichtbar werden sollen
var imgOffArr = new Array();
// Array mit Bildern, die bei einem Rollover sichtbar werden sollen
var imgMapOnArr = new Array();
// Array mit Bildern, die bei einem Rollout sichtbar werden sollen
var imgMapOff;                                                                  
// Anzahl Root Menuepunkte
var rootCount;
// Name des Menues, dass immer sichtbar ist 
var aktivMenu;


// --------------------
// Funktion zum Anzeigen eines neuen Menues
//
// function enterBaseMenu
// param m : Name des Menues, dass neu angezeigt werden soll
//

function enterBaseMenu(m, n){
	window.clearTimeout(TIMEOUTID);
	if(m.split("x").length == 1){
		if(levelArr.length == 1){
			if(levelArr[0] == m){
				return true;
			}
		}
		removeAllLevels();
		window.clearTimeout(TIMEOUTID);
		overFlag = 0;
		setAllOriginal();
		overFlag = 1;
		imgOver(n);
	}
	addLevel(m);
	hideAllMenues();
	menuNumber = m;
	overFlag = 0;
    if(aktivMenu){
        myElt = getElt(aktivMenu);
        if(myElt){
            setEltVisibility(myElt, 'hidden');
        }
    }
	myElt = getElt(menuNumber);
	var imgElt = getElt(imgName+n);
	if(myElt){
		myElt.style.top=getEltTopNew(imgElt) - 1;
		//moveEltTo(myElt, myElt.style.left, getEltTopNew(imgElt) - 1);
		//moveEltTo(myElt, 178, getEltTopNew(imgElt) - 1);
		setEltVisibility(myElt, 'visible');
	}
	return true;
}


// --------------------
// Funktion zum Verstecken des aktuellen Menues
//
// function exitBaseMenu
//

function exitBaseMenu(){
	TIMEOUTID = window.setTimeout("hideMenu()", timeoutLength);
	return true;
}


// --------------------
// Funktion zum verstecken aller Menues (ausser die, die noch sichtbar sein sollen -> parentLevel)
//
// function hideAllMenues
//

function hideAllMenues(){
	window.clearTimeout(TIMEOUTID);
	killAll = 1;
	for(var i = 0;i < menuArr.length;i++){
		menuNumber = menuArr[i];
		if(!parentLevel()){
			killMenu();
		}
	}
 killAll = 0;
}


// --------------------
// Funktion zum Verstecken des aktuellen Menues
//
// function killMenu
//

function killMenu(){
	if((menuNumber.length > 0) || killAll){
		myElt = getElt(menuNumber);
		if(myElt) setEltVisibility(myElt, 'hidden');
	}
}


// --------------------
// Funktion zum Setzen eines TimeOuts und dem loeschen des zuletzt geoeffneten Menues
//
// function hideMenu
//

function hideMenu(){
	window.clearTimeout(TIMEOUTID);
	if(overFlag == 0){
		removeLevel();
		killMenu();
        if(aktivMenu){
            myElt = getElt(aktivMenu);
            if(myElt){
                setEltVisibility(myElt, 'visible');
            }
        }
	}
	TIMEOUTID = window.setTimeout("setAllOriginal()", timeoutLength);
}


// --------------------
// Funktion zum Wiederherstellen des Ursprungszustands
//
// function setAllOriginal
//

function setAllOriginal(){
	window.clearTimeout(TIMEOUTID);
	if(overFlag == 0){
		removeAllLevels();
		hideAllMenues();
		setImgOriginal();
	}
}


// --------------------
// Funktion zum Anfügen eines Menues in levelArr
//
// function addLevel
// param l : Name des Menues, dass an das Array angefuegt werden soll
//

function addLevel(l){
	if(levelArr.length == 0){
		levelArr[levelArr.length] = l;
	}
	else if(levelArr[levelArr.length - 1].split("x").length < l.split("x").length){
		levelArr[levelArr.length] = l;
	}
	else{
		levelArr[levelArr.length - 1] = l;
	}
}


// --------------------
// Funktion zum Entfernen eines Menues in levelArr
//
// function removeLevel
//

function removeLevel(){
	var tmpArr = levelArr;
	levelArr = new Array();
	for(var i=0;i<(tmpArr.length-1);i++){
		levelArr[i] = tmpArr[i];
	}
}


// --------------------
// Funktion zum löschen des levelArr
//
// function removeAllLevels
//

function removeAllLevels(){
	levelArr = new Array();
	menuNumber = "";
}

// --------------------
// Funktion zur Prüfung, ob das aktuelle menuNumber sichtbar sein soll
//
// function parentLevel
//

function parentLevel(){
	for(var j=0;j<levelArr.length;j++){
		if(levelArr[j] == menuNumber){
			return true;
		}
	}
	return false;
}


// --------------------
// Funktion zum Erzeugen der EventListener feur alle Menues
//
// function setMenuEltEventListeners
//

function setMenuEltEventListeners(){
	for(var i=0;i<menuArr.length;i++){
		myElt = getElt(menuArr[i]);
		if(myElt){
			addEltEventListener(myElt, 'MOUSEOVER', 'enterMenu');
			addEltEventListener(myElt, 'MOUSEOUT', 'exitMenu');
		}
	}
}

// --------------------
// Funktion zum setzen eines neuen TimeOuts, wenn sich ein aufgeklapptes Menue oeffnet
//
// function enterMenu
//

function enterMenu(){
	window.clearTimeout(TIMEOUTID);
	overFlag = 1;
	return true;
}


// --------------------
// Funktion zum loeschen des TimeOuts beim Verlassen eines Menues
//
// function exitMenu
//

function exitMenu(){
	overFlag = 0;
	TIMEOUTID = window.setTimeout("exitBaseMenu()", timeoutLength);
	return true;
}


// --------------------
// Funktion zum setzen des overFlag bei Bewegung ueber einem Menue
//
// function setFlag
//

function setFlag(){
	overFlag = 1;
	return true;
}

// --------------------
// Funktion für imgRollover
//
// function imgOver
// param n : Restname des Bildes (Zahl)
//
 
function itemImgOver(n){
    if(itemImgName.length > 0){
        var myImg = getImg(itemImgName + n);
        if(myImg){
            myImg.src = itemImgOn.src;
        }
    }
}

// --------------------
// Funktion für imgRollover
//
// function imgOut
// param n : Restname des Bildes (Zahl)
//
 
function itemImgOut(n){
    if(itemImgName.length > 0){
        var myImg = getImg(itemImgName + n);
        if(myImg){
            myImg.src = itemImgOff.src;
        }
    }
}                                                                               

// --------------------
// Funktion für imgRollover
//
// function imgOver
// param n : Restname des Bildes (Zahl)
//

function imgOver(n){
	if(imgName.length > 0){
		var myImg = getImg(imgName + n);
		if(myImg){
			myImg.src = imgOnArr[n].src;
		}
	}
}


// --------------------
// Funktion für imgRollover
//
// function imgOut
// param n : Restname des Bildes (Zahl)
//

function imgOut(n){
	if(imgName.length > 0){
		var myImg = getImg(imgName + n);
		if(myImg){
			myImg.src = imgOffArr[n].src;
		}
	}
}


// --------------------
// Funktion für imgRollover
//
// function imgOver
// param n : Restname des Bildes (Zahl)
//
 
function imgMapOver(n){
    if(imgMapName.length > 0){
        var myImg = getImg(imgMapName);
        if(myImg){
            myImg.src = imgMapOnArr[n].src;
        }
    }
}
 
 
// --------------------
// Funktion für imgRollover
//
// function imgOut
// param n : Restname des Bildes (Zahl)
//
 
function imgMapOut(){
    if(imgMapName.length > 0){
        var myImg = getImg(imgMapName);
        if(myImg){
            myImg.src = imgMapOff.src;
        }
    }
}                                                                               

// --------------------
// Funktion zum Finden eines Bildes in einem Dokument
//
// function getImg
// param n : Name des Bildes
// param doc : document-Objekt, in dem (bei Netscape 4.x) begonnen werden soll, nach dem Bild zu suchen
//

function getImg(n, doc){
	if(!cD.nav4){
		return document.images[n];
	}
	else{
		var currentImage;
		var currentDoc;
		if(!doc){
			currentDoc = document;
		}
		else{
			currentDoc = doc;
		}
		currentImage = currentDoc.images[n];
		for(var i=0;!currentImage && i < currentDoc.layers.length;i++){
			currentImage = getImg(n, currentDoc.layers[i].document);
		}
		return currentImage;
	}
}


// --------------------
// Funktion zum Zurücksetzen der Bilder in den Ursprungszustand
//
// function setImgOriginal
//

function setImgOriginal(){
	if(imgName.length > 0){
		for(var i=0;i<rootCount;i++){
			var myImg = getImg(imgName + i);
			if(myImg){
				myImg.src = imgOffArr[i].src;
			}
		}
	}
}


// --------------------
// Funktion zum Zurücksetzen der Bilder in den Ursprungszustand
//
// function setImgOriginal
//

function setMenuPositions(){
	for(var i=0;i < menuArr.length;i++){
		myElt = getElt(menuArr[i]);
		if(myElt){
			moveEltTo(myElt, xMenuPosArr[i], yMenuPosArr[i]);
		}
	}
}

//
// Dynamische Navigation
// ende
// --------------------