<!-- Inhalt des JavaScripts für den Browser unsichtbar machen.
//
// Dateiname:     antZILLA.rollen.js
// Copyright (C): aXL keschner / aXL-online.com 2006-2008
// Version:       2008-11-24
//
// Diese Datei enthaelt Funktionen zur Durchfuehrung des Rollens:
//
// aXL_rollevent (...)
//    Bereitet das Rollen nach einem Event vor.
//
// aXL_rolleventaus (...)
//    Beendet die Ueberwachung der Mausbewegung
//    und loescht die verwendeten Variablen.
//
// aXL_rollezu (...)
//    Fuehrt das Rollen zu einem Querverweis-Ziel aus.
//
// aXL_rollschritt (...)
//    Rollt in festen Schritten zur Zielposition.
//
// aXL_rollover (...)
//    Rollt solange MOUSEOVER bei einem Button aktiv ist.
//
// aXL_rollstop (...)
//    Beendet das Timer-gesteuerte Rollen.
//
// aXL_rollsync (...)
//    Synchronisiert ein RollTool mit seinem zugehoerigen RollItem.
//
// aXL_rollkorrekt (...)  !!!!!!!!! momentan nicht verwendet !!!!!!!!!
//    Berechnet fuer die vertikale Position des Contents und des Reglers
//    einen Korrekturwert,
//    falls die Seite mit einem Anker als Sprungziel aufgerufen wurde.
//
//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////

// Hilfe-Link:
// file:///D:/webdesign/hilfen_und_scripte/SELFHTML/SELFHTML80/dhtml/beispiele/navigation.htm

//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////

//alert("antZILLA.rollen.js");

// Ueberwachung fuer die Ereignisse MOUSEDOWN und MOUSEUP aktivieren:
if ( document.captureEvents )
{
   document.captureEvents(Event.MOUSEDOWN | Event.MOUSEUP);
}
document.onmousedown = aXL_rollevent;
document.onmouseup = aXL_rolleventaus;

//////////////////////////////////////////////////////////////////

