/*======================================================================*/
/*  browser.js                                                          */
/*  Work-arounds um Browser-Abhaengigkeiten                             */
/*  Copyright by Antritter-Informatik, Juli 2002 - Mai 2004             */ 
/*======================================================================*/

if( !window.parent.FLAGS )
   {
   TESTFLAG_show_browserBranch = false;
   TESTFLAG_alert_ifDocumentAll = false;
   TESTFLAG_alert_ifDocumentLayers = false;
   TESTFLAG_alert_ifDocumentGetElementByID = false;
   TESTFLAG_alert_functionEntry = false;
   TESTFLAG_inhibitExecution = false;
   TESTFLAG_inhibitCapturingMouseEvents = false;
   TESTFLAG_A = false;
   TESTFLAG_B = false;
   TESTFLAG_C = false;
   TESTFLAG_D = false;
   TESTFLAG_E = false;
   }



/*======================================================================*/
/*- feststellen des genauen Browsertyps:                               -*/
/*======================================================================*/

function Browser()
   {
   this.ver=navigator.appVersion
   this.dom=document.getElementById?1:0
   this.ie6=(this.ver.indexOf("MSIE 6")>-1 && this.dom)?1:0;
   this.ie5=(this.ver.indexOf("MSIE 5")>-1 && this.dom)?1:0;
   this.ie4=(document.all && !this.dom)?1:0;
   this.ns6=(this.dom && parseInt(this.ver) >= 5 && !document.layers && !document.all) ?1:0;
   this.ns5=(this.dom && parseInt(this.ver) >= 5 && document.layers) ?1:0;
   this.ns4=(document.layers && !this.dom)?1:0;
   this.bw=(this.ie6 || this.ie5 || this.ie4 || this.ns4 || this.ns5)
   this.ns=(this.ns4 || this.ns5 || this.ns6)
   this.ms=(this.ie6 || this.ie5 || this.ie4)
   }
var whichBrowser = new Browser();



/*======================================================================*/
/*- ergänzende Definitionen für alte Browser:                          -*/
/*======================================================================*/

//-----------------------
// Konstante "undefined":
//-----------------------
var Browser_ConstUndefined;

// diese "Variable" (es soll eher eine "Konstante" sein..) ist deklariert,
// kann somit auch angesprochen werden, hat aber keinen Wert zugewiesen bekommen,
// und hat somit den Wert "undefined"...



//---------------
// Array-Objekte:
//---------------
function Browser_ArrayPush( element )
   {
   //***************
   if( TESTFLAG_alert_functionEntry )
     alert( "Browser_ArrayPush: entry..." );
   //***************
   this[this.length] = element;
   }

if( Array.prototype.push )
   {
   //***************
   if( TESTFLAG_A ) alert( "Browser kennt 'Array.push'..." );
   //***************
   }
else
   {
   //***************
   if( TESTFLAG_alert_functionEntry )
     alert( "Browser_ArrayPush: Prototypdefinition..." );
   //***************

   //***************
   if( TESTFLAG_A ) alert( "Browser kennt 'Array.push' nicht!" );
   //***************

   Array.prototype.push = Browser_ArrayPush;
   }



//------------
// setTimeout:
//------------

function Browser_setTimeout( funcRef, Wartezeit /* ...ggf. weitere Parameter...  */ )
   {
   if( typeof funcRef == "string" )
      {
      Browser_setTimeoutOriginal( funcRef, Wartezeit );
      }

   else
      {
      var funcName = funcRef.toString().slice( 9 );  // überlies "function "...
      var funcNameLength = funcName.indexOf( "(" );  // lies bis zur öffnenden Klammer...
      var funcName = funcName.slice( 0, funcNameLength );

      var aufruf = "Browser_setTimeoutOriginal(\"" + funcName + "(";

      var i;
      for( i=2 ; i<Browser_setTimeout.arguments.length ; i++ )
         {
         aufruf += ((i>2)?",":"") + Browser_setTimeout.arguments[i];
         }

      aufruf += ")\", " + Wartezeit + ");";

      eval(aufruf);
      }
   }

var Browser_setTimeoutOriginal = window.setTimeout;

if( whichBrowser.ms )
   {
   window.setTimeout = Browser_setTimeout;
   }



//------------
// getDivByID:
//------------

function Browser_getDivByID( id, doc )
   {
   if( document.layers )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentLayers || TESTFLAG_show_browserBranch )
        alert( "Browser_getDivByID: IfDocumentLayers-branch..." );
      //***************
      if( !doc )
         {
         // optionaler Parameter 'doc' nicht angegeben?
         doc = window.document;
         }

      var i;
      var innerDiv;
      var elemFound;

      // hat eine Ebene im Dokument den gesuchten Namen?
      for (i = 0; i < doc.layers.length; ++i)
         {
         if (doc.layers[i].id && doc.layers[i].id == id )
            {
            return doc.layers[i];
            }
         }

      // wenn nicht, suche in den Unterdokumenten weiter...
      for (i = 0; i < doc.layers.length; ++i)
         {
         innerDiv = doc.layers[i];
         elemFound = Browser_getDivByID( id, innerDiv.document );
         if( elemFound != null )
            {
            return elemFound;
            }
         }

      // wenn auch dort nichts gefunden: vielleicht wurde gesuchte Ebene ja dynamisch erzeugt?
      if( Browser_listeDynamischErzeugterEbenen[id] != null )
         {
         return Browser_listeDynamischErzeugterEbenen[id];
         }

      // nichts gefunden?
      return null;
      }

   else if( document.all )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentAll || TESTFLAG_show_browserBranch )
        alert( "Browser_getDivByID: IfDocumentAll-branch..." );
      //***************
      if( document.all[id] )
         {
         return document.all[id];
         }
      else
         {
         return null;
         }
      }

   else if( document.getElementById )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentGetElementByID || TESTFLAG_show_browserBranch )
        alert( "Browser_getDivByID: IfDocumentGetElementByID-branch..." );
      //***************
      return document.getElementById(id);
      }

   else
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_getDivByID: Else-branch..." );
      //***************
      // Browser hat nicht die benötigte Funktionalität!
      return null;
      }
   }



