function ShowDiv(id) {
    var theObject;
    theObject = document.getElementByName(id);
    theObject.style.display="block";
    return true;
}


/* 'Wechsle Darstellung 051006' (c) by cybaer@binon.net
   ----------------------------
 Inhalt    : HTML-Elemente anzeigen oder verstecken (mit oder ohne Platzhalter, bzw. transparent)
 Aufruf    : toggle(type,element,toggleID[,xID[,xID[,...[,xSwitch]]]])
 Parameter : type (Aktionstyp: 1. fold (voreingestellt)/unfold: Ohne Platzhalter verstecken/zeigen
                                  (optional kann die Darstellungsart angehaengt werden, z.B. unfold:block)
                               2. hide/unhide: Mit Platzhalter verstecken/zeigen
                               3. trans: Transparenz wechseln (optional kann der gewuenschte Grad
                                  der Transparenz, sowie die Komplementaertransparenz angehaengt
                                  werden, z.B. trans:50/0 - diese Werte sind voreingestellt)
                               4. color: Vordergrund-Farbe wechseln (optional kann die gewuenschte
                                  Farbe, sowie die Farbe f?r die Komplementaerfunktion angehaengt
                                  werden, z.B. color:#000000/#FFFFFF - diese Werte sind voreingestellt)
                               5. back: Hintergrund-Farbe wechseln (optional kann die gewuenschte
                                  Farbe, sowie die Farbe f?r die Komplementaerfunktion angehaengt
                                  werden, z.B. back:#FFFFFF/#000000 - diese Werte sind voreingestellt)
                               6. border: Hintergrund-Farbe wechseln (optional kann die gewuenschte
                                  Farbe, sowie die Farbe f?r die Komplementaerfunktion angehaengt
                                  werden, z.B. border:transparent/black - diese Werte sind voreingestellt)
                               7. test: Ueberpruefung der Browserfaehigkeit
                   auch kombinierbar: z.B. "unfold hide" oder "unfold:block hide")
             element (1. ID des Elements, das bearbeitet werden soll, oder
                      2. Tagname der Elemente, die bearbeitet werden sollen (optional kann,
                         nach einem Doppelpunkt, ein Attributname uebergeben werden, sowie,
                         innerhalb geschweifter Klammern, ein Gueltigkeitsbereich), oder
                      3. leer (entspricht type="test"))
             toggleID (nur wenn element ein Tagname: einheitlicher Beginn (Basiskennung)
                       des Toggle-Attributs der gewuenschten Elemente)
             xID (optional: nur wenn element ein Tagname: (Rest-)Kennung(en) von Elementen,
                  die nicht erfasst werden sollen (Ausnahmen))
             xSwitch (optional: nur wenn element ein Tagname: Wenn true, dann wird bei den
                      mit xID definierten Ausnahmen die Komplementaerfunktion getogglet)
 Sprache   : JavaScript 1.1 (ungesichert), JavaScript 1.5 (gesichert)
 Quelle    : http://Coding.binon.net/Toggle (cybaer@binon.net)
             Die kostenlose Nutzung der Quelltexte in eigenen Projekten ist
             bei nicht-kommerziellen Projekten (und deren unentgeltlicher
             Herstellung) bei Nennung der Quelle ausdruecklich gestattet.
 InlineFunc: -
 Konstante : -
 Variable  : -
 SystemVar : -
 ExternVar : -
 Rueckgabe : Anzahl der bearbeiteten Elemente (auch 0), bzw. false, wenn der Einsatz technisch
             nicht moeglich ist und true, wenn er moeglich ist (Rueckgabewert des Testmodus).
 Anmerkung : 1. Auswahl per ID: Es wird exakt das Element mit der passenden ID behandelt. Wird
                kein passendes Element gefunden, wird der Parameter als Tagname interpretiert.
             2. Auswahl per Tagname: Jedes zu behandelnde Element muss das HTML-Attribut gid=""
                besitzen (wird in der Variablen toggleAttribute definiert - alternativ kann
                man ein eigenes Attribut in element uebergeben: "tr:id" fuer <tr id="">), mit
                einer einheitlichen Basiskennung am Anfang des Attributinhalts, gefolgt von
                einer beliebigen Restkennung. Wird bei z.B. toggle("fold",...) ein Element
                gefunden dessen Toggle-Attribut mit dieser Basiskennung beginnt, so wird dieses
                Element gefaltet. Wird ein passendes Element gefunden dessen (Rest-)Kennung
                aber als Ausnahme uebergeben wurde, so wird es nicht bearbeitet (xSwitch
                ist false oder leer), bzw. es wird explizit entfaltet (xSwitch ist true).
 Beispiele : HTML  : <tr id="TypA"><td>Zeile 1</td></tr>
                     <tr id="TypB"><td>Zeile 2</td></tr>
                     <tr id="TypC"><td>Zeile 3</td></tr>
             Script: toggle("fold","TypB")
             -> Zeile 2 wird ohne Platzhalter versteckt
             HTML  : <tr gid="TypA"><td>Zeile 1</td></tr>
                     <tr gid="TypB"><td>Zeile 2</td></tr>
                     <tr gid="TypB"><td>Zeile 3</td></tr>
                     <tr gid="TypC"><td>Zeile 4</td></tr>
                     <tr gid="TypD"><td>Zeile 5</td></tr>
             Script: toggle("fold","tr{0-4}","Typ")
             -> Alle Zeilen werden ohne Platzhalter versteckt (durchsucht werden nur die TRs Nr. 0-4)
             Script: toggle("fold","tr","Typ","A","D")
             -> Zeilen 2-4 werden ohne Platzhalter versteckt, Zeilen 1 & 5 werden nicht bearbeitet
             Script: toggle("fold","tr","Typ","A|D",true)
             -> Zeilen 2-4 werden ohne Platzhalter versteckt, Zeilen 1 & 5 werden angezeigt
             Script: toggle("hide","tr","Typ","B")
             -> Alle Zeilen werden mit Platzhalter versteckt, bis auf die Zeilen 2 & 3
             Script: toggle("unfold unhide","tr","Typ","C")
             -> Alle Zeilen werden angezeigt (egal ob vorher versteckt oder gefaltet), bis auf Zeile 4
*/