function aXL_rollevent (dieses_event)
//
// Copyright (C): aXL keschner / aXL-online.com 2006-2007
// Version:       2007-07-07
//
// Bereitet das Rollen nach einem Event vor.
//
// Parameter:
//   dieses_event = diese Function ausloesendes Event: MOUSEDOWN oder MOUSEMOVE.
//
{
   // Keine Aktion, wenn die aufrufende Rollspur nicht definiert ist:
   if (  typeof(meine_rollspur)=="undefined"
      || !meine_rollspur
      || meine_rollspur==null
      || meine_rollspur==""
      )
   {
//      alert("aXL_rollevent return: '"+dieses_event+"'");
      return;  // Ohne "false", sonst kein Markieren mehr auf der Seite moeglich!
   }
//else      alert("aXL_rollevent ok: '"+dieses_event+"'");


   // Zusaetzlich die Ueberwachung der Mausbewegung einschalten:
   if ( document.captureEvents )
      document.captureEvents(Event.MOUSEMOVE);
   document.onmousemove = aXL_rollevent;

   // Noch fehlende Parameter berechnen oder definieren:
   var diese_rollspur = meine_rollspur;
//alert("aXL_rollevent diese_rollspur: '"+diese_rollspur+"'");
   var diese_itempos = aXL_abspos (diese_rollspur);
   var diese_laenge = diese_rollspur.id.length;
   var diese_rollid = diese_rollspur.id.substring(0,diese_laenge-11);
   // ACHTUNG: BEI AENDERUNG DER ID's KANN SICH OBIGER ZAHLENWERT AENDERN !!!!!!!!!
   var diese_rollachse = diese_rollspur.id.substring(diese_laenge-1).toLowerCase();
   var dieser_rollregler = document.getElementById ( diese_rollid
                                                   + "_rollregler_"
                                                   + diese_rollachse
                                                   );
   var dieses_y, dieses_x;
//alert(diese_rollachse);

   // Mausposition in der Rollspur berechnen:
   if ( dieses_event && (dieses_event.pageX || dieses_event.pageY) )
   {
      dt = 1;
      dieses_x = dieses_event.pageX;
      dieses_y = dieses_event.pageY;
   }
   else
   if ( dieses_event && (dieses_event.clientX || dieses_event.clientY) )
   {
      dt = 2;
      dieses_x = dieses_event.clientX;
      dieses_y = dieses_event.clientY;
   }
   else
   if ( window.event && (window.event.clientX || window.event.clientY) )
   {
      dt = 3;
      dieses_x = window.event.clientX;
      dieses_y = window.event.clientY;
   }
   dieses_x = parseInt (dieses_x);
   dieses_y = parseInt (dieses_y);
/*
   window.status = dt
//                 + " / " + diese_itempos[1]
                 + " / " + ( dieses_x - diese_itempos[0] )
                 + " / " + ( dieses_y - diese_itempos[1] )
                 ;
*/
   dieses_x -= diese_itempos[0];
   dieses_y -= diese_itempos[1];
/*
   window.status = dt
                 + " / " + dieses_x
                 + " / " + dieses_y
                 ;
*/

   // Zielposition berechnen und Sprung dorthin aufrufen:
   if ( diese_rollachse == "x" )
   {
      if (  dieses_x < 0
         || dieses_x > diese_rollspur.offsetWidth
         )
      // Die Maus ist links oder rechts von der Spur:
      {
//window.status = dieses_x + " nix";
      }
      else
      if ( dieses_x < dieser_rollregler.offsetLeft )
      // Die Maus ist links vom Regler:
      {
//window.status = dieses_x + " nach links";
         dieses_ziel = dieses_x
                     / (diese_rollspur.offsetWidth - dieser_rollregler.offsetWidth)
                     ;
         aXL_rollschritt (dieses_ziel);
      }
      else
      if ( dieses_x > dieser_rollregler.offsetLeft+dieser_rollregler.offsetWidth )
      // Die Maus ist rechts vom Regler:
      {
//window.status = dieses_x + " nach rechts";
         dieses_ziel = (dieses_x - dieser_rollregler.offsetWidth)
                     / (diese_rollspur.offsetWidth - dieser_rollregler.offsetWidth)
                     ;
         aXL_rollschritt (dieses_ziel);
      }
      else
      // Die Maus ist auf dem Regler und soll ihn ziehen:
      {
//window.status = dieses_x + " horizontal ziehen";
      }
   }
   else
   if ( diese_rollachse == "y" )
   {
      if (  dieses_y < 0
         || dieses_y > diese_rollspur.offsetHeight
         )
      // Die Maus ist ueber oder unter der Spur:
      {
//window.status = dieses_y + " nix";
      }
      else
      if ( dieses_y < dieser_rollregler.offsetTop )
      // Die Maus ist oberhalb des Reglers:
      {
//window.status = dieses_y + " auf";
         dieses_ziel = dieses_y
                     / (diese_rollspur.offsetHeight - dieser_rollregler.offsetHeight)
                     ;
         aXL_rollschritt (dieses_ziel);
      }
      else
      if ( dieses_y > dieser_rollregler.offsetTop+dieser_rollregler.offsetHeight )
      // Die Maus ist unterhalb des Reglers:
      {
//window.status = dieses_y + " ab";
         dieses_ziel = (dieses_y - dieser_rollregler.offsetHeight)
                     / (diese_rollspur.offsetHeight - dieser_rollregler.offsetHeight)
                     ;
         aXL_rollschritt (dieses_ziel);
      }
      else
      // Die Maus ist auf dem Regler und soll ihn ziehen:
      {
//window.status = dieses_y + " vertikal ziehen";
         if ( dieser_rollregler.offsetTop < 0 )
            aXL_rollschritt (0);
         else
         if ( ( dieser_rollregler.offsetTop + dieser_rollregler.offsetHeight )
              >
              ( diese_rollspur.offsetHeight )
            )
            aXL_rollschritt (1);
         else
         if ( typeof(dieses_altey)=="undefined" || !dieses_altey )
         {
            dieses_altey = dieses_y;
         }
         else
         if ( dieses_altey != dieses_y )
         {
            dieses_ziel = ( dieser_rollregler.offsetTop
                          + dieses_y
                          - dieses_altey
                          )
                        / ( diese_rollspur.offsetHeight
                          - dieser_rollregler.offsetHeight
                          )
                        ;
            dieses_altey = dieses_y;
            aXL_rollschritt (dieses_ziel);
         }
      }
   }
}

