var menu_mindset1_behaviour = 'accordeon';
var menu_mindset1_timer = 300;

/**
 * Klapt de lijst met subitems uit en alle andere lijsten met subitems in
 *
 * @param integer li_id
 * @param string action       [open, close, auto] auto is omdraaien, dus open als hij close is en close als hij open is
 * @param boolean timer       vertraging bij open en sluiten.
 */
function expandList(li_id, action, timer)
{
  //alert2('expandList '+ li_id);

  if (typeof(action)=='undefined') action = 'auto';

  var li = (typeof(li_id)=='object') ? li_id : getObj(li_id);

  // misschien is li een element in een li (bijvoorbeeld een a), dan omhoog klimmen tot de li gevonden is
  while (li.tagName.toLowerCase()!='li') {
    li = li.parentNode;
  }

  // dit gaat stuk in IE
  if (li) {
    var parent = li.parentNode;

    // eerst alle andere nodes op dit niveau deactiveren
    var close_items = getChildren(parent, 'li');

    //alert2(close_items);

    for (var i=0; i<close_items.length; i++) {
      if (close_items[i] != li) {
        var uls = close_items[i].getElementsByTagName('ul');

        if (uls.length) {
          removeClass(close_items[i], 'exp-open');
          addClass(close_items[i], 'exp-closed');
          removeClass(uls[0], 'list-open');
          addClass(uls[0], 'list-closed');
        }
      }
    }

    // de lijst met kinderen openen/sluiten
    var uls = li.getElementsByTagName('ul');
    if (uls.length) {
      if ((hasClass(uls[0], 'list-open') && action=='auto') || action=='close'){
        removeClass(uls[0], 'list-open');
        removeClass(uls[0].parentNode.firstChild,'keep-active');
        addClass(uls[0], 'list-closed');
      }
      else if ((hasClass(uls[0], 'list-closed') && action=='auto') || action=='open') {
        removeClass(uls[0], 'list-closed');
        addClass(uls[0], 'list-open');
        addClass(uls[0].parentNode.firstChild,'keep-active');
        addExpanders(uls[0], uls[0]['id']+ '_sub');
      }
    }

    // het item zelf op geopend/gesloten zetten
    if ((hasClass(li, 'exp-open') && action=='auto') || action=='close'){
      removeClass(li, 'exp-open');
      addClass(li, 'exp-closed');
    }
    else if ((hasClass(li, 'exp-closed') && action=='auto') || action=='open') {
      removeClass(li, 'exp-closed');
      addClass(li, 'exp-open');
    }
  }
  else {
    //alert2('Li is geen object');
    //alert2(typeof(li));
    //alert2(li);
  }
}

/**
 * Past alle li's aan met submenu's en zonder link zodat ze hun submenu's kunnen uit- en inklappen
 *
 * @param element ul      De ul waarvan alle elementen moeten worden geprocessed
 * @param string prefix   De prefix die aan id's van elementen moet worden gegeven, voor recursie
 *
 * Uit de global scope wordt menu_mindset1_behaviour gebruikt
 */