//-----------------------
// getDivContainingImage:
//-----------------------

function Browser_getDivContainingImage( id, doc )
   {
   if( document.layers )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentLayers || TESTFLAG_show_browserBranch )
        alert( "Browser_getDivContainingImage: IfDocumentLayers-branch..." );
      //***************
      if( !doc )
         {
         // optionaler Parameter 'doc' nicht angegeben?
         doc = window.document;
         }

      var i;
      var innerDiv;
      var elemFound;

      // suche nicht im Hauptdokument, sondern sofort in Unterdokumenten
      // (direkt im "body" definierte Bilder sind uninteressant!)
      for ( i=0; i<doc.layers.length; i++ )
         {
         innerDiv = doc.layers[i];

         // falls betrachtete div Bild enthält, ist sie die gesuchte:
         if( eval("innerDiv.document."+id) )
            {
            return innerDiv;
            }

         // andernfalls: suche rekursiv in die Tiefe weiter...
         else
            {
            elemFound = Browser_getDivContainingImage( id, innerDiv.document );
            if( elemFound != null )
               {
               return elemFound;
               }
            }
         }

      // nichts gefunden?
      return null;
      }

   else if( document.all )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentAll || TESTFLAG_show_browserBranch )
        alert( "Browser_getDivContainingImage: IfDocumentAll-branch..." );
      //***************
      if(    document.all[id]
          && document.all[id].offsetParent
          && document.all[id].offsetParent.tagName
          && (document.all[id].offsetParent.tagName != "BODY")
        )
         {
         return document.all[id].offsetParent;
         }
      else
         {
         return null;
         }
      }

   else if( document.getElementsByName )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentGetElementByID || TESTFLAG_show_browserBranch )
        alert( "Browser_getDivContainingImage: IfDocumentGetElementsByName-branch..." );
      //***************
      var elemArray = document.getElementsByName(id);
      if( elemArray.length > 0 )
         {
         var elem = elemArray[0];
         while( elem.offsetParent && elem.offsetParent.tagName )
               {
               if( elem.offsetParent.tagName == "DIV")
                  {
                  return elem.offsetParent;
                  }
               else
                  {
                  elem = elem.offsetParent;
                  }
               }
         }

      return null;
      }

   else
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_getDivContainingImage: Else-branch..." );
      //***************
      // Browser hat nicht die benötigte Funktionalität!
      return null;
      }
   }



//------------
// getImgByID:
//------------

function Browser_getImgByID( id, doc )
   {
   if( document.layers )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentLayers || TESTFLAG_show_browserBranch )
        alert( "Browser_getImgByID: IfDocumentLayers-branch..." );
      //***************
      if( !doc )
         {
         // optionaler Parameter 'doc' nicht angegeben?
         doc = window.document;
         }

      var i;
      var innerDiv;
      var elemFound;

      // hat ein Bild (image) im aktuellen Dokument den gesuchten Namen?
      for (i = 0; i < doc.images.length; ++i)
         {
         if (doc.images[i].name && doc.images[i].name == id )
            {
            return doc.images[i];
            }
         }

      // wenn nicht, suche in den Unterdokumenten weiter...
      for (i = 0; i < doc.layers.length; ++i)
         {
         innerDiv = doc.layers[i];
         elemFound = Browser_getImgByID( id, innerDiv.document );
         if( elemFound != null )
            {
            return elemFound;
            }
         }

      // nichts gefunden?
      return null;
      }

   else if( document.all )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentAll || TESTFLAG_show_browserBranch )
        alert( "Browser_getImgByID: IfDocumentAll-branch..." );
      //***************
      if( document.all[id] )
         {
         return document.all[id];
         }
      else
         {
         return null;
         }
      }

   else if( document.getElementsByName )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentGetElementByID || TESTFLAG_show_browserBranch )
        alert( "Browser_getImgByID: IfDocumentGetElementByID-branch..." );
      //***************
      var elemArray = document.getElementsByName(id);
      if( elemArray.length > 0 )
         {
         return elemArray[0];
         }
      else
         {
         return null;
         }
      }

   else
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_getImgByID: Else-branch..." );
      //***************
      // Browser hat nicht die benötigte Funktionalität!
      return null;
      }
   }



//------------
// getImgByID:
//------------

function Browser_getFormObjByID( divId, formId )
   {
   if( document.layers )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentLayers || TESTFLAG_show_browserBranch )
        alert( "Browser_getFormObjByID: IfDocumentLayers-branch..." );
      //***************
      return Browser_getDivByID( divId ).document.forms[formId];
      }

   else
      {
      //***************
      if( TESTFLAG_alert_ifDocumentLayers || TESTFLAG_show_browserBranch )
        alert( "Browser_getFormObjByID: !IfDocumentLayers-branch..." );
      //***************
      return document.forms[formId];
      }
   }



/*======================================================================*/
/*- Erweiterungen der objektunabhängigen Funktionen                    -*/
/*======================================================================*/

