/*
  
  - Inhaltsangabe
  	Funktionen zum Erzeugen und Verwalten des Arrays für die Inhaltsangabe.

  - Inhaltsverzeichnis
	Funktionen zum Erzeugen und Verwalten einer Tabelle mit einem Inhaltsverzeichnis auf Basis der
  	Inhaltsangabe.

  - Fensterverwaltung
  	Grundlegende Funktionen für die Darstellung der Webseiten
  			
  */


  /***************************************************************************************************************/


  // I N H A L T S A N G A B E
  
  /*

  Das Array arrContent spiegelt den Aufbau der Website wieder. Es enthält ein Array mit Angaben zur
  Startseite und den Tochterseiten der nächste Hirachiestufe. Diese enthalten in gleicher Form
  wiederum Angaben zur jeweiligen Seite und zu den Tochterseiten der nächsten Hirachiestufe.
  Dadurch kann das Array beliebig oft geschachtelt werden.
  
  Die Elemente des Arrays arrContent bedeuten der Reihe nach:
  arrContent[0]       Array mit allen Angaben zu einer Seite:
                      arrContent[0][0]       Kennung der Seite
                      arrContent[0][1]       Titel der Seite
                      arrContent[0][2]       Dateiname der Seite (ohne Pfadangabe!)
                      arrContent[0][3]       Name des Unterordners mit weiteren Seiten. Angaben zu diesen Seiten enthalten
					    die Tochterarrays in den Folgeelementen arrContent[1 ...]
                      arrContent[0][4]       Kurzbeschreibung des Seiteninhalts
                      arrContent[0][5]       Langbeschreibung des Seiteninhalts
                      arrContent[0][6 ...]   ggf. weitere Angaben in Arrays aus jeweils 2 Elementen:
        											arrContent[0][6 ...][0]   Schlüsselwort für die Art der Info
        											arrContent[0][6 ...][1]   Info
  arrContent[1 ...]   ggf. Tochterarrays für alle Tochterseiten im oben angegebenen Unterordner.
                      Der Aufbau des Tochterarrays entspricht wiederum dem Aufbau des Arrays arrContent:
                      arrContent[1 ...][0]   Kennung der Seite
                      arrContent[1 ...][1]   Titel der Seite
                      ...                    ...
                          
  Die Angabe des ersten Elements ist zwingend, daran schließt sich eine variable Anzahl Tochterarrays an.


  Für die Auswertung des Arrays arrContent wurden folgende Funktionen definiert:
  
        
  GetPathOfPage(arrContent,sId,sPath)   Pfad einer Seite
        Sucht im Array arrContent die Kennung sId einer Seite und liefert den dazugehörigen Pfad aufbauend
        auf dem übergebenen Pfad sPath. Das Ergebnis kann auch ein Leerstring sein. Wird die Kennung nicht
        gefunden, dann wird ein Gatterzeichen geliefert.
        
  CreatePatharray(sPathname)
        Liefert ein Array, das der Reihe nach die Ordner und den Dateinamen eines Pfadnamens enthält.
        Wird nur ein Pfad angegeben, dann werden nur die Ordner aufgelistet. Der Pfad kann mit oder ohne
        abschließenden Slash angegeben werden.
  
  GetReversePath(sPath)    Liefert den Umkehrpfad
       Liefert den Umkehrpfad zu einem Pfad sPath. Der Umkehrpfad ist der Pfad, mit dem man zum Ausgangsordner
       zurückkehren kann. Er enthält ebenso viele Rückschritte wie der Pfadname Ordner enthält. Der
       Umkehrpfad der Pfadangabe "ordner1/ordner2/ordner3/" ist "../../../". Der abschließende Slash in
       der Pfadangabe sPath kann auch weggelassen werden. Im Umkehrpfad ist er in jedem Fall enthalten.
 		 
  GetInfoOfPage(arrPage,sKey)   Information über eine Seite
        Liefert ausgehend vom Array arrPage einer Seite eine Information zu dieser Seite. Dazu ist
        Schlüsselwort sKey für die Art der gewünschten Information anzugeben. Folgende Schlüsselwörter
        werden verwendet:
        childs		Anzahl Tochterseiten
        id		Seitenkennung
        title		Seitentitel
        subdir		Unterverzeichnis mit Tochterseiten
        short		Kurzbeschreibung des Themas der Seite
        long		Langbeschreibung des Themas der Seite
        file		Dateiname einer Inhaltsseite
        chapters	Titel für den Registerkartenreiter für weitere Kapitel (default: "Kapitel")
        color		Schriftfarbe für die Darstellung der Langbeschreibung (default: "#FFFFFF")
        background	Hintergrundfarbe für die Darstellung der Langbeschreibung (default: "transparent")
        picture		Dateiname eines gekachelten Hintergrundbildes für die Darstellung der Langbeschreibung
        align		Ausrichtung für die Darstellung der Langbeschreibung (default: "bottom")

        Ist für das angegebene Schlüsselwort keine Information angegeben, dann wird der o.a. Default-Wert
        geliefert oder ein Leerstring.
        Weitere Schlüsselwörter wurden in arrContent eingearbeitet, werden im Moment aber von keiner
        Funktion interpretiert!
		
  FindArrayOfPage(arrPage,sKey,sInfo)
	Sucht und liefert ausgehend vom Array arrPage das Array der Ausgangs- oder Tochterseite, das die
	Information sInfo zum Schlüsselwort sKey enthält. Wird die Information nicht gefunden, dann wird
	ein leeres Array zurück geliefert.
	
  SelectArrayFromPathname(arrContent,sPathname,iIndex)
	Liefert ausgehend vom Array arrContent das Tochterarray, das den Ordner oder den Dateinamen enthält,
	der im Pfadnamen sPathname an der Stelle iIndex angegeben ist. Wird das Array nicht gefunden oder
	wird ein zu großer Index angegeben, dann wird ein leeres Array zurück geliefert.
	Bei Angabe von -1 als Index, wird nach dem letzten Glied des Pfadnamens gesucht, also nach dem
        Dateinamen.

  GetArrayOfParent(arrContent,sId)   Mutterarray einer Seite
        Liefert ausgehend vom Hauptarray arrContent das Array, das das Tochterarray der Seite mit der
        Kennung sId enthält. Dieses Array ist das Mutterarray von sId. Kennzeichnet sId die Startseite,
        dann wird ein leeres Array zurück geliefert.
  
  GetEntryOfChild(arrParent,sId)   Index einer Tochterseite
        Liefert ausgehend vom Mutterarray arrParent den Index des Arrays der Tochterseite mit der Kennung sID.
        Da die erste Angabe das Mutterarray selbst beschreibt, ist der kleinste mögliche Index 1.
        Ist das Ergebnis 0, dann ist die angegebene Tochterseite nicht im Mutterarray enthalten.
  
  GetEntryOfPreviousSister(arrParent,iEntry)   Index Vorgänger einer Tochterseite
        Liefert ausgehend vom Mutterarray arrParent den Index des Arrays der vorhergehenden Schwester der
        Tochterseite mit dem Index iEntry oder 0, wenn sId die erste Tochterseite ist und deshalb keine
        vorhergehende Schwester existiert. Das Ergebnis ist -1, wenn iEntry=0.
  
  GetEntryOfNextSister(arrParent,iEntry)   Index Nachfolger einer Tochterseite
        Liefert ausgehend vom Mutterarray arrParent den Index des Arrays der nachfolgenden Schwester der
        Tochterseite mit der Kennung sId oder 0, wenn sId die letzte Tochterseite ist und deshalb keine
        nachfolgende Schwester existiert. Das Ergebnis ist -1, wenn iEntry=0.

  GetIdArrayOfPage(arrPage,sId,arrId)
        Liefert ein Array mit Seitenkennungen. Es beginnt mit der Kennung der Seite mit dem Seitenarray arrPage und
        endet mit der angegebenen Kennung sId. Dazwischen liegen die Kennungen der Seiten aller dazwischenliegenden
        Generationen.

        
  */

  // I N H A L T S V E R Z E I C H N I S

  /*

  IsContent(arrPage,arrColumns)   Untersuchen einer Inhaltszeile auf darstellbarem Inhalt
	Untersucht, ob für die Seite arrPage in den in arrColumns angegeben Spalten Text für die Anzeige in
	einer Inhaltszeile eines Inhaltsverzeichnisses vorhanden ist oder nicht. Ist dies nicht der Fall, dann
	wird eine leere Zeichenkette geliefert, sonst irgendein Text.
	Die Spaltentypen "title","shorttext","longtext" und "description" liefern Text, wenn darin mindestens
	eine Angabe vorhanden ist. Die Spaltentypen "number" und "ordinary" liefern niemals Text. Die übrigen
	Spaltentypen liefern stets Text. Die Textsuche wird abgebrochen, sobald Text gefunden wurde. Der
	gelieferte Text enthält somit nicht unbedingt den Text für die ganze Seite.

  ShowContentTable(arrContent,sId,sIdTable,sTitle,iDepth,iFirst,iLast,arrColumns)	Erzeugen eines Inhaltsverzeichnisses
	Erzeugt unter Verwendung der Funktion CreateContentTable() ein Inhaltsverzeichnis. Die Parameter sind
	entsprechend, eine Beschreibung befindet sich dort. Nach der Erstellung eines "nackten" Inhaltsverzeichnisses mit
	CreateContentTable() wird es mit festen Parametern formatiert. Durch das Ändern dieser Parameter lässt sich das
	Inhaltsverzeichnis anders gestalten.

  CreateContentTable(arrContent,sId,sTitle,iDepth,iFirst,iLast,arrColumns)	Erzeugen eines Inhaltsverzeichnisses
        Erzeugt auf Basis der Inhaltsangabe im Array arrContent ein Inhaltsverzeichnis mit dem Titel sTitle.
        Darin werden zeilenweise untergeordnete Seiten der Mutterseite mit der Kennung sID aufgelistet. Der
        Aufruf dieser Funktion kann nur in innerhalb dieser Mutterseite erfolgen, wenn der verlinkte Titel
        (siehe unten) ausgegeben werden soll!
        Mit iDepth lässt sich die Anzahl der Generationen angeben:
        1		Ausgabe der iFirst-ten bis iLast-ten Tochterseite. Ist iLast=0, dann werden alle vorhandenen
        		Tochterseiten ab der iFirst-ten Tochterseite ausgegeben.
        2		Zusätzlich Ausgabe der Enkelseiten, also aller Tochterseiten der ausgegebenen Tochterseiten.
              Die Angabe von iFirst und iLast spielt in dieser Generation keine Rolle mehr.
        3		zusätzlich Ausgabe der Urenkelseiten, also aller Tochterseiten der ausgegebenen Enkelseiten.
              Die Angabe von iFirst und iLast spielt in dieser Generation keine Rolle mehr.
        ...	...
        Mit dem Array arrColumns wird eine Liste der Spaltenbezeichnungen angegeben. Jede Spaltenbezeichnung
        hat das Format <Spaltentyp>[_<Erweiterung>]. Hinter dem Spaltentyp kann also durch einen Unterstrich
        getrennt eine Erweiterung hinzugefügt werden. Wird jeder Spaltentyp nur einmal angegeben, dann kann auf
        die Erweiterung verzichtet werden, bei gleichen Spaltentypen ist eine weitere Unterscheidung durch die
        zusätzliche Angabe einer unterschiedlichen Erweiterung notwendig. Für jeden Spaltentyp wird in der
        angegebenen Reihenfolge mindestens eine Spalte angelegt. Folgende Spaltentypen lassen sich angeben:
        	title				Ausgabe von zwei Spalten für die Einrückung und den Titel der jeweiligen Seite. Jede
        					Generation wird ein Stück eingerückt. In der linken Spalte wird ein Linksymbol, in der
        					rechten der verlinkte Titel ausgegeben. Ist kein Link angegeben, dann wird nur der
        					unverlinkte Titel in der rechten Spalte ausgegeben, die linke bleibt dann leer. Da
        					der Pfad zum angegebenen Link und zum verwendeten Linkimage relativ zur Mutterseite
        					berechnet wird, darf diese Funktion bei Angabe des Spaltentyps "title" nur innerhalb
        					der Mutterseite aufgerufen werden oder in einer Seite, die in der gleichen
        					Hirachiestufe mit der Mutter steht!
		 shorttext			Ausgabe einer Spalte mit der Kurzbeschreibung der jeweiligen Seite.
		 longtext			Ausgabe einer Spalte mit der Langbeschreibung der jeweiligen Seite.
		 description			Ausgabe einer Spalte mit der Kurzbeschreibung der jeweiligen Seite. Wird auch der
		 				verlinkte Titel angezeigt, dann wird die Kurzbeschreibung durch die Langbeschreibung
		 				ersetzt, solange der Mauszeiger über dem Titel positioniert wird.
		 number				Ausgabe einer Spalte mit der laufenden Zeilennummer.
		 ordinary			Ausgabe einer Spalte mit der laufenden Zeilennummer und einem anschließenden Punkt.
		 <Schlüsselwort>		Ausgabe einer Spalte mit der zu diesem Schlüsselwort abgelegten Information zur
		 				jeweiligen Seite.
		 <beliebig>			Ausgabe einer Spalte mit der angegebenen Spaltenbezeichnung, sofern der Spaltentyp
		 				kein Schlüsselwort ist.
  
  AddLineToContentTable(arrContent,arrPage,sTitle,arrColumns,iDepth,iStep,sRPath)	Erweitern des Inhaltsverzeichnisses
        Diese Funktion wird von der Funktion CreateContentTable() aufgerufen. Mit ihr wird das Inhaltsverzeichnis
        um eine Zeile erweitert. Das Array arrPage beschreibt die anzuzeigende Seite. Die neue Zeile erhält
        die Kennung "line_<sTitle>_<lfd. Nummer>", jede Zelle in der Zeile erhält die Kennung
        "<Spaltenbezeichnung>_<sTitle>_<lfd. Nummer>", die Zelle für die Einrückung erhält die Kennung
        "tab_<sTitle>_<lfd. Nummer>". Die laufende Nummer bezeichnet die mit eins beginnende Zeilennummer, die
        jeweilige Spaltenbezeichnung ergibt sich aus den im Array arrColumns abgelegten Einträgen. Die
        Parameter arrColumns, iDepth, iFirst und iLast sind bei der Funktion CreateContentTable() erläutert.
        Der Parameter iStep bezeichnet die Generation, zu der die aktuelle Seite ausgehend von der Mutterseite
        gehört. Der Umkehrpfad sRPath ist der Pfad zurück auf die Startseite, also z.B. "../../".
        Die Tabelle, die Zeilen, die Zellen und einige weitere Elemente erhalten Kennungen, über die sie
        bei Bedarf nachträglich angesprochen und verändert werden können. Diese Kennungen sind:
        
        Tabelle  				"table_<sIdTable>"
          Kopfzeile				  "line_<sIdTable>_head"
            Linke Randzelle			    "head_<sIdTable>_left"
            Einrückungszellen 			    "head_<sIdTable>_tab<column>"
            Zellen für jede Spalte		    "head_<sIdTable>_<arrColumns[index]>"
            Rechte Randzelle			    "head_<sIdTable>_right"
          Titelzeile				  "line_<sIdTable>_title"
            Linke Randzelle			    "title_<sIdTable>_left"
            Zelle für Tabellentitel		    "title_<sIdTable>"
            Rechte Randzelle			    "title_<sIdTable>_right"
          Inhaltszeile				  "line_<sIdTable>_<number>"
            Linke Randzelle			    "left_<sIdTable>_<number>"
            Einrückungszelle 			    "tab_<sIdTable>_<number>"
            Zellen für jede Spalte		    "content_<arrColumns[index]>_<sIdTable>_<number>"
            Rechte Randzelle			    "right_<sIdTable>_<number>"
          Fußzeile				  "line_<sIdTable>_footnote"
            Linke Randzelle			    "footnote_<sIdTable>_left"
            Zelle für Fußnote			    "footnote_<sIdTable>"
            Rechte Randzelle			    "footnote_<sIdTable>_right"
        Einblendung für Langtext		"longtext_<sIdTable>"
        Hierbei ist:
          sIdTable		Tabellenkennung			"id<sTitle ohne Leerzeichen>"
          column		Einrückungsschritt		0 ... iDepth-1
          index			Spaltenindex			0 ... arrColumns.length-1
          number		Zeilennummer			1 ... Anzahl Inhaltszeilen

       Die Zeile wird nicht dargestellt, wenn das Seitenarray die Information "visibility" mit dem Wert "hidden"
       enthält oder wenn die Seite in keiner der anzuzeigenden Spalten darstellbaren Text enthält.
          
  GetAmountOfLines(sTitle)		Anzahl der Zeilen im Inhaltsverzeichnis
        Liefert die Anzahl der Zeilen mit Einträgen, die die Tabelle mit dem Titel sTitle enthält. Die
        Kopf- und Fußzeile und die ggf. vorhandene Titelleiste werden nicht mitgezählt! Die Titelleiste ist
        nicht vorhanden, wenn der Titel ein Leerstring ist.

  ChangeColorOfContentLine(sIdLine,sColor)		Hintergrundfarbe einer Zeile setzen
       Setzt in der Tabellenzeile mit der Kennung sIdLine die Hintergrundfarbe sColor.
  
  ChangeDescription(sDescription,sNewDescription)    Beschreibung im Inhaltsverzeichnis ändern
       Ersetzt die Beschreibung mit der Kennung sDescription durch die neue Beschreibung sNewDescription.

  ShowLongDescription(sIdTable,iLine,sLongDescription)
       Blendet eine Langbeschreibung an. Sie wird so positioniert, dass sie über der Kurzbeschreibung erscheint.
       Dazu wird ein in der Funktion CreateContentTable() ein DIV-Bereich mit der Kennung longtext_<sIdTable>
       bereitgestellt, der nun sichtbar gemacht wird. Anzugeben ist die Tabellenkennung sIdTable, die Nummer der
       Inhaltszeile und der Text der Langbeschreibung.

  DelLongDescription(sIdTable)
       Blendet eine angezeigte Langbeschreibung mit der Kennung longtext_<sIdTable> wieder aus.


  */

  // F E N S T E R V E R W A L T U N G

  /*

  CheckCallOfPage(arrContent)
        Überprüft, ob eine Seite über die Frame-Seite bgdtal.htm indirekt aufgerufen wurde. Ist dies nicht
        der Fall (wurde sie also direkt aufgerufen), dann wird sie über die Frame-Seite indirekt aufgerufen.
        Der indirekte Aufruf erfolgt durch die Angabe der Seitenkennung. Sie wird mit Hilfe des Arrays
        arrContent (Inhaltsangabe) ermittelt.

  OpenGalerie(sPagename)   Fenster für die Bildergalerie öffnen
        Öffnet ein neues Fenster mit dem Namen und Titel "Galerie" und zeigt darin die Datei sPagename an. Das Fenster
        wird mit fester und unveränderbarer Größe geöffnet und enthält kein Pulldownmenü und keine
        Eingabezeile für die URL-Adressen. Das Fenster wird in der Bildschirmmitte plaziert.

  OpenWnd(sTitle,sPagename,iWidth,iHeight)
	Öffnet ein neues Fenster mit dem Titel sTitle und zeigt darin die Datei sPagename an. Das Fenster
	wird mit der angegebenen Größe geöffnet und enthält kein Pulldownmenü und keine Eingabezeile für 
	die URL-Adressen. Das Fenster wird in der Bildschirmmitte plaziert.

  OpenFixWnd(sTitle,sPagename,iWidth,iHeight)
	Wie OpenWnd, anschließend kann die angegebene Größe aber nicht verändert werden.

  */




  /***************************************************************************************************************/


  // I N H A L T S A N G A B E

  function GetPathOfPage(arrContent,sId,sPath)
  {
    var iEntry;    //Ohne diese sonst unnötige Deklaration funktioniert es nicht bei reversen Funktionsaufrufen!
    var sFound;    //Ohne diese sonst unnötige Deklaration funktioniert es nicht bei reversen Funktionsaufrufen!
    var sDir=GetInfoOfPage(arrContent,"subdir");				//Name des Tochterordners
    var sCurId=GetInfoOfPage(arrContent,"id");					//Id der aktuellen Seite

    if(sCurId == sId)															//sId gefunden?
      return sPath;                           					//übergebenen Pfadnamen zurück
    
    //Die aktuelle Seite ist nicht die gesuchte Seite. Deshalb wird bei den Tochterseiten weitergesucht:
    if(sDir != ""){                           					//Unterordner vorhanden?
      //Der angegebene Unterordner kann auch eine Dummy-Angabe sein, die durch ein Gatterzeichen gekennzeichnet wird.
      //In diesem Fall ist die Ordnung nach Generationen nur logisch, tatsächlich sind die Tochterseiten im gleichen
      //Ordner wie die Mutterseite oder nur Textmarkenverweise innerhalb der Mutterseite! Dem Pfadnamen wird in diesem
      //Fall kein Unterordner hinzugefügt:
      if(sDir != "#")								//gültige Angabe, kein Dummy?
        sPath=sPath + sDir + "/";               				//Pfad mit Unterordner erweitern
      for(iEntry=1;iEntry<arrContent.length;iEntry++){                  	//alle Tochterarrays
        sFound=GetPathOfPage(arrContent[iEntry],sId,sPath);            		//durchsuchen
        if(sFound != "#")														//sId gefunden?
          return sFound;														//gelieferten Pfadnamen zurück
      }
    }
    
    //Die Kennung wurde weder auf der aktuellen Seite noch in einer Tochterseite gefunden:
    return "#";                               								//Fehlerwert zurück
  }
  
  function CreatePatharray(sPathname)
  {
    var arrPath=sPathname.split("/");             							//Aufsplitten des Pfadnames
    //Wurde statt dem Pfadnamen nur ein Pfad angegeben und entdet dieser mit einem Slash, dann ist das
    //letzte Element leer und wird entfernt:
    if(arrPath[arrPath.length-1] == "") arrPath.pop();						//Leereintrag entfernen
    return arrPath;																//Array mit Ordnern/Dateinamen zurück
  }
  
  function GetReversePath(sPath)
  {
    var arrPath=CreatePatharray(sPath);             						//Aufsplitten des Pfades

    //Die Anzahl der Elemente entspricht nun der Anzahl Ordner im Pfad. Mit der gleichen Anzahl
    //Rückschritte wird nun der Umkehrpfad erzeugt:
    sRPath="";
    for(i=0;i<arrPath.length;i++) sRPath=sRPath + "../";					//Rückschritt hinzufügen
    return sRPath;																//Umkehrpfad zurück
  }
  
  function SelectArrayFromPathname(arrContent,sPathname,iEntry)
  {
    var arrPage=new Array();													//zunächst leeres Array
    var arrPath=CreatePatharray(sPathname);									//Array mit den Ordner und dem Dateinamen
    
    if(iEntry == -1)
      iEntry=arrPath.length-1;

    if(iEntry >= arrPath.length)												//Index zu groß?
      return arrPage;															//leeres Array zurück

    arrPage=FindArrayOfPage(arrContent,"subdir",arrPath[iEntry]); //Tochterarray mit Ordnernamen suchen

    if(arrPage.length == 0)														//Ordnername nicht gefunden?
      arrPage=FindArrayOfPage(arrContent,"file",arrPath[iEntry]);		//Tochterarray mit Dateinamen suchen

    return arrPage;																//Array zurück
  }
  
    //Liefert ausgehend vom Seitenarray arrPage ein Array mit der Kennung sId einer Seite und den Kennung
    //aller älteren Generationen (Mutter, Großmutter ...), angefangen mit der ältesten Generation, also der
    //Kennung der Seite mit dem Array arrPage.
    function GetIdArrayOfPage(arrPage,sId,arrId)
    {
      var iEntry;															//Position der jeweiligen Tochterseite
      var sIdPage=GetInfoOfPage(arrPage,"id");						//Kennung der aktuellen Seite
      arrId.push(sIdPage);												//Kennung dieser Seite hinzufügen
      if(sIdPage == sId)												//Kennung dieser Seite ist gesuchte Seite?
        return arrId;													//Array zurück
      
      //Die Kennung dieser Seite ist noch nicht die Kennung der gesuchten Seite. Deshalb wird mit den
      //Tochterseiten - sofern vorhanden - weitergemacht:
      if(GetInfoOfPage(arrPage,"subdir") != ""){			//Unterverzeichnis angegeben?
        for(iEntry=1;iEntry<arrPage.length;iEntry++){            //alle Tochterarrays durchsuchen
          var arrNext=GetIdArrayOfPage(arrPage[iEntry],sId,arrId);	//um Tochter-Id erweitertes Array
          if(arrNext[arrNext.length-1] == sId)						//gesuchte Kennung am Arrayende?
            return arrNext;												//erweitertes Array zurück
        }
      }
      
      //Die gesuchte Kennung wurde weder in der aktuellen Seite noch in einer der Tochterseiten gefunden
      return arrId.pop();														//bisheriges Array zurück
    }


   function GetArrayOfParent(arrContent,sIdPage)
   {
    var arrParent=arrContent;							//mit übergebener Struktur beginnen
    var arrId=GetIdArrayOfPage(arrContent,sIdPage,new Array());			//Array mit der Id-Struktur der Seite
    arrId.pop();								//übergebene Seite entfernen

    //sIdPage kennzeichnet die Startseite, das ID-Array ist deshalb leer:
    if(arrId.length == 0) return arrId;						//leeres Array zurück

    //Ausgehend vom übergebenen Array werden der Reihe nach alle Arrays jeder neuen Tochtergeneration ermittelt. Da die
    //Kennung der aktuellen Seite aus der Id-Struktur entfernt wurde, verweist die letzte Kennung auf die Mutterseite:
    for(iId=1;iId<arrId.length;iId++){						//alle Kennungen
      iEntry=GetEntryOfChild(arrParent,arrId[iId]);				//Position der Tochter mit aktueller Kennung
      arrParent=arrParent[iEntry];        					//Array der nächsten Generation
    }
    return arrParent;                         					//Mutterarray zurück
  }
  
  function GetEntryOfChild(arrParent,sId)
  {
    var iEntry;
    for(iEntry=1;iEntry<arrParent.length;iEntry++){                                //in allen Tochterarrays suchen
      if(GetInfoOfPage(arrParent[iEntry],"id") == sId){                           //sId gefunden?
        return iEntry;                        											 //Index der gesuchten Seite
      }
    }
    return 0;                                 											//sId nicht gefunden!
  }
  
  function GetEntryOfPreviousSister(arrParent,iEntry)
  {
    return (iEntry-1);                        											//Index der vorhergehenden Seite
  }
  
  function GetEntryOfNextSister(arrParent,iEntry)
  {
    if(iEntry < 1) return -1;																//iEntry unzulässig
    if(iEntry < (arrParent.length-1)) return (iEntry+1);                           //Index der nachfolgenden Seite
    return -1;                                 											//sId hat keine Schwester
  }
  
  function GetArrayOfChild(arrParent,iEntry)
  {
    //arrParent kann ein leeres Array sein, wenn das Mutterarray der Startseite übergeben wird!
    if(arrParent.length == 0) return arrParent;											//leeres Array zurück
    return arrParent[iEntry];                 											//Tochterarray
  }
  
  function FindArrayOfPage(arrPage,sKey,sInfo)
  {
    var iEntry;
    var arrFound=new Array();													//zunächst leeres Array
	//Ist die Ausgangsseite die gesuchte Seite, dann wird das übergebene Array zurückgeliefert:
    if(GetInfoOfPage(arrPage,sKey) == sInfo)									//Info in der aktuellen Seite vorhanden?
      return arrPage;															//Array zurück

    //Die Ausgangsseite ist nicht die gesuchte Seite. Deshalb wird bei den Tochterseiten weitergesucht:
    if(GetInfoOfPage(arrPage,"subdir") != ""){                   //Unterordner vorhanden?
      for(iEntry=1;iEntry<arrPage.length;iEntry++){                  	//alle Tochterarrays
        arrFound=FindArrayOfPage(arrPage[iEntry],sKey,sInfo);           //durchsuchen
        if(arrFound.length > 0)												//Array von Tochterseite geliefert?
          return arrFound;														//geliefertes Array zurück
      }
    }
    
    //Die Information wurde weder in der Ausgangs- noch in einer Tochterseite gefunden. Deshalb wird ein
    //leeres Array zurück geliefert:
    return arrFound;																//leeres Array zurück
  }

  function GetInfoOfPage(arrPage,sKey)
  {
    switch(sKey){
    case "id":
      return(arrPage[0][0]);							   //Kennung zurück
      break;
    case "title":
      return(arrPage[0][1]);							   //Titel zurück
      break;
    default:
      for(iInfo=2;iInfo<arrPage[0].length;iInfo++){        //alle zusätzlichen Infos durchsuchen
        if(arrPage[0][iInfo][0] == sKey)                   //Schlüsselwort für Info gefunden?
          return arrPage[0][iInfo][1];                     //zusätzliche Info zurück
      }
      break;
    }
	
	//Wurde das Schlüsselwort nicht gefunden, dann werden für bestimmte Schlüsselwörter Default-Werte zurückgegeben,
	//für den Rest Leerstrings:
    switch(sKey){
    case "chapters":
      return "Menü%d";
      break;
    case "color":
      return "#FFFFFF";
      break;
    case "background":
      return "transparent";
      break;
    case "align":
      return "bottom";
      break;
	}

	return "";
  }

  // F E N S T E R V E R W A L T U N G


    function CheckCallOfPage(arrContent)
    {
      //Beispiel:
      //aus dem direkten Aufruf mit der URL
      //http://localhost/bgdtal/bgdtal/situation.htm?map=4
      //wird der indirekte Aufruf mit der URL
      //http://localhost/bgdtal/bgdtal.htm?sIdPage=idSituation&map=4
      var iPos=top.location.href.indexOf("bgdtal.htm?");			//Position von 'bgdtal.htm?' in URL
      if(iPos < 0){														//'bgdtal.htm?' in URL nicht vorhanden?
        //Die Seite wurde außerhalb des Framesets in bgdtal.htm direkt aufgerufen:
        iPos=top.location.pathname.lastIndexOf("bgdtal/");			//Beginn des Pfadnamens
        if(iPos>=0){														//Pfadname enthalten?
          //Der Pfadname ist normalerweise immer enthalten, nicht jedoch zum Beispiel beim Aufruf in Frontpage in
          //der Vorschau!
          var sPath=top.location.pathname.slice(iPos);				//Pfadname der direkt aufgerufenen Seite
          var arrPage=SelectArrayFromPathname(arrContent,sPath,-1);		//Array der direkt aufgerufenen Seite
          var sId=GetInfoOfPage(arrPage,"id");						//Kennung der direkt aufgerufenen Seite
          var sParam=top.location.search;								//Parameterliste mit führendem ?
          if(sParam != "") sParam="&"+sParam.slice(1);				//führendes ? durch & ersetzen
          iPos=top.location.href.lastIndexOf("bgdtal/");			//Beginn des Pfadnamens in URL
          //Indirekter Aufruf der Seite über den Aufruf der Frame-Seite bgdtal.htm. Dieser werden als
          //Parameter die Kennung der zuvor direkt aufgerufenen Seite übergeben.
          top.location.href=top.location.href.substr(0,iPos)+"bgdtal.htm?sIdPage="+sId+sParam;
        }
      }
    }

    function OpenGalerie(sPagename)
    {
      var wg;
      var iWidth=950;
      var iHeight=550;

      //Wird das Fenster mit open() neu geöffnet, dann wird es im vordergrund angezeigt. Ist es dann aber im Hintergrund
      //und wird erneut geöffnet, dann wird es wegen des identischen Fensternamens "Galerie" nicht neu erzeugt und
      //bleibt im Hintergrund. Damit es in jedem Fall neu erzeugt wird, wird es zuvor geschlossen. Die Funktion close()
      //benötigt aber eine Objektkennung, die nur die Funktion open() liefert. Deshalb wird das Fenster zuerst geöffnet,
      //dann geschlossen und schließlich entgültig geöffnet.
      wg = open(sPagename,"Galerie","width="+iWidth+",height="+iHeight+",locationbar=no,menubar=no,resizable=no");
      wg.close();

      wg = open(sPagename,"Galerie","width="+iWidth+",height="+iHeight+",locationbar=no,menubar=no,resizable=no");
      wg.moveTo((screen.width-iWidth)/2,(screen.height-iHeight)/2);
    }


    function OpenWnd(sTitle,sPagename,iWidth,iHeight)
    {
      var wg;

      //siehe oben in OpenGalerie
      wg = open(sPagename,"Window","width="+iWidth+",height="+iHeight+",locationbar=no,menubar=no,resizable=yes");
      wg.close();

      wg = open(sPagename,"Window","width="+iWidth+",height="+iHeight+",locationbar=no,menubar=no,resizable=yes");
      wg.moveTo((screen.width-iWidth)/2,(screen.height-iHeight)/2);
      wg.document.title=sTitle;
    }

    function OpenFixWnd(sTitle,sPagename,iWidth,iHeight)
    {
      var wg;

      //siehe oben in OpenGalerie
      wg = open(sPagename,"FixWindow","width="+iWidth+",height="+iHeight+",locationbar=no,menubar=no,resizable=no");
      wg.close();

      wg = open(sPagename,"FixWindow","width="+iWidth+",height="+iHeight+",locationbar=no,menubar=no,resizable=no");
      wg.moveTo((screen.width-iWidth)/2,(screen.height-iHeight)/2);
      wg.document.title=sTitle;
    }