//////////////////////////////////////////////////////////////////

function aXL_rolleventaus (dieses_ereignis)
//
// Copyright (C): aXL-online.com 2006-2007
// Version:       2007-06-24
//
// Beendet die Ueberwachung der Mausbewegung
// und loescht die verwendeten Variablen.
//
// Parameter:
//   dieses_ereignis = diese Function ausloesendes Event;
//
{
   if ( document.releaseEvents )
      document.releaseEvents(Event.MOUSEMOVE);
   document.onmousemove = null;
   meine_rollspur = null;
   dieses_x = null;
   dieses_y = null;
   dieses_altex = null;
   dieses_altey = null;
//   window.status = null;
}

//////////////////////////////////////////////////////////////////

function aXL_rollezu (dieser_name)
//
// Copyright (C): aXL keschner / aXL-online.com 2006-2007
// Version:       2007-07-07
//
// Fuehrt das Rollen zu einem Querverweis-Ziel aus.
//
// Parameter:
//   dieser_name: Anker-Name fuer den Querverweis.
//
{
   // Ueberlaenge = Anteil des RollItems,
   // der nicht in der RollBox zu sehen ist:
   var dieses_rollitem = document.getElementById ("content");
   var diese_ueberlaenge = dieses_rollitem.offsetHeight
                         - dieses_rollitem.parentNode.offsetHeight
                         ;

   // Zielposition fuer den Querverweis ermitteln:
   dieses_ziel = document.getElementsByName(dieser_name)[0];  // Array!
   dieses_ziel = dieses_ziel.offsetTop;
   // Zielposition relativ zur Ueberlaenge:
   dieses_ziel = dieses_ziel / diese_ueberlaenge;
   // Zielposition begrenzen auf die Ueberlaenge:
   dieses_ziel = Math.min ( dieses_ziel
                          , 1
                          )
                          ;
//alert(dieses_ziel);

   // Sprung vorbereiten und ausfuehren:
   meine_rollspur = document.getElementById ("content_rollspur_y") ;
   aXL_rollschritt (dieses_ziel);
   meine_rollspur = null;
}

//////////////////////////////////////////////////////////////////