function Browser_Number2Hex( zahl )
   {
   // das Argument sollte zwischen 0 und 255 liegen...!
   if( (zahl >= 0) && (zahl <= 255) )
      {
      var hexDigits = new Array("0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F");
      return hexDigits[Math.floor(zahl/16)] + hexDigits[zahl % 16];
      }

   //else:
   return "";
   }



function Browser_filtereText()
   {
   var ergebnisText;

   var ersatzFuerShy = ( (Browser_kannZeichenDarstellen("&shy;"))? "&shy;" : "" );
   ergebnisText = this.replace( /&shy;/g, ersatzFuerShy );

   return ergebnisText;
   }

String.prototype.filtern = Browser_filtereText;



function Browser_kannZeichenDarstellen( zeichen )
   {
   switch( zeichen )
      {
      case "&shy;":
         {
         if( whichBrowser.ie6 ) return 1
         else return 0;
         break;
         }

      default:
         {
         return 1;
         break;
         }
      }
   }



/*======================================================================*/
/*- Handler für "resizePage"-Event des Browsers:                       -*/
/*======================================================================*/

window.onresize = Browser_resizePage;



// Routine zum Anmelden der Event-Handler aus Anwendungsmodulen:
function Browser_registerResizeEventHandler( handlerFuncRef )
   {
   //***************
   if( TESTFLAG_show_browserBranch )
     alert( "Browser_registerResizeEventHandler: wird ausgeführt..." );
   //***************
   Browser_resizeEventHandlers.push( handlerFuncRef );
   }

// Sammlung aller angemeldeten Resize-Ereignis-Handler:
var Browser_resizeEventHandlers = new Array();



function Browser_resizePage()
   {
   // läuft Seite in übergeordnetem Kontrollframeset?
   // wenn ja, dann könnten dort bei Bedarf Scrollleisten ein- oder ausgeblendet werden
   // (durch Neudefinition eines Framesets, dessen Frames Scrollleisten zulassen oder
   // unterdrücken...):
   
   if( document.layers )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentLayers || TESTFLAG_show_browserBranch )
        alert( "Browser_resizePage: IfDocumentLayers-branch..." );
      //***************
      location.reload();
      }

   else
      {
      if(   parent
         && parent.parent
         && parent.parent.CHECKBROWSER
         && parent.parent.CHECKBROWSER.CHECKBROWSER_setupContentFrameset
        )
         {
         parent.parent.CHECKBROWSER.CHECKBROWSER_setupContentFrameset();
         // führt ggf. zum Neuladen der Seite...
         }

      // an alle angemeldeten Resize-Ereignis-Handler weiterleiten:
      var i;
      for( i=0 ; i<Browser_resizeEventHandlers.length ; i++ )
         {
         eval( Browser_resizeEventHandlers[i]() );
         }
      }
   }



/*======================================================================*/
/*- Handler für "onLoad"-Event des Browsers:                           -*/
/*======================================================================*/

// Routine zum Anmelden der Event-Handler aus Anwendungsmodulen:
function Browser_registerOnloadEventHandler( handlerFuncRef )
   {
   //***************
   if( TESTFLAG_show_browserBranch )
     alert( "Browser_registerResizeEventHandler: wird ausgeführt..." );
   //***************
   Browser_onloadEventHandlers.push( handlerFuncRef );
   }

// Sammlung aller angemeldeten onLoad-Ereignis-Handler:
var Browser_onloadEventHandlers = new Array();


function Browser_onLoad()
   {
   // an alle angemeldeten onLoad-Ereignis-Handler weiterleiten:
   var i;
   for( i=0 ; i<Browser_onloadEventHandlers.length ; i++ )
      {
      eval( Browser_onloadEventHandlers[i]() );
      }
   }

window.onload = Browser_onLoad;


/*======================================================================*/
/*- Größe des Anzeigebereiches feststellen:                            -*/
/*======================================================================*/

// interne Funktion
function Browser_getWindowInnerWidth()
   {
   if( window.innerWidth )
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_getWindowInnerWidth: 'window.innerWidth'-branch..." );
      //***************
      return window.innerWidth;
      }

   else if( document.all )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentAll || TESTFLAG_show_browserBranch )
        alert( "Browser_getWindowInnerWidth: IfDocumentAll-branch..." );
      //***************
      return window.document.all.tags("body")[0].offsetWidth;
      }

   else
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_getWindowInnerWidth: Else-branch..." );
      //***************
      // Browser hat nicht die benötigte Funktionalität!
      return 0;
      }
   }

// interne Funktion
function Browser_getWindowInnerHeight()
   {
   if( window.innerHeight )
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_getWindowInnerHeight: 'window.innerHeight'-branch..." );
      //***************
      return window.innerHeight;
      }

   else if( document.all )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentAll || TESTFLAG_show_browserBranch )
        alert( "Browser_getWindowInnerHeight: IfDocumentAll-branch..." );
      //***************
      return window.document.all.tags("body")[0].offsetHeight;
      }

   else
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_getWindowInnerHeight: Else-branch..." );
      //***************
      // Browser hat nicht die benötigte Funktionalität!
      return 0;
      }
   }

function Browser_getScreenWidth()
   {
   return screen.availWidth;
   }

function Browser_getScreenHeight()
   {
   return screen.availHeight;
   }



