/*--------------------------------------------------------------------------------
 Program : framemenu.js
 
 Sprache:  javascript ab Browser V4.0
 
 Funktion: Verschachtelte Menus welche sich in einem anderen Frame als die
           Auslöserbilder befinden
 
 ---------------------------------------------------------------------------------
 Copyright (c) 1999 INM AG, Wetzikon
 ---------------------------------------------------------------------------------
 
 Revisions:
 
   1.0 - 14.9.1999 /ra

     Initial Release

   1.01 - 16.9.1999 /ra
     
     MENU_OPEN_OFFSET_X,Y hinzugefuegt um Abstand zu bestimmen mit welchem Menu
     geoeffnet werden soll.
      
 --------------------------------------------------------------------------------*/
 
/*---------------------------------------
 Klassen
 ---------------------------------------*/

function TMenuItem(aCaption,aURL,aTarget,aSubMenu,aDiv)
{
  this.Caption      = aCaption ;  // Beschriftung des Items
  this.URL          = aURL ;      // URL welcher damit geoeffent wird
  this.Target       = aTarget ;   // Target für den URL
  this.SubMenu      = aSubMenu ;  // Name des Arrays welches ggf eine Submenue Definition enthaelt
  this.Div			= aDiv ;	  // Diverses
  this.Layer        = null ;      // Layer des Menuitems
  this.MenuLayer    = null ;      // Layer des Menus welches das Item beinhaltet
}

/* end TMenuItem */

function TMenu (aMarkColor,aUMarkColor,aItems)
{
  this.Level = 0 ; // Verschachtelungstiefe in welcher sich der Mennülevel befindet.
  this.markColor = aMarkColor ;
  this.uMarkColor = aUMarkColor ;
  this.items = aItems ;
}

/*-------------------------------------------------------------------------------
 Zugriffsfunktionen
 -------------------------------------------------------------------------------*/

/*-------------------------------------------------------------------------------
 Function    menuMouseOut
 Purpose     Beim verlassen des Bildes, welches das Menu geöffnet hat, 
             schliesen aller geöffneten Menus nach einem Timeout.
 -------------------------------------------------------------------------------*/

function menuMouseOut()
{
  mnuTimer = setTimeout("closeSubMenus(0);",MENU_CLOSE_TIMEOUT2) ;
}

/*-------------------------------------------------------------------------------
 Function    menuResize
 Purpose     Problem mit Navigator, beim Resize gehen saemtlich Layer
             halb verloren. Daher wird das Targetframe neu geladen um
             einen definierten Zustand herzustellen.
 -------------------------------------------------------------------------------*/

function menuResize()
{
  if(document.layers) 
  {
    var k = eval(TARGET_WINDOW) ;
    k.location.reload() ; 
  }
}
/*-------------------------------------------------------------------------------
 Function    menuShowMenu
 Purpose     Öffnen und darstellen eines zuvor definierten Menüs.
             Die positionen geben an, wo im Targeframe das Menu dargestellt 
             werden soll. Dabei wird berücksichtigt, dass wenn im Targetframe
             gesrollt wurde, die Position angepasst wird.
 -------------------------------------------------------------------------------*/

function menuShowMenu(aMenuName,posX,posY)
{

  if (mnuTimer)
  {
    clearTimeout(mnuTimer) ;
  }
  
  closeSubMenus(0);
  
  // Sehen, ob der Layer zu diesem Menupunkt nicht bereits
  // erstellt ist, wenn nicht, neu erstellen
  if(document.layers) 
  {
    var k = eval(TARGET_DOCUMENT + "." + aMenuName) ;
  } else {
    var k = eval(TARGET_DOCUMENT + ".all." + aMenuName) ;
  }
  if ( !k ) {
    k = dynBuildMenu(aMenuName,200,1) ;
  }

  var td = eval(TARGET_WINDOW) ;
  // Menulayer Positionieren
  if(document.layers) 
  {
    var aX = posX + td.pageXOffset ;
    var aY = posY + td.pageYOffset ;
    k.moveTo(aX,aY) ;
  } else {
    k.style.pixelLeft = posX + td.document.body.scrollLeft ;
    k.style.pixelTop  = posY + td.document.body.scrollTop ;
  }
  
  showMenu(k) ;
}

/*-------------------------------------------------------------------------------
 Privat Variables 
 -------------------------------------------------------------------------------*/

mnuTimer = null ;
openMenuLayers = new Array (null,null,null,null) ;

CurrentItem = null ;
LastItem = null ;

MENU_OPEN_OFFSET_X = 10 ;
MENU_OPEN_OFFSET_Y = 3 ;

/*-------------------------------------------------------------------------------
 Event Handler
 -------------------------------------------------------------------------------*/

function onItemMouseClick(ev) 
{
  if (this.MenuItem.URL != "")
  {
    window.open(this.MenuItem.URL,this.MenuItem.Target) ;
  }
}