function aXL_rollschritt (dieses_ziel)
//
// Copyright (C): aXL keschner / aXL-online.com 2006-2007
// Version:       2007-07-07
//
// Rollt in festen Schritten zur Zielposition.
//
// Parameter:
//   dieses_ziel = Zielposition relativ zur Groesse des RollItems.
//
{
   // Keine Aktion, wenn die aufrufende Rollspur nicht definiert ist:
   if (  typeof(meine_rollspur)=="undefined"
      || !meine_rollspur
      || meine_rollspur==null
      || meine_rollspur==""
      )
   {
//      alert("aXL_rollschritt return: '"+dieses_ziel+"'");
      return;  // Ohne "false", sonst kein Markieren mehr auf der Seite moeglich!
   }
//else      alert("aXL_rollschritt ok: '"+dieses_ziel+"'");

   // Noch fehlende Parameter berechnen oder definieren:
   var diese_rollspur = meine_rollspur;
//alert("aXL_rollschritt diese_rollspur: '"+diese_rollspur+"'");
   var diese_laenge = diese_rollspur.id.length;
   var diese_rollid = diese_rollspur.id.substring(0,diese_laenge-11);
   // ACHTUNG: BEI AENDERUNG DER ID's KANN SICH OBIGER ZAHLENWERT AENDERN !!!!!!!!!
   var dieses_rollitem = document.getElementById (diese_rollid);
   var diese_rollachse = diese_rollspur.id.substring(diese_laenge-1).toLowerCase();
   var diese_rollzeile = 15;
//window.status = diese_rollachse + " ziehen nach: " + dieses_ziel;

   // Eventuell noch aktiven alten Timer deaktivieren, da sonst Konflikt:
   aXL_rollstop (diese_rollid);

   // Naechsten Schritt zur Zielposition berechnen:
   if (diese_rollachse == "x")
   {
      var dieses_rollfenster = dieses_rollitem.parentNode.offsetWidth;
      var diese_neupos = (-1)
                       * ( dieses_rollitem.offsetWidth - dieses_rollfenster )
                       * dieses_ziel
                       ;
      var dieser_schritt = diese_neupos - dieses_rollitem.offsetLeft;
   }
   else
   {
      var dieses_rollfenster = dieses_rollitem.parentNode.offsetHeight;
      var diese_neupos = (-1)
                       * ( dieses_rollitem.offsetHeight - dieses_rollfenster )
                       * dieses_ziel
                       ;
      var dieser_schritt = diese_neupos - dieses_rollitem.offsetTop;
   }
   if ( dieser_schritt > (dieses_rollfenster - diese_rollzeile) )
   {
      dieser_schritt = dieses_rollfenster - diese_rollzeile;
      diese_rollzeile = 0;
   }
   else
   if ( dieser_schritt < (diese_rollzeile - dieses_rollfenster) )
   {
      dieser_schritt = diese_rollzeile - dieses_rollfenster;
      diese_rollzeile = 0;
   }

   // Naechsten Schritt zur Zielposition ausfuehren:
   if (diese_rollachse == "x")
      dieses_rollitem.style.left = dieses_rollitem.offsetLeft + dieser_schritt;
   else
      dieses_rollitem.style.top  = dieses_rollitem.offsetTop  + dieser_schritt;
   aXL_rollsync (diese_rollid, diese_rollachse);

   // Falls noetig, weiteren Schritt nach kurzer Pause ausfuehren:
   if ( diese_rollzeile == 0 )
      dieses_rollitem.dieser_rolltimer = setTimeout
                                       ( "aXL_rollschritt ('" + dieses_ziel + "')"
                                       , 500
                                       )
                                       ;
}

//////////////////////////////////////////////////////////////////