/*======================================================================*/
/*- Neue Ebenen anlegen:                                               -*/
/*======================================================================*/
/*-------------
...geht normalerweise dadurch, dass während des Einlesens des HTML-Dokuments
mittels "document.write(...)" der HTML-Code für die zu dynamisch zu erzeugenden
Ebenen geschrieben wird; "vernünftige" Browser gehen mit diesen dynamischen
Definitionen genau so um, als stünden sie in eben dieser Form fest eingebrannt
im HTML-Code.
Nicht aber NN4: der stellt die Ebenen zwar dar, kann sie aber nicht ansprechen,
weil sie nicht im "document.layers"-Array eingetragen werden und somit nicht
für "DHTML"-Aktionen ansprechbar sind!

Lösungsansatz:
auch NN4 kann mit "var neueEbene = new Layer(...)" neue Ebenen dynamisch
anlegen und anschließend mit "neueEbene.document.write(...)" mit Inhalt füllen;
dies "aber bzw. sogar" _nach_ vollständigem Laden der Seite und "leider nicht / nicht nur"
während des Ladens. Auf der einen Seite schön: man könnte hier dynamisch Ebenen
erzeugen auch wenn die Seite bereits komplett geladen ist - was mit anderen Browsern
möglicherweise nicht geht!
Auf der anderen Seite problematisch: man kann den spezifizierten Inhalt der
neuen Ebenen nicht in einem Rutsch ausgeben, weil diese Definitionen dann ignoriert werden!

Fazit:
man braucht hier eine Routine zum Erzeugen und Beschreiben neuer Ebenen, die
bei neueren Browsern den Code direkt während des Einlesens der Datei ausgibt, und bei
NN4 den Code in eine Warteschlange einstellt und _nach_ dem Einlesen der Datei
umsetzt.
(kleines Problem dabei: die Ebenenschichtungsreihenfolge gerät bei diesem Verfahren
möglicherweise durcheinander... werden _alle_ Ebenen auf diese Weise erzeugt, stimmt die
Reihenfolge natürlich wieder, man muss aber aufpassen, wenn statisch und dynamisch
definierte Ebenen vermischt werden!)

Noch ein Problem: beim NN4-Ansatz "var neueEbene = new Layer(...)" lässt sich keine
ID anlegen?!
-------------*/

function Browser_ZuErzeugendeEbene(
   nameDerEbene,
   nameDerUebergeordnetenEbene,
   breite, hoehe,
   positionX, positionY,
   visibility,
   codeInhalt,
   parameter
)
   {
   this.nameDerEbene                = nameDerEbene;
   this.nameDerUebergeordnetenEbene = nameDerUebergeordnetenEbene;
   this.breite                      = breite;
   this.hoehe                       = hoehe;
   this.positionX                   = positionX;
   this.positionY                   = positionY;
   this.visibility                  = visibility;
   this.codeInhalt                  = codeInhalt;
   this.parameter                   = parameter;
   }

var Browser_ContainerFuerZuErzeugendeEbenen = new Array();



var Browser_listeDynamischErzeugterEbenen = new Object();
function Browser_vermerkeNeueEbene( neueEbene, nameDerNeuenEbene )
   {
   Browser_listeDynamischErzeugterEbenen[nameDerNeuenEbene] = neueEbene;
   }



function Browser_erzeugeEbenen()
   {
   var i;
   var ebenenSpezifikation;
   var neueEbene;
   for( i=0 ; i<Browser_ContainerFuerZuErzeugendeEbenen.length ; i++ )
      {
      ebenenSpezifikation = Browser_ContainerFuerZuErzeugendeEbenen[i];


      if( !ebenenSpezifikation.parameter ) ebenenSpezifikation.parameter = "";

      if( ebenenSpezifikation.parameter.indexOf("umbrechen") != -1 )
         {
         var positionUmbruchSpezifikation = ebenenSpezifikation.parameter.indexOf("umbrechen(#");
         var trennstellenMarkerVorgabe = ebenenSpezifikation.parameter.slice(positionUmbruchSpezifikation + 11);
         trennstellenMarkerVorgabe = trennstellenMarkerVorgabe.slice( 0, trennstellenMarkerVorgabe.indexOf("#,") );
         var breite = ebenenSpezifikation.parameter.slice(positionUmbruchSpezifikation + 11 + trennstellenMarkerVorgabe.length + 2);
         breite = breite.slice(0, breite.indexOf(");"));
         ebenenSpezifikation.codeInhalt = Umbruch_umbrecheText( ebenenSpezifikation.codeInhalt, breite, trennstellenMarkerVorgabe );
         }

      if( document.layers )
         {
         //***************
         if( TESTFLAG_alert_ifDocumentLayers || TESTFLAG_show_browserBranch )
           alert( "Browser_erzeugeNeueEbene: IfDocumentLayers-branch..." );
         //***************

         if( ebenenSpezifikation.nameDerUebergeordnetenEbene )
            {
            neueEbene = new Layer( ebenenSpezifikation.breite,
                                   Browser_getDivByID(ebenenSpezifikation.nameDerUebergeordnetenEbene)
                                 );
            }
         else
            {
            neueEbene = new Layer( ebenenSpezifikation.breite );
            }

         neueEbene.left = ebenenSpezifikation.positionX;
         neueEbene.top  = ebenenSpezifikation.positionY;

         // halte dynamisch erzeugte Ebene fest, damit sie später per Namen gefunden werden kann:
         if( ebenenSpezifikation.nameDerEbene != "" )
            {
            Browser_vermerkeNeueEbene(neueEbene, ebenenSpezifikation.nameDerEbene);
            }

         neueEbene.visibility = ((ebenenSpezifikation.visibility)?"show":"hide");

         with( neueEbene.document )
            {
            open();
            write( ebenenSpezifikation.codeInhalt );
            close();
            }
         } // endIf document.layers

      else 
         {
         //***************
         if( TESTFLAG_show_browserBranch )
           alert( "Browser_erzeugeNeueEbene: IfNotDocumentLayers-branch..." );
         //***************

         neueEbene = Browser_getDivByID( ebenenSpezifikation.nameDerEbene );
         neueEbene.innerHTML = ebenenSpezifikation.codeInhalt;
         }
      } // Ende: iteriere zu erzeugende Ebenen
   }