function addExpanders(ul, prefix)
{
  
  // als een lijst al behandeld is heeft hij er een rel bij waar dat instaat zodat het niet nog een keer gebeurd
  if (ul && (!ul.rel || ul.rel.indexOf('addExpanders_handled')==-1))
  {
    //alert2('addExpanders');

    if (typeof(prefix)=='undefined') prefix = '';

    // een array maken van alleen alle li's onder deze ul
    var list = getChildren(ul, 'li');

    for (var i=0; i<list.length; i++) {
      uls = list[i].getElementsByTagName('ul');

      // dit item heeft een lijst met kinderen
      if (uls.length) {
        if (list[i].firstChild && list[i].firstChild.tagName && list[i].firstChild.tagName.toLowerCase() == 'a') {
          a = list[i].firstChild;

          list[i].id = prefix +'_list'+ i;
          uls[0].id = prefix +'_children_list'+ i;

          if (menu_mindset1_behaviour=='accordeon') {
            // dit item heeft geen link en is dus uitklapbaar
            if (getAttr(a,'href')=='#') {
              // accordeon gaat open en dicht als erop wordt geklikt
              a.href = 'javascript:void(expandList(\''+ prefix +'_list'+ i +'\'))';
            }
          }
          else if (menu_mindset1_behaviour=='fold') {
            // fold gaat open bij mouseover en dicht bij mouseout
            //alert2('onmouseover '+ prefix +'_list'+ i +' open');

            a.onmouseover = function() { expandList(this.parentNode['id'], 'open') };
            a.onmouseout = function() { expandList(this.parentNode['id'], 'open') };

            list[i].onmouseover = function() { expandList(this['id'], 'open') };
            list[i].onmouseout = function() { expandList(this['id'], 'close') };
          }

          for(var u=0; u<uls.length; u++){
            addExpanders(uls[u], uls[u]['id']+ '_sub');
          }
        }
      }
    }

    ul.rel = 'addExpanders_handled';
  }
}

addLoadEvent(function() { addExpanders(getObj('nav')); });

function addLoadEvent(func)
{
  if (typeof window.onload != 'function') {
		window.onload = func;
	}
	else {
  	var oldonload = window.onload;

		window.onload = function() {
			oldonload();
			func();
		}
	}
}

function initMenuMindset(navid, navtype, delay)
{
   addExpanders(getObj(navid));
   menu_mindset1_behaviour = navtype;
   menu_mindset1_timer = delay;
}


function alert2(string) {
  document.body.appendChild(document.createTextNode(string));
  document.body.appendChild(document.createElement('br'));
}

/**
 * Haalt alle elementen met deze tagname onder element op, zonder recursie
 *
 * @param object element     Het element waarvan de kinderen moeten worden opgehaald
 * @param string tagname     De tagname van de kinderen die opgehaald moeten worden
 *
 * @return array             Array met kind-objecten
 */
function getChildren(element, tagname)
{
  var children = new Array();

  for (var x=0; x < element.childNodes.length; x++) {
    if (element.childNodes[x].tagName && element.childNodes[x].tagName.toLowerCase() == tagname) {
      children[children.length] = element.childNodes[x];
    }
  }

  return children;
}

/**
 * Kijkt of een element een bepaalde class heeft
 *
 * @return boolean
 */
function hasClass(el,className)
{
  var re=new RegExp('(?:^|\\s+)'+className+'(?:\\s+|$)');
  return re.test(el['className']);
}

/**
 * Voegt een class toe aan een element, als die die class niet al heeft
 */
function addClass(el,className)
{
  if (hasClass(el,className)) {
    return;
  }
  el['className'] = [el['className'],className].join(' ');
}

/**
 * Verwijdert een class van een element, als die die class heeft
 */
function removeClass(el,className)
{
  if (!hasClass(el,className)) {
    return;
  }
  var re=new RegExp('(?:^|\\s+)'+className+'(?:\\s+|$)','g');
  var c=el['className'];
  el['className']=c.replace(re,' ');
}

/**
 * Wrapper om een element op te halen
 *
 * @return element
 */
function getObj(name)
{
  if (document.getElementById)
  {
  	return document.getElementById(name);
  }
  else if (document.all)
  {
	  return document.all[name];
  }
  else if (document.layers)
  {
   	return document.layers[name];
  }
}

/**
 * Wrapper om een attribuut op te halen, met speciale detectie voor href
 *
 * @return string   De waarde van het attribuut
 */
function getAttr(element, name)
{
	if (name == 'href') {
	  var loc = location.hostname;
	  var url = element.getAttribute(name);

	  if ((url.substring(0,7) == 'http://' && url.substring(0, loc.length+7) == 'http://'+loc) || url == '#') {
	    if (url.charAt(url.length-1) == '#') {
        return '#';
	    }
	  }
	}

  return element.getAttribute(name);
}