function aXL_rollover (diese_rollid, diese_richtung, diese_geschwindigkeit)
//
// Copyright (C): aXL keschner / aXL-online.com 2006-2007
// Version:       2007-07-07
//
// Rollt solange MOUSEOVER bei einem Button aktiv ist.
//
// Parameter:
//   diese_rollid        = ID des zu rollenden Items;
//   diese_richtung        = "auf", "ab", "li", "re"
//   diese_geschwindigkeit = Faktor zur Verkuerzung des Intervalls: 1,3 ...
//
{
   // Ermittlung des RollItems:
   var dieses_rollitem = document.getElementById (diese_rollid);
   // Voreinstellung fuer die Rollrichtung:
   diese_richtung = ( diese_richtung )
                  ? diese_richtung.toLowerCase()
                  : "ab"
                  ;
   // Bewegungsachse aus der Rollrichtung oder Voreinstellung ermitteln:
   var diese_achse = ( diese_richtung == "li" || diese_richtung == "re" )
                   ? "x"
                   : "y"
                   ;
   // Voreinstellung fuer die Geschwindigkeit:
   diese_geschwindigkeit = ( diese_geschwindigkeit )
                         ? diese_geschwindigkeit
                         : 1
                         ;
   var mein_intervall = 20;
   dieses_intervall = mein_intervall;  //  / diese_geschwindigkeit;
   // Voreinstellung fuer die Schrittweite:
   var dieser_schritt = 2;

//alert(dieses_rollitem.offsetTop);

   // Berechnung der aktuellen Bewegung:
   dieser_schritt = dieser_schritt * diese_geschwindigkeit;
   if ( diese_richtung == "auf" )
   {
      diese_position = Math.abs ( dieses_rollitem.offsetTop
//                                - aXL_rollkorrekt (dieses_rollitem)
                                )
                                ;
      if ( dieser_schritt > diese_position )  // Oberes Ende (fast) erreicht.
      {
         dieser_schritt = diese_position;
         if ( dieser_schritt > 2 )
            dieser_schritt -= 1;
      }
      dieser_schritt = 0 - dieser_schritt;  // Schritt in negative Richtung!
   }
   else
   if ( diese_richtung == "li" )
   {
      diese_position = Math.abs(dieses_rollitem.offsetLeft);
      if ( dieser_schritt > diese_position )  // Linkes Ende (fast) erreicht.
      {
         dieser_schritt = diese_position;
         if ( dieser_schritt > 2 )
            dieser_schritt -= 1;
      }
      dieser_schritt = 0 - dieser_schritt;  // Schritt in negative Richtung!
   }
   else
   if ( diese_richtung == "ab" )
   {
      diese_position = dieses_rollitem.offsetHeight
                     + dieses_rollitem.offsetTop
//                     - aXL_rollkorrekt (dieses_rollitem)
                     - dieses_rollitem.parentNode.offsetHeight;
      if ( dieser_schritt > diese_position )  // Unteres Ende (fast) erreicht.
      {
         dieser_schritt = diese_position;
         if ( dieser_schritt > 2 )
            dieser_schritt -= 1;
      }
   }
   else
   if ( diese_richtung == "re" )
   {
      diese_position = dieses_rollitem.offsetWidth
                     + dieses_rollitem.offsetLeft
                     - dieses_rollitem.parentNode.offsetWidth;
      if ( dieser_schritt > diese_position )  // Rechtes Ende (fast) erreicht.
      {
         dieser_schritt = diese_position;
         if ( dieser_schritt > 2 )
            dieser_schritt -= 1;
      }
   }

   // Rollen ausfuehren:
   if (dieses_rollitem)
   {
//      clearInterval (dieses_rollitem.dieser_rolltimer);
      if (diese_achse=="x")
         dieses_rollitem.style.left = ( dieses_rollitem.offsetLeft
                                      - dieser_schritt
                                      )
                                    + "px"
                                    ;
      else
         dieses_rollitem.style.top = ( dieses_rollitem.offsetTop
                                     - dieser_schritt
                                     )
                                   + "px"
                                   ;
//         dieses_rollitem.setAttribute ("style", "top:" + dieses_y);
//         dieses_rollitem.style.top = dieses_rollitem.offsetTop - dieser_schritt;
      aXL_rollsync (diese_rollid, diese_achse);
//      alert ("id: "+dieses_rollitem.id);
//      if ( dieser_schritt == 0 )
         aXL_rollstop (diese_rollid);
//      else
//      if ( !dieses_rollitem.dieser_rolltimer )
//      {
// alert ("else: "+dieses_rollitem.id);
         dieses_rollitem.dieser_rolltimer = setTimeout
                                          ( "aXL_rollover ('"
                                                          + diese_rollid
                                                          + "', '"
                                                          + diese_richtung
                                                          + "', '"
                                                          + diese_geschwindigkeit
                                                          + "')"
                                          , dieses_intervall
                                          )
                                          ;
//      }
   }
//else alert ("rollitem nicht gefunden"); // +dieses_rollitem.id
}

//////////////////////////////////////////////////////////////////

function aXL_rollstop (diese_rollid)
//
// Copyright (C): aXL keschner / aXL-online.com 2006-2007
// Version:       2007-07-07
//
// Beendet das Timer-gesteuerte Rollen.
//
// Parameter:
//   diese_rollid = ID des zu rollenden Items;
//
{
   var dieses_rollitem = document.getElementById (diese_rollid);
   if (  (document.layers || document.all || document.getElementById)
      && dieses_rollitem
      && dieses_rollitem.dieser_rolltimer
      )
      clearTimeout (dieses_rollitem.dieser_rolltimer);
      dieses_rollitem.dieser_rolltimer = null;  // Wichtig !!!
}

//////////////////////////////////////////////////////////////////