Browser_registerOnloadEventHandler( Browser_erzeugeEbenen );



function Browser_erzeugeNeueEbene(
   nameDerEbene,
   nameDerUebergeordnetenEbene,
   breite, hoehe,
   positionX, positionY,
   visibility,
   codeInhalt,
   parameter
)
   {
   if( document.layers )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentLayers || TESTFLAG_show_browserBranch )
        alert( "Browser_erzeugeNeueEbene: IfDocumentLayers-branch..." );
      //***************

      // beachte: beim layer-Modell könnten auch nach dem Laden noch neue Ebenen erzeugt
      // werden; ein Aufruf der Funktion nach dem Laden würde aber hier nur eine
      // "zu erzeugende Ebene" festhalten, diese aber dann niemals wirklich erzeugen,
      // weil ja nun kein "onLoad"-Signal mehr kommt. Da aber bei den anderen Browsern
      // diese Art der Ebenenerzeugung ohnehin noch nicht implementiert ist, ist das
      // auch in diesem Fall nicht so wichtig...

      Browser_ContainerFuerZuErzeugendeEbenen.push(
         new Browser_ZuErzeugendeEbene(
                nameDerEbene,
                nameDerUebergeordnetenEbene,
                breite, hoehe,
                positionX, positionY,
                visibility,
                codeInhalt,
                parameter
             )
      );
      }

   else 
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_erzeugeNeueEbene: IfNotDocumentLayers-branch..." );
      //***************

      // erzeuge (während des Ladens) eine neue, aber zunächst leere Ebene...
      // Allerdings: falls kein Name angegeben wurde, so soll die Ebene auch später
      // nicht angesprochen werden - in diesem Fall setze den Inhalt sofort:
      var htmlCode = "";
      htmlCode += "   <div " + ((nameDerEbene!="")? ("id=\"" + nameDerEbene + "\"") : ("")) + "   \n";
      htmlCode += "        style=\"position:absolute; left:" + positionX + "; top:" + positionY + "; ";
      htmlCode += "                width:" + breite + ";";
      htmlCode +=       ((hoehe)? "height:" + hoehe + ";" : "");
      htmlCode += "                visibility:" + ((visibility)?"visible":"hidden") + ";\""
      htmlCode += "                >";
      htmlCode +=       ((nameDerEbene!="")? "" : codeInhalt);
      htmlCode += "   </div>   \n";

      with(document)
         {
         open();
         write( htmlCode );
         close();
         }

      // ...die erst nach "onload" mit dem eigentlichen Inhalt beschrieben wird;
      // speichere hierzu die nötigen Informationen:
      // (ausser natürlich in dem oben bereits erwähnten Spezialfall anonymer Ebenen)
      if(nameDerEbene != "")
         {
         Browser_ContainerFuerZuErzeugendeEbenen.push(
            new Browser_ZuErzeugendeEbene(
                   nameDerEbene,
                   nameDerUebergeordnetenEbene,
                   breite, hoehe,
                   positionX, positionY,
                   visibility,
                   codeInhalt,
                   parameter
                )
         );
         }
      }
   }



function Browser_setzeNeuenInhalt( divObj, htmlCode )
   {
   if( document.layers )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentLayers || TESTFLAG_show_browserBranch )
        alert( "Browser_erzeugeNeueEbene: IfDocumentLayers-branch..." );
      //***************

      with( divObj.document )
         {
         open();
         write( htmlCode );
         close();
         }
      }

   else 
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_erzeugeNeueEbene: IfNotDocumentLayers-branch..." );
      //***************

      divObj.innerHTML = htmlCode;
      }
   }



/*======================================================================*/
/*- Ebenengroessen ermitteln und verändern:                            -*/
/*======================================================================*/

// interne Funktion
function Browser_getDivHeight( id )
   {
   var obj = Browser_getDivByID( id );

   if( document.layers )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentLayers || TESTFLAG_show_browserBranch )
        alert( "Browser_getDivHeight: IfDocumentLayers-branch..." );
      //***************
      return obj.clip.height;
      }

   else if( obj.style.height )
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_getDivHeight: 'obj.style.height'-branch..." );
      //***************
      return parseInt( obj.style.height );
      }

   else
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_getDivHeight: Else-branch..." );
      //***************
      return 0;
      }
   }

// interne Funktion
// benötigt im Modul "ugTiling" zur Größenanpassung der ugKachel-Ebene...!
function Browser_setDivWidth(id, width)
   {
   if( width < 0 )
      width = 0;

   var obj = Browser_getDivByID( id );

   if( document.layers )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentLayers || TESTFLAG_show_browserBranch )
        alert( "Browser_setDivWidth: IfDocumentLayers-branch..." );
      //***************
      obj.clip.width = width;
      }

   else if( obj.style.width )
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_setDivWidth: 'obj.style.width'-branch..." );
      //***************
      obj.style.width = width;
      }

   else
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_setDivWidth: Else-branch..." );
      //***************
      }
   }

