function openSite(target, selectedObj, restore)
{
        eval(target + ".location='" + selectedObj.options[selectedObj.selectedIndex].value + "'");

        // reset drop down
        if (restore)
        {
                                eval(selectedObj + ".selectedIndex = 0");
        }
}

function MM_swapImgRestore() { //v3.0
  var i,x,a=document.MM_sr; for(i=0;a&&i<a.length&&(x=a[i])&&x.oSrc;i++) x.src=x.oSrc;
}

function MM_preloadImages() { //v3.0
  var d=document; if(d.images){ if(!d.MM_p) d.MM_p=new Array();
    var i,j=d.MM_p.length,a=MM_preloadImages.arguments; for(i=0; i<a.length; i++)
    if (a[i].indexOf("#")!=0){ d.MM_p[j]=new Image; d.MM_p[j++].src=a[i];}}
}

function MM_findObj(n, d) { //v4.01
  var p,i,x;
  if(!d) d=document;
  if((p=n.indexOf("?"))>0&&parent.frames.length) {
    d=parent.frames[n.substring(p+1)].document; n=n.substring(0,p);}
  if(!(x=d[n])&&d.all) x=d.all[n]; for (i=0;!x&&i<d.forms.length;i++) x=d.forms[i][n];
  for(i=0;!x&&d.layers&&i<d.layers.length;i++) x=MM_findObj(n,d.layers[i].document);
  if(!x && d.getElementById) x=d.getElementById(n); return x;
}

function MM_swapImage() { //v3.0
  var i,j=0,x,a=MM_swapImage.arguments; document.MM_sr=new Array; for(i=0;i<(a.length-2);i+=3)
   if ((x=MM_findObj(a[i]))!=null){document.MM_sr[j++]=x; if(!x.oSrc) x.oSrc=x.src; x.src=a[i+2];}
}


function gehe(seite)
{
  if (seite=="none")
   {
    document.forms[0].elements[0].blur;
    document.forms[0].elements[0].reset();
   }
   else if ((seite.indexOf("http") == -1) && (seite.indexOf("pdf") == -1))
   {
    self.location.href=seite;
    document.forms[0].elements[0].blur;
   }
   else
   window.open(seite);
   document.forms[0].elements[0].blur;
}

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);
}

// --------------------
// 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.style.top));
}


// --------------------
// 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 enterball4
// 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);
        if(myElt){
                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;
                }
        }
}


var menuArr = new
Array('menu0','menu1','menu2','menu3','menu4','menu5');
var xMenuPosArr = new Array(120,120,120,120,120,120);
var yMenuPosArr = new Array(310,310,330,310,355,380);
function preLoad(){
    setMenuEltEventListeners();
    setMenuPositions();
}

// --------------------
// 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
// --------------------