function onItemMouseOver(ev)
{
  
  var l ;
  var k ;
  var s ;
  
  if (mnuTimer)
  {
    clearTimeout(mnuTimer) ;
  }

  // ev ist der Layer des MenuItems in welches 
  // eingetreten wurde
  if(document.layers) 
  {
    l = ev.target ;
    l.bgColor = l.markColor ;
  } else {
    //alert(this) ;
    l = this ;
    // Wenn im Explorer über ein Element gefahren wird, welches auf dem Layer ist,
    // wird ebenfalls diese Rutine aufgerufen. Als Layer nehmen wir dan den Parent dieses
    // Elements an!
    if (l.tagName == "DIV") 
    { 
      l.style.background = l.markColor ;
    }
  }

  menuMark(l) ;

  // Alle Menulayers welche sich in einem höheren Level 
  // als unserem befinden schliessen !
  if (! l.MenuItem) { return ; } 

  closeSubMenus(l.MenuItem.MenuLayer.Level) ; 

  // Wenn Item submenus hat, diese öffnen.
  if (l.MenuItem.SubMenu)
  {
    openSubMenu(l.MenuItem,0,0)
  }
}

function onItemMouseOut(ev)
{
  if(document.layers) 
  {
    l = ev.target ;
    l.bgColor = l.uMarkColor ;
  } else {

    l = this ;

    if (l.tagName == "DIV") 
    { 
      l.style.background = l.uMarkColor ;
    }
  }
  menuUnMark(l) ;
  mnuTimer = setTimeout("closeSubMenus(0);",MENU_CLOSE_TIMEOUT) ;
}

/*-------------------------------------------------------------------------------
 Function    openSubMenu
 Purpose     Wenn übe ein Menuitem gefahren wird, welches submenus enthält,
             werden diese Submenus hier geöffnet.
 -------------------------------------------------------------------------------*/

function openSubMenu (aMenuItem,aX,aY)
{
  
  var s ;
  var k ;
    
  s = aMenuItem.SubMenu ;

  // feststellen, ob der Layer für dieses Menu im Target Frame
  // existiert (wird gelöscht, bei einem Reload des Targetframes)
  if (document.layers) 
  {
    lyr = eval(TARGET_DOCUMENT + "." + s ) ;
  } else {
    lyr = eval(TARGET_DOCUMENT + ".all." + s ) ;
  }
  // alert("Layer in OpenSubMenu = " + lyr) ;

  // Wenn der Layer noch nicht existiert, wird er neu 
  // erstellt.
  if ( ! lyr )
  {
    lyr = dynBuildMenu(s,200,aMenuItem.MenuLayer.Level + 1) ;
  }
  if (! lyr ) 
  {
    sayError("openSubMenu","Layer konnte nicht gefunden oder erstellt werden") ;
  }
  l = aMenuItem.Layer ;

  // Netscape and IE4 specific
  if(document.layers) 
  {
    aX = l.pageX + l.clip.width + MENU_OPEN_OFFSET_X ;
    aY = l.pageY + MENU_OPEN_OFFSET_Y ;
    lyr.moveTo(aX , aY) ;
  } else {
    aX = aMenuItem.MenuLayer.style.pixelLeft  + aMenuItem.MenuLayer.style.pixelWidth ;
    aY = l.style.pixelTop + aMenuItem.MenuLayer.style.pixelTop ;
    lyr.style.left = aX + MENU_OPEN_OFFSET_X ;
    lyr.style.top = aY + MENU_OPEN_OFFSET_Y ;
  }
  showMenu(lyr) ;
}

/*-------------------------------------------------------------------------------
 Function    dynBuildMenu
 Purpose     Erstellt einen Menulayer dynamisch, wird benoetigt, wenn ein Layer erst 
             erstellt wird, die Seite bereits fertig erstellt ist.
 -------------------------------------------------------------------------------*/