// interne Funktion
// benötigt im Modul "ugTiling" zur Größenanpassung der ugKachel-Ebene...!
function Browser_setDivHeight(id, height)
   {
   if( height < 0 )
      height = 0;

   var obj = Browser_getDivByID( id );

   if( document.layers )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentLayers || TESTFLAG_show_browserBranch )
        alert( "Browser_setDivHeight: IfDocumentLayers-branch..." );
      //***************
      obj.clip.height = height;
      }

   else if( obj.style.height )
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_setDivHeight: 'obj.style.height'-branch..." );
      //***************
      obj.style.height = height;
      }

   else
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_setDivHeight: Else-branch..." );
      //***************
      }
   }



/*======================================================================*/
/*- Ebenenpositionen ermitteln und verändern:                          -*/
/*======================================================================*/

// interne Funktion
function Browser_getLeftAbsolute( name )
   {
   return Browser_getLeftAbsoluteByObj( Browser_getDivByID( name ) );
   }
function Browser_getLeftAbsoluteByObj( obj )
   {
   if( obj.pageX )
      {
      return obj.pageX;
      }

   else if( obj.tagName )
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_getLeftAbsolute: rekursiver Zweig..." );
      //***************
      if( obj.tagName.toLowerCase() == "body" )
         {
         return 0;
         }
      else if( obj.offsetLeft )
           if( obj.offsetParent )
         {
         return (obj.offsetLeft) + Browser_getLeftAbsoluteByObj( obj.offsetParent );
         }
      }

   // else: soll auch etwaige else-Fälle der oberen inneren Tests abfangen...
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_getLeftAbsolute: Else-branch..." );
      //***************
      // Browser hat nicht die benötigte Funktionalität!
      return 0;
      }
   }



// interne Funktion
function Browser_getTopAbsolute( name )
   {
   return Browser_getTopAbsoluteByObj( Browser_getDivByID( name ) );
   }
function Browser_getTopAbsoluteByObj( obj )
   {
   if( obj.pageY )
      {
      return obj.pageY;
      }

   else if( obj.tagName )
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_getTopAbsolute: rekursiver Zweig..." );
      //***************
      if( obj.tagName.toLowerCase() == "body" )
         {
         return 0;
         }
      else if( obj.offsetTop )
           if( obj.offsetParent )
         {
         return (obj.offsetTop) + Browser_getTopAbsoluteByObj( obj.offsetParent );
         }
      }

   // else: soll auch etwaige else-Fälle der oberen inneren Tests abfangen...
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_getTopAbsolute: Else-branch..." );
      //***************
      // Browser hat nicht die benötigte Funktionalität!
      return 0;
      }
   }



// interne Funktion
function Browser_getLeftRelative( name )  // ehemals: Browser_getOffsetLeft
   {
   var obj = Browser_getDivByID( name );

   if( obj.offsetLeft )
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_getLeftRelative: 'obj.offsetLeft'-branch..." );
      //***************
      return obj.offsetLeft;
      }

   else if( document.layers )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentLayers || TESTFLAG_show_browserBranch )
        alert( "Browser_getLeftRelative: IfDocumentLayers-branch..." );
      //***************
      return obj.left;
      }

   else
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_getLeftRelative: Else-branch..." );
      //***************
      // Browser hat nicht die benötigte Funktionalität!
      return 0;
      }
   }

// interne Funktion
function Browser_getTopRelative( name)  // ehemals: Browser_getOffsetTop
   {
   var obj = Browser_getDivByID( name );

   if( obj.offsetTop )
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_getTopRelative: 'obj.offsetTop'-branch..." );
      //***************
      return obj.offsetTop;
      }

   else if( document.layers )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentLayers || TESTFLAG_show_browserBranch )
        alert( "Browser_getTopRelative: IfDocumentLayers-branch..." );
      //***************
      return obj.top;
      }

   else
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_getTopRelative: Else-branch..." );
      //***************
      // Browser hat nicht die benötigte Funktionalität!
      return 0;
      }
   }

// interne Funktion
function Browser_moveToRelativeByObj( obj, x, y )  // ehemals: Browser_divPlaceByCoord
   {
   Browser_setLeftRelativeByObj( obj, x );
   Browser_setTopRelativeByObj( obj, y );
   }

function Browser_moveToRelative( name, x, y )  // ehemals: Browser_divPlaceByCoord
   {
   Browser_setLeftRelative( name, x );
   Browser_setTopRelative( name, y );
   }

// interne Funktion
function Browser_setLeftRelative( name, x )
   {
   var obj = Browser_getDivByID( name );
   if( obj == null ) return;

   Browser_setLeftRelativeByObj( obj, x );
   }
function Browser_setLeftRelativeByObj( obj, x )
   {
   if( document.layers )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentLayers || TESTFLAG_show_browserBranch )
        alert( "Browser_setLeftRelative: IfDocumentLayers-branch..." );
      //***************
      obj.left = x;
      }

   else if( obj.style )
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_setLeftRelative: 'obj.style'-branch..." );
      //***************
      obj.style.left = x;
      }

   else
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_setLeftRelative: Else-branch..." );
      //***************
      // Browser hat nicht die benötigte Funktionalität!
      return;
      }
   }

// interne Funktion
function Browser_setTopRelative( name, y )
   {
   var obj = Browser_getDivByID( name );
   if( obj == null ) return;

   Browser_setTopRelativeByObj( obj, y );
   }
function Browser_setTopRelativeByObj( obj, y )  // ehemals: Browser_divPlaceVert
   {
   if( document.layers )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentLayers || TESTFLAG_show_browserBranch )
        alert( "Browser_setTopRelative: IfDocumentLayers-branch..." );
      //***************
      obj.top = y;
      }

   else if( obj.style )
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_setTopRelative: 'obj.style'-branch..." );
      //***************
      obj.style.top = y;
      }

   else
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_setTopRelative: Else-branch..." );
      //***************
      // Browser hat nicht die benötigte Funktionalität!
      return;
      }
   }