function toggle(type,element,toggleID) {
 // Lokale Variable definieren
 var i, j, t, type0, start=0, result=0;
 var obj, objName, objFirst=-1, objLast=-1, objCount, exceptions, lastArgument, xSwitch;
 var toggleDisplay, displayType, displayStyle, displayXStyle;
 var toggleVisibility, visibilityStyle, visibilityXStyle;
 var toggleOpacity, opacityType, opacityStyle, opacityXStyle, opacityStyleCSS, opacityXStyleCSS, opacityStyleMoz, opacityXStyleMoz, opacityStyleKHTML, opacityXStyleKHTML, opacityStyleIE, opacityXStyleIE;
 var toggleColor, colorType, colorXType, colorStyle, colorXStyle;
 var toggleBack, backType, backXType, backStyle, backXStyle;
 var toggleBorder, borderType, borderXType, borderStyle, borderXStyle;
 var toggleAttribute="gid"; // hier ggf. gewuenschten Standard-Attribut-Namen eintragen (z.B. "id")
 var showStatus=200; // hier eintragen, ab wieviel Elementen ein Bearbeitungshinweis erfolgen soll

 // Aktionstyp vereinheitlichen/definieren (Standard: "Falten")
 type=(type)?type.toLowerCase():"fold";

 // Wurde Elemente-Begrenzung uebergeben?
 if(element) {
  i=element.indexOf("{"); j=element.indexOf("}",i);
  if(i>=0 && j>=0) {
  objFirst=parseInt(element.substring(i+1,element.indexOf("-",i)));
  objLast=parseInt(element.substring(element.indexOf("-",i)+1,j));
  element=element.substring(0,i);
  }
 }

 // Nur Abfrage, ob toggle technisch moeglich ist?
 if(!element || type=="test") {
  result=(document.getElementsByTagName)?true:false;
 } else {

  // Aktionsflags definieren
  toggleDisplay=(type.indexOf("fold")+1);    // Style display verwenden
  toggleVisibility=(type.indexOf("hide")+1); // Style visibility verwenden
  toggleOpacity=(type.indexOf("trans")+1);   // Style opacity & Co. verwenden
  toggleColor=(type.indexOf("color")+1);     // Style color verwenden
  toggleBack=(type.indexOf("back")+1);       // Style background-color verwenden
  toggleBorder=(type.indexOf("border")+1);   // Style border-color verwenden

  // "Ent-/Falten" (Darstellung ohne Platzhalter: display)?
  // ------------------------------------------------------
  if(toggleDisplay) {
   // Standard-Darstellungsart
   displayType="";
   // Spezielle Darstellungsart uebergeben?
   i=type.indexOf("fold:");
   if(i>=0) {
    // Ja, also Trenn-Positionen der Art festlegen, ...
    i+=4; j=type.indexOf(" ",i)
    // ... und Aktion von Darstellungsart trennen
    displayType=type.substring(i+1,(j<0)?type.length:j);
    // Darstellungsart "none" aus logischen Gruenden nicht zulassen
    displayType=(displayType=="none")?"":displayType;
   }
   // Aktionsstyle und Ausnahmestyle festlegen
   if(type.indexOf("unfold")>=0) {
    displayStyle=displayType; displayXStyle="none";
   } else {
    displayStyle="none"; displayXStyle=displayType;
   }
  }

  // "Anzeigen/Verstecken" (Darstellung mit Platzhalter: visibility)?
  // ----------------------------------------------------------------
  if(toggleVisibility) {
   // Aktionsstyle und Ausnahmestyle festlegen
   if(type.indexOf("unhide")>=0) {
    visibilityStyle="visible"; visibilityXStyle="hidden";
   } else {
    visibilityStyle="hidden"; visibilityXStyle="visible";
   }
  }

  // "Durchscheinend" (transparente Darstellung: 'opacity')?
  // -------------------------------------------------------
  if(toggleOpacity) {
   // Standard-Deckungsgrad
   opacityType=50;
   // Komplementaere Standard-Deckungsgrad
   opacityXType=0;
   // Spezieller Transparenzwerte uebergeben?
   i=type.indexOf("trans:");
   if(i>=0) {
    // Ja, also Trenn-Positionen der Werte festlegen, ...
    i+=5; j=type.indexOf(" ",i)
    // ... und Aktion von Transparenzwerten trennen
    opacityType=type.substring(i+1,(j<0)?type.length:j);
    // Spezieller komplementaerer Transparenzwert uebergeben?
    i=opacityType.indexOf("/");
    if(i>=0) {
     // Ja, also Trenn-Positionen der Werte festlegen, ...
     j=opacityType.indexOf(" ",i)
     // ... und Transparenzwerte trennen
     opacityXType=opacityType.substring(i+1,(j<0)?opacityType.length:j);
     opacityType=opacityType.substring(0,i)+((j<0)?"":opacityType.substring(j,opacityType.length));
    }
   }
   // Aktionsstyle und Ausnahmestyle festlegen (Umwandlung Transparenz->Deckung von 0-100)
   opacityStyle=Math.min(100,Math.max(0,100-parseInt(opacityType)));
   opacityXStyle=Math.min(100,Math.max(0,100-parseInt(opacityXType)));
   // Fuer unterschiedliche Browser vordefinieren
   opacityStyleCSS=""+opacityStyle/100;
   opacityXStyleCSS=""+opacityXStyle/100;
   opacityStyleMoz=opacityStyleCSS;
   opacityXStyleMoz=opacityXStyleCSS;
   opacityStyleKHTML=opacityStyleCSS;
   opacityXStyleKHTML=opacityXStyleCSS;
   opacityStyleIE="alpha(opacity="+opacityStyle+")";
   opacityXStyleIE="alpha(opacity="+opacityXStyle+")";
  }

  // "Farbwahl (Vordergrund)" (Darstellung in Farbe: color)?
  // -------------------------------------------------------
  if(toggleColor) {
   // Standard-Darstellungsart
   colorType="#000000";
   // Komplementaere Standard-Darstellungsart
   colorXType="#FFFFFF";
   // Spezielle Darstellungsart uebergeben?
   i=type.indexOf("color:");
   if(i>=0) {
    // Ja, also Trenn-Positionen der Art festlegen, ...
    i+=5; j=type.indexOf(" ",i)
    // ... und Aktion von Darstellungsart trennen
    colorType=type.substring(i+1,(j<0)?type.length:j);
    // Spezielle komplementaere Darstellungsart uebergeben?
    i=colorType.indexOf("/");
    if(i>=0) {
     // Ja, also Trenn-Positionen der Art festlegen, ...
     j=colorType.indexOf(" ",i)
     // ... und Darstellungsarten trennen
     colorXType=colorType.substring(i+1,(j<0)?colorType.length:j);
     colorType=colorType.substring(0,i)+((j<0)?"":colorType.substring(j,colorType.length));
    }
   }
   // Aktionsstyle und Ausnahmestyle festlegen
   colorStyle=colorType;
   colorXStyle=colorXType;
  }

  // "Farbwahl (Hintergrund)" (Darstellung auf Farbe: background-color)?
  // -------------------------------------------------------------------
  if(toggleBack) {
   // Standard-Darstellungsart
   backType="#FFFFFF";
   // Komplementaere Standard-Darstellungsart
   backXType="#000000";
   // Spezielle Darstellungsart uebergeben?
   i=type.indexOf("back:");
   if(i>=0) {
    // Ja, also Trenn-Positionen der Art festlegen, ...
    i+=4; j=type.indexOf(" ",i)
    // ... und Aktion von Darstellungsart trennen
    backType=type.substring(i+1,(j<0)?type.length:j);
    // Spezielle komplementaere Darstellungsart uebergeben?
    i=backType.indexOf("/");
    if(i>=0) {
     // Ja, also Trenn-Positionen der Art festlegen, ...
     j=backType.indexOf(" ",i)
     // ... und Darstellungsarten trennen
     backXType=backType.substring(i+1,(j<0)?backType.length:j);
     backType=backType.substring(0,i)+((j<0)?"":backType.substring(j,backType.length));
    }
   }
   // Aktionsstyle und Ausnahmestyle festlegen
   backStyle=backType;
   backXStyle=backXType;
  }

  // "Farbwahl (Rahmen)" (Umrandung in Farbe: border-color)?
  // -------------------------------------------------------
  if(toggleBorder) {
   // Standard-Darstellungsart
   borderType="transparent";
   // Komplementaere Standard-Darstellungsart
   borderXType="black";
   // Spezielle Darstellungsart uebergeben?
   i=type.indexOf("border:");
   if(i>=0) {
    // Ja, also Trenn-Positionen der Art festlegen, ...
    i+=6; j=type.indexOf(" ",i)
    // ... und Aktion von Darstellungsart trennen
    borderType=type.substring(i+1,(j<0)?type.length:j);
    // Spezielle komplementaere Darstellungsart uebergeben?
    i=borderType.indexOf("/");
    if(i>=0) {
     // Ja, also Trenn-Positionen der Art festlegen, ...
     j=borderType.indexOf(" ",i)
     // ... und Darstellungsarten trennen
     borderXType=borderType.substring(i+1,(j<0)?borderType.length:j);
     borderType=borderType.substring(0,i)+((j<0)?"":borderType.substring(j,borderType.length));
    }
   }
   // Aktionsstyle und Ausnahmestyle festlegen
   borderStyle=borderType;
   borderXStyle=borderXType;
  }

  /* ----------------------- */
  /* Beginn der Hauptroutine */
  /* ----------------------- */

  // Toggling per ID?
  if(document.getElementById && document.getElementById(element)) {
   // ID gefunden: Kurzform fuer Element-Objekt definieren
   obj=document.getElementById(element);
   // Ein Element behandelt
   result=1;

   // Darstellung ohne Platzhalter
   // ----------------------------
   if(toggleDisplay) {
    // Display-Style setzen
    obj.style.display=displayStyle;
   }

   // Darstellung mit Platzhalter
   // ---------------------------
   if(toggleVisibility) {
    // Visibility-Style setzen
    obj.style.visibility=visibilityStyle;
   }

   // Transparente Darstellung
   // ------------------------
   if(toggleOpacity) {
    // "filter(Alpha)"-Style setzen (fuer IE)
    obj.style.filter=opacityStyleIE;
    // "-moz-opacity"-Style setzen (fuer Mozilla)
    obj.style.MozOpacity=opacityStyleMoz;
    // "-khtml-opacity"-Style setzen (fuer Konqueror und Safari)
    obj.style.KhtmlOpacity=opacityStyleKHTML;
    // "opacity"-Style setzen (fuer CSS 3)
    obj.style.opacity=opacityStyleCSS;
   }

   // Darstellung in Farbe
   // --------------------
   if(toggleColor) {
    // Color-Style setzen
    obj.style.color=colorStyle;
   }

   // Darstellung auf Farbe
   // ---------------------
   if(toggleBack) {
    // Background-Color-Style setzen
    obj.style.backgroundColor=backStyle;
   }

   // Umrandung in Farbe
   // ------------------
   if(toggleBorder) {
    // Border-Color-Style setzen
    obj.style.borderColor=borderStyle;
   }

  // ID nicht gefunden!
  } else if(document.getElementsByTagName) {
   // Enthaelt element nicht nur Tag-, sondern auch Attributnamen?
   i=element.indexOf(":");
   if(i>=0) {
    // Ja, also toggleAttribut neu definieren und element anpassen
    toggleAttribute=element.substring(i+1,element.length);
    element=element.substring(0,i);
   }

   // Sind gesuchtes Element vorhanden und eine Basiskennung definiert?
   if(document.getElementsByTagName(element).length && toggleID) {

    // Letzter Parameter ist true/false?
    lastArgument=(typeof(toggle.arguments[toggle.arguments.length-1])=="boolean")?-1:0;
    // "Switch"-Effekt?
    xSwitch=(lastArgument)?toggle.arguments[toggle.arguments.length-1]:false;
    // Ausnahme-Kennungen in einem String zusammenfassen (Basiskennung+Restkennung+Pipe-Symbol als Trenner)
    exceptions=toggleID; for(i=3;i<(toggle.arguments.length+lastArgument);i++) { exceptions+=toggle.arguments[i]+"|"; }
    i=exceptions.indexOf("|"); t=""; while(i>=0) { t+=exceptions.substring(start,i+1)+toggleID; start=i+1; i=exceptions.indexOf("|",start); if(!i) { break; } }
    exceptions=t.substring(0,t.length-toggleID.length);

    // Kurzform fuer Element-Objekt definieren
    obj=document.getElementsByTagName(element);
    // Start- und Endelement sowie zu bearbeitende Anzahl festlegen
    objFirst=(objFirst<0)?0:Math.max(0,objFirst);
    objLast=(objLast<0)?obj.length:Math.min(obj.length,objLast);
    objCount=(objLast-objFirst)+1;
    // Alle passenden Objekte durchgehen
    for(i=objFirst;i<objLast;i++) {
     // Kennung des aktuellen Elementes auslesen (und mit Trenner versehen)
     objName=obj[i].getAttribute(toggleAttribute);
     // Existiert Kennung und beginnt diese auch mit der Basiskennung?
     if(objName && objName.substring(0,toggleID.length)==toggleID) {
      // Anzahl der bearbeiteten Elemente erhoehen
      result++;
      // Element steht in der Ausnahmeliste?
      toggleException=(exceptions.indexOf(objName+"|")>=0)?true:false;
      // Wenn Anzahl ueber 100: Fortschritt in Statuszeile anzeigen
      if(objCount>showStatus) { window.status="Bearbeitetes Element: "+(result)+"/"+objCount; }

      // Darstellung ohne Platzhalter
      // ----------------------------
      if(toggleDisplay) {
       // Auf jeden Fall Style setzen (entweder/oder)?
       if(xSwitch) {
        // Display-Style unbedingt setzen
        obj[i].style.display=(toggleException)?displayXStyle:displayStyle;
       } else if(!toggleException) {
        // Einfachen Display-Style setzen
        obj[i].style.display=displayStyle;
       }
      }

      // Darstellung mit Platzhalter
      // ---------------------------
      if(toggleVisibility) {
       // Auf jeden Fall Style setzen (entweder/oder)?
       if(xSwitch) {
        // Visibility-Style unbedingt setzen
        obj[i].style.visibility=(toggleException)?visibilityXStyle:visibilityStyle;
       } else if(!toggleException) {
        // Visibility-Style nur bei gueltiger Kennung setzen
        obj[i].style.visibility=visibilityStyle;
       }
      }

      // Transparente Darstellung
      // ------------------------
      if(toggleOpacity) {
       // Auf jeden Fall Style setzen (entweder/oder)?
       if(xSwitch) {
        // Opacity-Styles unbedingt setzen (IE/Moz/KHTML/CSS 3)
        obj[i].style.filter=((toggleException)?opacityXStyleIE:opacityStyleIE);
        obj[i].style.MozOpacity=((toggleException)?opacityXStyleMoz:opacityStyleMoz);
        obj[i].style.KhtmlOpacity=((toggleException)?opacityXStyleKHTML:opacityStyleKHTML);
        obj[i].style.opacity=((toggleException)?opacityXStyleCSS:opacityStyleCSS);
       } else if(!toggleException) {
        // Opacity-Styles nur bei gueltiger Kennung setzen (IE/Moz/KHTML/CSS 3)
        obj[i].style.filter=opacityStyleIE;
        obj[i].style.MozOpacity=opacityStyleMoz;
        obj[i].style.KhtmlOpacity=opacityStyleKHTML;
        obj[i].style.opacity=opacityStyleCSS;
       }
      }

      // Darstellung in Farbe
      // --------------------
      if(toggleColor) {
       // Auf jeden Fall Style setzen (entweder/oder)?
       if(xSwitch) {
        // Color-Style unbedingt setzen
        obj[i].style.color=(toggleException)?colorXStyle:colorStyle;
       } else if(!toggleException) {
        // Color-Style nur bei gueltiger Kennung setzen
        obj[i].style.color=colorStyle;
       }
      }

      // Darstellung auf Farbe
      // ---------------------
      if(toggleBack) {
       // Auf jeden Fall Style setzen (entweder/oder)?
       if(xSwitch) {
        // Background-Color-Style unbedingt setzen
        obj[i].style.backgroundColor=(toggleException)?backXStyle:backStyle;
       } else if(!toggleException) {
        // Background-Color-Style nur bei gueltiger Kennung setzen
        obj[i].style.backgroundColor=backStyle;
       }
      }

      // Umrandung in Farbe
      // ------------------
      if(toggleBorder) {
       // Auf jeden Fall Style setzen (entweder/oder)?
       if(xSwitch) {
        // Border-Color-Style unbedingt setzen
        obj[i].style.borderColor=(toggleException)?borderXStyle:borderStyle;
       } else if(!toggleException) {
        // Border-Color-Style nur bei gueltiger Kennung setzen
        obj[i].style.borderColor=borderStyle;
       }
      }

     }
    }
    // Statuszeile wieder loeschen
    if(objCount>showStatus) { window.status=" "; }
   } else {
    // Dokument hat keine passenden Elemente
    result=0;
   }
  } else {
   // Browser kennt getElementsByTagName nicht
   result=false;
  }
 }
 return result;
}