function dynBuildMenu( aMenu , aWidth , aLevel)
{
  
  var pl ;
  var l ;
  var y ;
  var a ;
  var s ;
  var i ;
  var n ;
  var item ;
  var target ;

  // alert("Create Layer "+aMenu) ;
    
  // Netscape and IE4 specific
  // Neuen Layer mit dem Namen aMenu erstellen
  if(document.layers) 
  {
    eval(TARGET_DOCUMENT + "." + aMenu + " = " +
      " new Layer(" + ITEM_WIDTH + "," + TARGET_WINDOW + ") ") ;
    pl = eval(TARGET_DOCUMENT + "." + aMenu) ;
    pl.bgColor = MENU_BACKGROUND_COLOR ;
    pl.visibility = "inherit" ;
    pl.zIndex = 5; 

	      
  } else {
     s = "<DIV ID=" + aMenu + " STYLE='position:absolute; filter:alpha(); cursor:hand;'></DIV>" ;
     target = eval(TARGET_DOCUMENT) ;
     target.body.insertAdjacentHTML("BeforeEnd",s);
     pl = target.all[aMenu] ;
     pl.style.width = ITEM_WIDTH ;
	 pl.style.backgroundColor = MENU_BACKGROUND_COLOR;
	 pl.visibility = "inherit" ;
	 pl.zIndex = 5;
	 pl.filters.alpha.opacity = IE_ALPHA; 
  }

  
  if (pl == null) {
    sayError("dynBuildMenu","Layer "+aMenu+"konnte nicht erstellt werden !") ;
  }

  // Array Element mit dem Namen aMenu in a 
  // speichern und die einzelnen Menuitem Layer erstellen.
  a = eval(aMenu) ;

  // Mouseover + level setzen
  pl.onmouseover = onMenuMouseOver ;
  pl.onmouseout  = onMenuMouseOut ;
  
  pl.Level = aLevel ;
  pl.markColor = a.markColor ;
  pl.uMarkColor = a.uMarkColor ;

  y = 0 ;
  for ( i = 0 ; i < a.items.length ; i++ )
  {
    n = aMenu + '__' + i ;
    item = a.items[i] ;

    l = 0 ;

    // Netscape and IE4 specific
    if(document.layers) 
    {
      l = new Layer(ITEM_WIDTH,pl) ; 
      l.top  = y + MENU_OFFSET_TOP;
	  l.left = l.left + MENU_OFFSET_LEFT;
      l.bgColor = pl.uMarkColor ;
      l.visibility = "inherit" ;
      l.captureEvents(Event.MOUSEUP) ;
    } else {
      s = "<DIV ID=" + n + " STYLE='position:absolute'></DIV>";
      pl.insertAdjacentHTML("BeforeEnd",s);
	  l = pl.document.all[n];
      l.style.top = y + MENU_OFFSET_TOP ;
	  l.style.left = l.style.left + MENU_OFFSET_LEFT;	 
      l.style.width = ITEM_WIDTH ;
      l.style.background = pl.uMarkColor ;
    }
	l.zIndex = 15;
    l.onmouseover = onItemMouseOver ;
    l.onmouseout  = onItemMouseOut ;
    l.onmouseup = onItemMouseClick ;
    
    s = menuGetInnerHTML(item.Caption,item.SubMenu,n) ;

    // Netscape and IE4 specific
    if(document.layers) 
    {
      with (l.document) 
      { 
        open () ;
        write(s) ;
        close() ;
      }
    } else {
      l.insertAdjacentHTML("BeforeEnd",s);
    }

    l.markColor = pl.markColor ;
    l.uMarkColor = pl.uMarkColor ;
    l.MenuItem = item ;
    item.Layer = l ;
    item.MenuLayer = pl ;
    item.Index = i ;
    
    y += ITEM_HEIGHT ;
  }

  
  // Netscape and IE4 specific
  if(document.layers) 
  {
    pl.resizeTo((ITEM_WIDTH+(MENU_OFFSET_LEFT*2)),(y+(MENU_OFFSET_TOP*2))) ;
  } else {
    pl.style.width = (ITEM_WIDTH+(MENU_OFFSET_LEFT*2)) ;
    pl.style.height = (y+(MENU_OFFSET_TOP*2)) ;
  }
  
  return(pl) ;
}

function onMenuMouseOver(ev)
{
}

function onMenuMouseOut(ev)
{
}


/*-------------------------------------------------------------------------------
 Function    showMenu
 Purpose     Anzeigen eines Menulayers mit den darauf befindlichen Items.
 -------------------------------------------------------------------------------*/

function showMenu(aMenu)
{
  if(document.layers) 
  {
    aMenu.visibility = "show" ;
	aMenu.zIndex = aMenu.zIndex + 5;
  } else {
    aMenu.style.visibility = "visible" ;
	aMenu.style.zIndex = aMenu.style.zIndex + 5;
  }
  openMenuLayers[aMenu.Level] = aMenu ;
}

/*-------------------------------------------------------------------------------
 Function    hideMenu
 Purpose     Verbergen eines Menulayers mit den darauf befindlichen Items.
 -------------------------------------------------------------------------------*/

function hideMenu(aMenu)
{
  l = aMenu ;
  
  if(document.layers) 
  {
    l.visibility = "hide" ;
	l.zIndex = aMenu.zIndex - 5;
  } else {
    l.style.visibility = "hidden" ;
	l.style.zIndex = aMenu.style.zIndex - 5;
  }
  //change_img("img" + nr_old,'n',"menu" + nr_old +"x");
  openMenuLayers[aMenu.Level] = null ;
}

/*-------------------------------------------------------------------------------
 Function    closeSubmenus
 Purpose     
 -------------------------------------------------------------------------------*/

function closeSubMenus (aLevel)
{
  
  var i ;
  
  for ( i = openMenuLayers.length ; i > aLevel ; i -- )
  {
     if (openMenuLayers[i])
     {
	   //change_img("img" + nr_old,'n',"menu" + nr_old +"x");
       hideMenu(openMenuLayers[i]) ;
     } 
  }
}

function WriteDebug(txt) 
{
   document.all["debug"].insertAdjacentHTML("BeforeEnd",txt+'<BR>');
}

/*-------------------------------------------------------------------------------
 Function    sayError
 Purpose     Ausgeben einer Fehlermeldung.
 -------------------------------------------------------------------------------*/

function sayError(aFunction,aText) 
{
  alert("Error in function " + aFunction + "\n" + aText) ;
}