/*======================================================================*/
/*- Teildokumentgrößen (z.B. von Texten) ermitteln:                    -*/
/*======================================================================*/

function Browser_getContentWidth( name )  // ehemals: Browser_getOffsetWidthOf
   {
   var obj = Browser_getDivByID( name );
   if( obj == null ) return;

   return Browser_getContentWidthByObj( obj );
   }


function Browser_getContentWidthByObj( obj )
   {
   if( obj.offsetWidth )
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_getContentWidth: 'obj.offsetWidth'-branch..." );
      //***************
      return obj.offsetWidth;
      }

   else if( document.layers )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentLayers || TESTFLAG_show_browserBranch )
        alert( "Browser_getContentWidth: IfDocumentLayers-branch..." );
      //***************
      return obj.document.width;
      }

   else
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_getContentWidth: Else-branch..." );
      //***************
      // Browser hat nicht die benötigte Funktionalität!
      return 0;
      }
   }


function Browser_getContentHeight( name )  // ehemals: Browser_getOffsetHeightOf
   {
   var obj = Browser_getDivByID( name );
   if( obj == null ) return;

   return Browser_getContentHeightByObj( obj );
   }

function Browser_getContentHeightByObj( obj )
   {
   if( obj.offsetHeight )
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_getContentHeight: 'obj.offsetHeight'-branch..." );
      //***************
      return obj.offsetHeight;
      }

   else if( obj.document && obj.document.height )
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_getContentHeight: 'obj.document.height'-branch..." );
      //***************
      return obj.document.height;
      }

   else
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_getContentHeight: Else-branch..." );
      //***************
      // Browser hat nicht die benötigte Funktionalität!
      return 0;
      }
   }



/*======================================================================*/
/*- Anzeigemodalitäten:                                                -*/
/*======================================================================*/

// interne Funktion
function Browser_setClip( name, north, east, south, west )  // ehemals: Browser_divSetClip
   {
   var obj = Browser_getDivByID( name );
   if( obj == null ) return;

   Browser_setClipByObj( obj, north, east, south, west );
   }
function Browser_setClipByObj( obj, north, east, south, west )  // ehemals: Browser_divSetClip
   {
   if( document.layers )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentLayers || TESTFLAG_show_browserBranch )
        alert( "Browser_setClip: IfDocumentLayers-branch..." );
      //***************
      obj.clip.top    = north;
      obj.clip.right  = east;
      obj.clip.bottom = south;
      obj.clip.left   = west;
      }

   else if( obj.style )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentAll || TESTFLAG_show_browserBranch )
        alert( "Browser_setClip: 'obj.style'-branch..." );
      //***************
      obj.style.clip = "rect(" + north + "," + east + "," + south + "," + west + ")";
      }

   else
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_setClip: Else-branch..." );
      //***************
      // Browser hat nicht die benötigte Funktionalität!
      return;
      }
   }

// interne Funktion
function Browser_setVisibility( name, vis )  // ehemals: Browser_divSetVisibility
   {
   var obj = Browser_getDivByID( name );
   if( obj == null ) return;

   Browser_setVisibilityByObj( obj, vis );
   }
function Browser_setVisibilityByObj( obj, vis )  // ehemals: Browser_divSetVisibility
   {
   if( document.layers )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentLayers || TESTFLAG_show_browserBranch )
        alert( "Browser_setVisibility: IfDocumentLayers-branch..." );
      //***************
      obj.visibility=((vis)?"show":"hide");
      }

   else if( obj.style )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentAll || TESTFLAG_show_browserBranch )
        alert( "Browser_setVisibility: 'obj.style'-branch..." );
      //***************
      obj.style.visibility=((vis)?"visible":"hidden");
      }

   else
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_setVisibility: Else-branch..." );
      //***************
      // Browser hat nicht die benötigte Funktionalität!
      return;
      }
   }

// interne Funktion
function Browser_setBgColor( name, colorSpec )  // ehemals: Browser_divSetBackgroundColor
   {
   var obj = Browser_getDivByID( name );
   var color;
   if( colorSpec == "RGB")
      {
      color = "#"
              + Browser_Number2Hex(Browser_setBgColor.arguments[2])    // red
              + Browser_Number2Hex(Browser_setBgColor.arguments[3])    // green
              + Browser_Number2Hex(Browser_setBgColor.arguments[4])    // blue
              ;
      }
   else
      {
      color = colorSpec;
      }

   if( document.layers )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentLayers || TESTFLAG_show_browserBranch )
        alert( "Browser_setBgColor: IfDocumentLayers-branch..." );
      //***************
      obj.bgColor=color;
      }

   else if( obj.style )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentAll || TESTFLAG_show_browserBranch )
        alert( "Browser_setBgColor: 'obj.style'-branch..." );
      //***************
      obj.style.backgroundColor=color;
      }

   else
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_setBgColor: Else-branch..." );
      //***************
      // Browser hat nicht die benötigte Funktionalität!
      return;
      }
   }



function Browser_definiereKachelung( id, dateinameDerKachelgrafik )
   {
   var obj = Browser_getDivByID( id );

   if( document.layers )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentLayers || TESTFLAG_show_browserBranch )
        alert( "Browser_definiereKachelung: IfDocumentLayers-branch..." );
      //***************
      obj.background.src = dateinameDerKachelgrafik;
      }

   else if( obj.style )
      {
      //***************
      if( TESTFLAG_alert_ifDocumentAll || TESTFLAG_show_browserBranch )
        alert( "Browser_definiereKachelung: 'obj.style'-branch..." );
      //***************
      obj.style.backgroundImage  = "url("+dateinameDerKachelgrafik+")";
      }

   else
      {
      //***************
      if( TESTFLAG_show_browserBranch )
        alert( "Browser_definiereKachelung: Else-branch..." );
      //***************
      // Browser hat nicht die benötigte Funktionalität!
      return;
      }
   }