function aXL_rollsync (diese_rollid, diese_achse)
//
// Copyright (C): aXL keschner / aXL-online.com 2006-2007
// Version:       2007-07-07
//
// Synchronisiert ein RollTool mit seinem zugehoerigen RollItem.
//
// Parameter:
//   diese_rollid = ID des zu rollenden Items,
//   diese_achse    = Achse in der gerollt wird: "x" oder "y".
//
{
   var dieses_rollitem = document.getElementById (diese_rollid);

   // RollBox ermitteln, die das RollItem enthaelt:
   var diese_rollbox = dieses_rollitem.parentNode;

   // Anteil des RollItems, der in der RollBox zu sehen ist:
   var diese_relativehoehe  = diese_rollbox.offsetHeight
                            / dieses_rollitem.offsetHeight
                            ;
   var diese_relativebreite = diese_rollbox.offsetWidth
                            / dieses_rollitem.offsetWidth
                            ;

   // Groesse und Position des Reglers in der Spur synchronisieren
   // sowie Sichtbarkeit des RollTools festlegen:
   var dieser_regler = document.getElementById ( dieses_rollitem.id
                                               + "_rollregler_"
                                               + diese_achse
                                               )
                                               ;
   var diese_spur = document.getElementById ( dieses_rollitem.id
                                            + "_rollspur_"
                                            + diese_achse
                                            )
                                            ;
   var dieses_rolltool = document.getElementById ( dieses_rollitem.id
                                                 + "_rolltool_"
                                                 + diese_achse
                                                 )
                                                 ;
   if (diese_achse=="x")
   {
      dieser_regler.style.width = diese_spur.offsetWidth
                                * diese_relativebreite
                                ;
      dieser_regler.style.left = (-1)
                               * dieses_rollitem.offsetLeft
                               * diese_spur.offsetWidth
                               / dieses_rollitem.offsetWidth
                               ;
      dieses_rolltool.style.visibility = (diese_relativebreite == 1)
                                       ? "hidden"
                                       : "visible"
                                       ;
   }
   else
   {
      dieser_regler.style.height = diese_spur.offsetHeight
                                 * diese_relativehoehe
                                 ;
      dieser_regler.style.top = (-1)
                              * ( dieses_rollitem.offsetTop
//                                - aXL_rollkorrekt (dieses_rollitem)
                                )
                              * diese_spur.offsetHeight
                              / dieses_rollitem.offsetHeight
                              ;
      dieses_rolltool.style.visibility = (diese_relativehoehe == 1)
                                       ? "hidden"
                                       : "visible"
                                       ;
   }
}

//////////////////////////////////////////////////////////////////

function aXL_rollkorrekt (dieses_rollitem)
//
// Copyright (C): aXL keschner / aXL-online.com 2007
// Version:       2007-07-07
//
// Berechnet fuer die vertikale Position des Contents und des Reglers
// einen Korrekturwert,
// falls die Seite mit einem Anker als Sprungziel aufgerufen wurde.
//
// Parameter:
//   dieses_rollitem = das zu rollende Item.
//
{
   var dieser_korrekturwert = 0;
   var diese_ueberlaenge = dieses_rollitem.offsetHeight
                         - dieses_rollitem.parentNode.offsetHeight
                         ;
   var dieser_anker = window.location.hash.substr(1);

   if (  dieses_rollitem.id.toLowerCase() == "content"
      && dieser_anker
      && dieser_anker != ""
      )
   {
      dieser_anker = document.getElementsByName(dieser_anker)[0];  // Array !!!
      dieser_korrekturwert = Math.min ( dieser_anker.offsetTop
//                                      + dieser_anker.fontsize
//                                      + dieses_rollitem.getAttribute("fontsize")
                                      - document.all.content.offsetTop
                                      , diese_ueberlaenge
                                      )
                                      ;
window.status = "top: " + document.all.content.offsetTop + " || ";
window.status += dieser_anker.offsetHeight + " || ";
window.status += "anker-name: " + dieser_anker.name + " || ";
window.status += "anker-top: " + dieser_anker.offsetTop + " || ";
window.status += "korrektur: " + dieser_korrekturwert;
   }
//alert(dieser_korrekturwert);
   return dieser_korrekturwert;
}

//////////////////////////////////////////////////////////////////
// Folgenden Text für den Browser wieder sichtbar machen. -->