/*======================================================================*/
/*- Bildwechsel:                                                       -*/
/*======================================================================*/

// interne Funktion
function Browser_changeImage( imgName, imgObj )
   {
   Browser_getImgByID( imgName ).src = imgObj.src;
   }

// interne Funktion
function Browser_loadImage( imgName, fileName )
   {
   Browser_getImgByID( imgName ).src = fileName;
   }



/*======================================================================*/
/*- Mausereignisse abfangen:                                           -*/
/*======================================================================*/

// alle Mausereignisse werden auf Dokument-Ebene abgefangen und dann an
// zuständige Module weitergeleitet, die sich zur Initialisierung
// hier anmelden müssen...

//***************
if( !TESTFLAG_inhibitCapturingMouseEvents )
   {
//***************

// alle Mausereignisse abfangen:
if (window.Event)
   {
   document.captureEvents( Event.MOUSEDOWN );
   document.captureEvents( Event.MOUSEUP );
   document.captureEvents( Event.MOUSEMOVE );
   }
document.onmousedown    = Browser_prepareEventDataForHandlerCalls;
document.onmouseup      = Browser_prepareEventDataForHandlerCalls;
document.onmousemove    = Browser_prepareEventDataForHandlerCalls;

// MouseWheel-Ereignisse nur behandeln, wenn Seite in AICB-Frameset läuft
// und keine globalen Scrollleisten vorhanden sind (wenn nämlich doch,
// dann lasse MouseWheel auf das Scrollen des gesamten Dokumentes wirken)

if( parent && !parent.GMP4WDGIN_bisherScrollingErforderlich )
   {
   if (window.Event && Event.MOUSEWHEEL)
      {
      document.captureEvents( Event.MOUSEWHEEL );
      }
   document.onmousewheel = Browser_prepareEventDataForHandlerCalls;
   }


//***************
   }
else
   {
   alert( "Browser: capturing mouse events inhibited...!" );
   }
// Ende "!TESTFLAG_inhibitCapturingMouseEvents"
//***************


function Browser_prepareEventDataForHandlerCalls( e )
   {
   // Attribute des Ereignisses browserunabhängig verfügbar machen:
   var ereignis = ( (window.Event)? e : window.event );
   var ereignisDaten = new Browser_eventDataContainer(ereignis);

   // an alle angemeldeten Mausereignis-Handler weiterleiten:
   var i;
   for( i=0 ; i<Browser_mouseEventHandlers.length ; i++ )
      {
      eval( Browser_mouseEventHandlers[i]( ereignisDaten ) );
      }

   // Default-Action zulassen oder verhindern?
   if(window.Event)
      {
      // Code für NN4, NN6, Mozilla1:  (und Opera...)
      return Browser_allowEventDefaultAction(ereignisDaten);
      }
   else
      {
      // Code für IE6: noch nicht ausgereift,
      // lediglich Notlösung, damit Widgets funktionieren...
      return false;
      }
   }



// Routine zum Anmelden eines neuen Mausereignis-Handlers:
function Browser_registerMouseEventHandler( handlerFuncRef )
   {
   Browser_mouseEventHandlers.push( handlerFuncRef );
   }

// Sammlung aller angemeldeten Mausereignis-Handler:
var Browser_mouseEventHandlers = new Array();



// Attribute des Ereignisses browserunabhängig verfügbar machen:
function Browser_eventDataContainer( ereignis )
   {
   this.type       =        ( (ereignis.type       )? ereignis.type       : Browser_ConstUndefined );
   this.target     =        ( (ereignis.target     )? ereignis.target     : Browser_ConstUndefined );
   this.target     =        ( (ereignis.srcElement )? ereignis.srcElement : this.target            );

   // für NN4:
   if( ereignis.pageX )
      {
      this.mouseAbsX  = ereignis.pageX;
      this.mouseAbsY  = ereignis.pageY;
      }

   // für IE6 und NN6:
   if( ereignis.clientX )
   if( !isNaN(document.body.scrollLeft) )
      {
      this.mouseAbsX  = ereignis.clientX + document.body.scrollLeft;
      this.mouseAbsY  = ereignis.clientY + document.body.scrollTop;
      }

   // für Mozilla:
   if(ereignis.clientX)
   if( !isNaN(window.pageXOffset) )
      {
      this.mouseAbsX  = ereignis.clientX + window.pageXOffset;
      this.mouseAbsY  = ereignis.clientY + window.pageYOffset;
      }

   if( ereignis.wheelDelta )
      {
      this.wheelDelta = ereignis.wheelDelta;  // Vielfache von 120...
      }
   }



function Browser_allowEventDefaultAction( ereignisDaten )
   {
   if( ereignisDaten.type == "mousemove")
      {
      return true;
      }
   else
      {
      // ... "mousedown" oder "mouseup":
      var elementID = "";
      if( ereignisDaten.target.name ) elementID = ereignisDaten.target.name;
      if( ereignisDaten.target.id   ) elementID = ereignisDaten.target.id;

      if( elementID.indexOf("WA") != 0 )   // "WA" ... steht für "(w)idget (a)rea...
         return true;
      else
         return false;
      }
   }



/*======================================================================*/
/*- end of file                                                        -*/
/*======================================================================*/