/* <documentation about="ABOUT library.js" type="GENERAL">
	<summary>This file is a library: it contains general functions used for the entire application. 
		No page initialisation calls are made in this file; there is one exception: Lib.addEvent(window, "unload", Lib.eventCache.flush): This removes all attached events.
		Make your function calls in the specific javascript files, in the [namespace].init()
	</summary>
	<namespace>nsUCBInternet</namespace>
</documentation> */
var Lib = {};

/* <documentation about="Lib.debug/Lib.allowAlert" type="global variables">
	<summary>These variables are used for debugging - do not change</summary>
	<namespace>Lib</namespace>
</documentation> */
Lib.debug = false; 
Lib.allowAlert = true;

/* <documentation about="Lib.safari/Lib.opera/Lib.ie" type="global variables">
	<summary>Browser checks</summary>
	<namespace>Lib</namespace>
</documentation> */
Lib.safari = (navigator.userAgent.toLowerCase().indexOf('safari') != - 1);
Lib.opera = window.opera ? true : false;
Lib.ie = (document.all && document.getElementById) ? true:false;
Lib.ie7 = navigator.appVersion.indexOf("MSIE 7")!=-1 ? true:false;

/* <documentation about="Lib.newWindowToolTipText" type="global variables">
	<summary>Title text shown on mouse over of a link which opens in a new window</summary>
	<namespace>Lib</namespace>
</documentation> */
Lib.newWindowToolTipText = "deze link opent in een nieuw venster";


/* ========== CORE ============================================================================ */
/* <documentation about="Lib.addEvent" type="CORE FUNCTION">
	<summary>Adds events to elements of the DOM</summary>
	<namespace>Lib</namespace>
	<param type="object" descr="A reference to the node on which the event has been set (HTML element).">obj</param>
	<param type="string" descr="The name of the event ">evt</param>
	<param type="object" descr="A reference to the function which handles the event.">fn</param>
</documentation> */
Lib.addEvent = function (obj,evt,fn) {
	if (obj.addEventListener)
		obj.addEventListener(evt,fn,false);
	else if (obj.attachEvent)
		obj.attachEvent('on'+evt,fn);
}

/* <documentation about="Lib.removeEvent" type="CORE FUNCTION">
	<summary>Removes events to elements of the DOM</summary>
	<namespace>Lib</namespace>
	<param type="object" descr="A reference to the node on which the event has been set (HTML element).">obj</param>
	<param type="string" descr="The name of the event ">evt</param>
	<param type="object" descr="A reference to the function which handles the event.">fn</param>
</documentation> */
Lib.removeEvent = function (obj,evt,fn) {
	if (obj.removeEventListener)
		obj.removeEventListener(evt,fn,false);
	else if (obj.detachEvent)
		obj.detachEvent('on'+evt,fn);
}

Lib.eventCache = function(){
	try {
		var listEvents = [];
		
		/*  Implement array.push for browsers which don't support it natively. (used in EventCache)
		Please remove this if it's already in other code */
		if(Array.prototype.push == null){
			Array.prototype.push = function(){
				for(var i = 0; i < arguments.length; i++){
					this[this.length] = arguments[i];
		       	};
		        return this.length;
			};
		};
	     
	    return {
			listEvents : listEvents,
	     
			/* <documentation about="Lib.eventCache.add" type="CORE FUNCTION">
				<summary>Keeping track of all the attached events</summary>
				<namespace>Lib</namespace>
				<param type="object" descr="A reference to the node on which the event has been set (HTML element).">node</param>
				<param type="string" descr="The name of the event">sEventName</param>
				<param type="object" descr="A reference to the function which handles the event. ">fHandler</param>
				<param type="bool" descr="A boolean which determines whether the event is triggered in capture mode or not. Does not apply to Internet Explorer.">bCapture</param>
			</documentation> */
			add : 	function(node, sEventName, fHandler, bCapture){
						listEvents.push(arguments); 
					},
	     
		 	/* <documentation about="Lib.eventCache.flush" type="CORE FUNCTION">
				<summary>Used to remove (detach) all cached events.</summary>
			</documentation> */
			flush : 	function(){
					var i, item;
					for(i = listEvents.length - 1; i >= 0; i = i - 1){
						item = listEvents[i];
	                 	Lib.removeEvent(item[0], item[1], item[2])
	                    
						item[0][item[1]] = null;
					};
			}
	      };
	} catch (ex){ Lib.errHandler(ex); }	
}();

/* <documentation about="Lib.debugAlert" type="CORE FUNCTION">
	<summary>Displays alert with error message, if alert is allowed (not cancelled in confirm) and Lib.debug = true</summary>
	<namespace>Lib</namespace>
	<param type="string" descr="Message to display in alert">message</param>
</documentation> */
Lib.debugAlert = function (message) {
		 if(Lib.allowAlert && Lib.debug) { Lib.allowAlert = confirm(message); }
	}


/* <documentation about="Lib.errHandler" type="CORE FUNCTION">
	<summary>Handles errors in javascript application</summary>
	<namespace>Lib</namespace>
	<param type="object" descr="Error object">err</param>
</documentation> */
Lib.errHandler = function (err) {
		var errorText = "";
		for (var i in err) { errorText += i + "=" + err[i] + "\n"; }
		Lib.debugAlert("An error has occured: \n\n" + errorText + "\nSee Firefox browser for correct linenumbers."); 			
		return true;	
	}	
/* ========== END CORE ====================================================================== */
	
/* ========== GENERAL FUNCTIONS ============================================================= */
/* <documentation about="Lib.getWindowHeight" type="general function">
	<summary>Gets innerheight of browser window</summary>
	<namespace>Lib</namespace>
	<returns>Inner window height in pixels (integer)</returns>
</documentation> */
Lib.getWindowHeight = function () {
	var myHeight = 0;
	if( typeof( window.innerHeight ) == 'number' ) {
		//Non-IE
		myHeight = window.innerHeight;
	} else if( document.documentElement &&  document.documentElement.clientHeight  ) {
		//IE 6+ in 'standards compliant mode'
		myHeight = document.documentElement.clientHeight;
	} else if( document.body && document.body.clientHeight) {
		//IE 4 compatible
		myHeight = document.body.clientHeight;
	}
	return myHeight;
}
/* <documentation about="Lib.getWindowWidth" type="general function">
	<summary>Gets innerwidth of browser window</summary>
	<namespace>Lib</namespace>
	<returns>Inner window width in pixels (integer)</returns>
</documentation> */
Lib.getWindowWidth = function () {
	var myHeight = 0;
	if( typeof( window.innerWidth ) == 'number' ) {
		//Non-IE
		myHeight = window.innerWidth;
	} else if( document.documentElement &&  document.documentElement.clientWidth  ) {
		//IE 6+ in 'standards compliant mode'
		myHeight = document.documentElement.clientWidth;
	} else if( document.body && document.body.clientWidth) {
		//IE 4 compatible
		myHeight = document.body.clientWidth;
	}
	return myHeight;
}
/* <documentation about="Lib.getScrollY" type="general function">
	<summary>Get scrolling distance from the top of the window in pixels</summary>
	<namespace>Lib</namespace>
	<returns>Scrolling distance in pixels (integer)</returns>
</documentation> */
Lib.getScrollY = function () {
  var scrOfY = 0;
  if( typeof( window.pageYOffset ) == 'number' ) {
    //Netscape compliant
    scrOfY = window.pageYOffset;
  } else if( document.body && ( document.body.scrollLeft || document.body.scrollTop ) ) {
    //DOM compliant
    scrOfY = document.body.scrollTop;
  } else if( document.documentElement && ( document.documentElement.scrollLeft || document.documentElement.scrollTop ) ) {
    //IE6 standards compliant mode
    scrOfY = document.documentElement.scrollTop;    
  }
  return scrOfY;
}

/* <documentation about="Lib.findElementPosition" type="general function">
	<summary>Find position of a HTML element relative to window</summary>
	<namespace>Lib</namespace>
	<param type="object" descr="HTML element">elem</param>
	<returns>array [left (integer), top (integer)]</returns>
</documentation> */
Lib.findElementPosition = function (elem){
	var curleft = curtop = 0;
	if (elem.offsetParent) {
	
		curleft = elem.offsetLeft
		curtop = elem.offsetTop
		while (elem = elem.offsetParent) {
			curleft += elem.offsetLeft
			curtop += elem.offsetTop
		}
	}
	return [curleft,curtop];
}

/* <documentation about="Lib.elementIsHidden" type="general function">
	<summary>Checks if an element is hidden (has parent with className 'hide'</summary>
	<namespace>Lib</namespace>
	<param type="object" descr="HTML element">obj</param>
	<returns>true or false</returns>
</documentation> */
Lib.elementIsHidden = function (elem) {
	var isHidden = false;
	
	while ( elem && !isHidden) {
		elem = elem.parentNode; 
		if(elem && elem.className && elem.className.indexOf("hide") != -1) { isHidden=true; }
	}
    return isHidden;
}

/* <documentation about="Lib.elementsExists" type="general function">
	<summary>Checks if all the elements with the id specified in the arguments of this function exist; returns true if they do exist; false if one or more do not exist</summary>
	<namespace>Lib</namespace>
	<param type="array of strings" descr="Id's of HTML elements">[array]</param>
	<returns>boolean</returns>
</documentation> */
Lib.elementsExists = function () {
	var result = true;
	for(var i=0; i< arguments.length; i++) {
		if(!document.getElementById(arguments[i])) result=false;
	}
	return result;
}

/* <documentation about="Lib.addStyleSheet" type="general function">
	<summary>Adds stylesheet to the document</summary>
	<namespace>Lib</namespace>
	<param type="string" descr="Relative path to the stylesheet for example '../css/stylesheet.css'">relPath</param>
</documentation> */
Lib.addStyleSheet = function (relPath) {
	if(document.getElementsByTagName("head"))
	{
		var head = document.getElementsByTagName("head")[0]; 
		var newStyle = document.createElement("link");
   		newStyle.setAttribute("type", "text/css");
		newStyle.setAttribute("rel", "stylesheet"); 
		newStyle.setAttribute("href", relPath); 
		head.appendChild(newStyle);
	}
} 

/* <documentation about="Lib.removeStyleSheet" type="general function">
	<summary>Removes (or disables) stylesheet in document</summary>
	<namespace>Lib</namespace>
	<param type="string" descr="File name of stylesheet for example 'stylesheet.css'">stylesheetFileName</param>
</documentation> */
Lib.removeStyleSheet = function (stylesheetFileName) {
	if(document.getElementsByTagName("head"))
	{
		var head = document.getElementsByTagName("head")[0]; 
		var linkElements = head.getElementsByTagName("link");
		
		for(var i=0; i<linkElements.length; i++) {
			
			var href = linkElements[i].getAttribute("href");
			if( href.indexOf(stylesheetFileName) != -1) {  
				linkElements[i].disabled=true; 
				head.removeChild(linkElements[i]); 
			}			
		}		
	}	
} 

/* <documentation about="Lib.switchStyleSheet" type="general function">
	<summary>Enable/disable stylesheet</summary>
	<namespace>Lib</namespace>
	<param type="string" descr="Value of the title attribute of link-tag that has to be adjusted">linkTitle</param>
</documentation> */
Lib.switchStyleSheet = function (linkTitle) {
	if(document.getElementsByTagName("head"))
	{
		var head = document.getElementsByTagName("head")[0]; 
		var linkElements = head.getElementsByTagName("link");
		for(var i=0; i< linkElements.length; i++) {
			if(linkElements[i].getAttribute("title") != linkTitle) { continue; }
			linkElements[i].disabled ? linkElements[i].disabled = false : linkElements[i].disabled = true;
		}
	}
} 

Lib.setCookie = function (name, value) {  
	var argv = Lib.setCookie.arguments;  
	var argc = Lib.setCookie.arguments.length;  
	var expires = (argc > 2) ? argv[2] : null;
	var path = (argc > 3) ? argv[3] : null;  
	var domain = (argc > 4) ? argv[4] : null;  
	var secure = (argc > 5) ? argv[5] : false;  
	document.cookie = name + "=" + escape (value) + 
	((expires == null) ? "" : ("; expires=" + expires.toGMTString())) + 
	((path == null) ? "" : ("; path=" + path)) +  
	((domain == null) ? "" : ("; domain=" + domain)) +    
	((secure == true) ? "; secure" : "");
}

Lib.getCookie = function (name) {
	var start = document.cookie.indexOf(name+"="); 
	var len = start+name.length+1; 
	if ((!start) && (name != document.cookie.substring(0,name.length))) { return  null; }
	if (start == -1){ return null; }
	
	var end = document.cookie.indexOf(";",len); 
	
	if (end == -1) { end = document.cookie.length; } 
	return unescape(document.cookie.substring(len,end)); 
}

/* <documentation about="Lib.getBodyId" type="general function">
	<summary>Gets  id of body element</summary>
	<namespace>Lib</namespace>
	<returns>id (string)</returns>
</documentation> */
Lib.getBodyId = function ()  {
 	try {
		var body = document.getElementsByTagName("body")[0];
		return body.id;
	} catch (ex){ Lib.errHandler(ex); }	
 }

/* <documentation about="Lib.getNextElement" type="general function">
	<summary>Gets next element in DOM tree; while ignoring text nodes</summary>
	<namespace>Lib</namespace>
	<param type="object" descr="HTML element">elem</param>
	<returns>HTML element</returns>
</documentation> */
Lib.getNextElement = function ( elem ) {
    do { elem = elem.nextSibling; } 
	while ( elem && elem.nodeType != 1 );
    return elem;
}


/* <documentation about="Lib.getPreviousElement" type="general function">
	<summary>Gets previous element in DOM tree; while ignoring text nodes</summary>
	<namespace>Lib</namespace>
	<param type="object" descr="HTML element">elem</param>
	<returns>HTML element</returns>
</documentation> */
Lib.getPreviousElement = function ( elem ) {
	do { elem = elem.previousSibling; }
	while ( elem && elem.nodeType != 1 );
	return elem;
}

/* <documentation about="Lib.getElementsByClassName" type="general function">
	<summary>Used to find HTML elements with certain classname</summary>
	<namespace>Lib</namespace>
	<param type="string" descr="Classname you are looking for">searchClass</param>
	<param type="string" descr="An optional tag name to narrow the search to specific tags e.g. "a" for links (optional, defaults to  "*").">tagName</param>
	<param type="string" descr="An optional object container to search inside. This narrows the scope of the search (optional, defaults to document).">elem</param>
	<returns>Array of HTML elements</returns>
</documentation> */
Lib.getElementsByClassName = function (searchClass, tagName, containerElement) {
	tagName = tagName || "*";
	containerElement = containerElement || document;
	
	var allElements = containerElement.getElementsByTagName(tagName);
	if (!allElements.length &&  tagName == "*" &&  containerElement.all) allElements = containerElement.all;
	
	var elementsFound = new Array();
	var delim = searchClass.indexOf("|") != -1  ? '|' : " ";
	
	var arrClass = searchClass.split(delim);
	for (var i = 0, j = allElements.length; i < j; i++) {
		var arrObjClass = allElements[i].className.split(" ");
		if (delim == " " && arrClass.length > arrObjClass.length) { continue; }
		var c = 0;
		comparisonLoop:
			for (var k = 0, l = arrObjClass.length; k < l; k++) {
				for (var m = 0, n = arrClass.length; m < n; m++) {
					if (arrClass[m] == arrObjClass[k]) c++;
					if (( delim == "|" && c == 1) || (delim == " " && c == arrClass.length)) {
						elementsFound.push(allElements[i]);
					break comparisonLoop;
				}
			}
		}
	}
	return elementsFound;
}
/* <documentation about="Lib.getElementByTitle" type="general function">
	<summary>Get Elements by title attribute</summary>
	<namespace>Lib</namespace>
	<param type="string" descr="Value of title attribute you are looking for">searchTitle</param>
	<param type="string" descr="An optional tag name to narrow the search to specific tags e.g. "a" for links (optional, defaults to  "*").">tagName</param>
	<param type="string" descr="An optional object container to search inside. This narrows the scope of the search (optional, defaults to document).">elem</param>
	<returns>Array of HTML elements</returns>
</documentation> */
Lib.getElementsByTitle = function (searchTitle, tagName, containerElement) {
	tagName = tagName || "*";
	containerElement = containerElement || document;
	
	var allElements = containerElement.getElementsByTagName(tagName);
	if (!allElements.length &&  tagName == "*" &&  containerElement.all) allElements = containerElement.all;
	
	var elementsFound = new Array();

	for (var i = 0, j = allElements.length; i < j; i++) {
		if (allElements[i].title == searchTitle) {
			elementsFound.push(allElements[i]);
		}
	}
	return elementsFound;
}

/* <documentation about="Lib.removeElements" type="general function">
	<summary>Used to remove HTML elements</summary>
	<namespace>Lib</namespace>
	<param type="string" descr="An optional tag name to narrow the search to specific tags e.g. "a" for links (optional, defaults to "*").">tagName</param>
	<param type="string" descr="Classname you are looking for">searchClass</param>
	<param type="string" descr="An optional object container to search inside. This narrows the scope of the search (optional, defaults to document).">elem</param>
</documentation> */
Lib.removeElements = function (tagName, searchClass, containerElement) {
	var elementToRemove = Lib.getElementsByClassName(searchClass, tagName, containerElement);
	
	for(var i=0; i< elementToRemove.length; i++) {
		elementToRemove[i].parentNode.removeChild(elementToRemove[i]);
	}
}

/* <documentation about="Lib.showElements" type="general function">
	<summary>Used to show HTML elements</summary>
	<namespace>Lib</namespace>
	<param type="array of objects" descr="references to html objects">[array]</param>
</documentation> */
Lib.showElements = function () {
	for(var i = 0; i < arguments.length; i++){
		arguments[i].style.display = 'block';
	};
}

/* <documentation about="Lib.hideElements" type="general function">
	<summary>Used to hide HTML elements</summary>
	<namespace>Lib</namespace>
	<param type="array of objects" descr="references to html objects">[array]</param>
</documentation> */
Lib.hideElements = function () {
	for(var i = 0; i < arguments.length; i++){
		arguments[i].style.display = 'none';
	};
}

/* <documentation about="Lib.trim" type="general function">
	<summary>Used to trim a variable (removing spaces left and right)</summary>
	<namespace>Lib</namespace>
	<param type="string" descr="Variables that you want to trim">stringToTrim</param>
	<returns>Trimmed variable (string)</returns>
</documentation> */
Lib.trim = function(stringToTrim) {
	return stringToTrim.replace(/^\s+|\s+$/g, '') ;
}

/* <documentation about="Lib.inputAutoClear" type="general function">
	<summary>Resets default value in text field when text field is left empty</summary>
	<namespace>Lib</namespace>
</documentation> */
Lib.inputAutoClear = function () {
	for(var i=0; i< arguments.length; i++) {
		var inputField = arguments[i];
		// Add a onfocus to inputField
		// This will store the initial value for restoring it when the box stays empty when losing focus
		inputField.onfocus = function(){
			if(this.getAttribute("default") && this.getAttribute("default")== this.value) { 
				this.value = "";
			}
		};
		Lib.eventCache.add(inputField,"onfocus",function(){if(this.getAttribute("default")&&this.getAttribute("default")==this.value){this.value="";}},false);
		// Add a onblur to inputField
		// This will restore the initial value if no value is inserted
		inputField.onblur = function() { 
			if(this.value.length==0 && this.getAttribute("default")) { this.value = this.getAttribute("default")} 
		};
		Lib.eventCache.add(inputField,"onblur",function(){if(this.value.length==0&&this.getAttribute("default")){this.value==this.getAttribute("default");}},false);
	}
}


/* <documentation about="Lib.addDefaultTextAttribute" type="specific function">
<summary>Adds attribute "default" to text form elements</summary>
<namespace>Lib</namespace>
<param type="array of strings" descr="Id's of HTML elements">[array]</param>
</documentation> */
Lib.addDefaultTextAttribute = function () {
	for(var i=0; i< arguments.length; i++) {
		var field = arguments[i];
		field.setAttribute("default", field.value);
	}
}


/* <documentation about="Lib.pageIsStyled" type="global variables">
	<summary>Used to keep status if page is styled</summary>
	<namespace>Lib</namespace>
</documentation> */
Lib.pageIsStyled = false;


/* <documentation about="Lib.setPageIsStyled" type="general function">
	<summary>Sets variable Lib.pageIsStyled to true when HTML element 'utilities' is more than 100 px from the left. If the page is not styled, the stylesheet javascript.css is removed </summary>
	<namespace>Lib</namespace>
</documentation> */
Lib.setPageIsStyled = function () {
	if(Lib.elementsExists("utilities")) { if(parseInt(document.getElementById("utilities").offsetLeft) >100) { Lib.pageIsStyled = true; }	 }	
	if(!Lib.pageIsStyled) { Lib.removeStyleSheet ("javascript.css"); }
}


/* <documentation about="Lib.addResizingLinks" type="specific function">
	<summary>Adds increase/decrease font size links</summary>
	<namespace>Lib</namespace>
</documentation> */
Lib.addResizingLinks = function() {
	if(!Lib.pageIsStyled) { return; } //stop if page is not styled
	
	try {
		// find the place to insert the html
		var utils = document.getElementById("utilities");
		var utilDivs = utils.getElementsByTagName("div");
		for (var u=0; u < utilDivs.length; u++) {
			if (utilDivs[u].className == "recommend") {
				var placeMarker = utilDivs[u];
			}
		}
		
		//get first div for insert
		var firstDiv = Lib.getNextElement(placeMarker); //div languages
		
		//make new div with id fontSize;
		var divFontSize = document.createElement("div");
		divFontSize.id = "page-utilities";
		
		//add print link
		var printLink = document.createElement("a");
		printLink.id="print-page";
		printLink.innerHTML = "Print page";	
		divFontSize.appendChild(printLink);

		//add text
		var strong = document.createElement("strong");
		strong.innerHTML = "Text resize";	
		divFontSize.appendChild(strong);
		
		var ul = document.createElement("ul");
		
		var firstLi = document.createElement("li");
		firstLi.id = "larger-font";
		var largerLink = document.createElement("a");
		largerLink.href="#";
		largerLink.innerHTML = "Increase font size";
		firstLi.appendChild(largerLink);
		ul.appendChild(firstLi);
			
		var secondeLi = document.createElement("li");
		secondeLi.id = "smaller-font";
		var smallerLink = document.createElement("a");
		smallerLink.href="#";
		smallerLink.innerHTML = "Reduce font size";
		secondeLi.appendChild(smallerLink);
		ul.appendChild(secondeLi);
		
		printLink.onclick = function() { window.print(); return false; };
		Lib.eventCache.add(printLink, "onclick", function() { window.print(); return false; }, false );
		
		largerLink.onclick = function() { changeFontSize("larger"); return false; };
		Lib.eventCache.add(largerLink, "onclick", function() { changeFontSize("larger"); return false; }, false );
		
		smallerLink.onclick = function() { changeFontSize("smaller"); return false; };
		Lib.eventCache.add(smallerLink, "onclick", function() { changeFontSize("smaller"); return false; }, false );
		
		if(Lib.getCookie("fontsize")) {
			if(Lib.getCookie("fontsize") == "scalingLargest") { largerLink.className = "disabled"; 	}
			if(Lib.getCookie("fontsize") == "scalingSmallest") { smallerLink.className = "disabled"; 	}
		}
		//else { smallerLink.className = "disabled"; }
		
		divFontSize.appendChild(ul);
			
		//add div id = fontSize
		placeMarker.parentNode.insertBefore(divFontSize,  firstDiv);
		
		/* <documentation about="Lib.changeFontSize" type="private function in Lib.addResizingLinks">
			<summary>Set font-size and updates font size links (enabled/disabled) according to status</summary>
			<namespace>Lib</namespace>
		</documentation> */
		var changeFontSize = function (status) {
			//get cookie value
			var cookieValue = "";
			if(Lib.getCookie("fontsize")) {
				cookieValue = Lib.getCookie("fontsize");
			}
			
			//reset links
			var largerLink = document.getElementById("larger-font").getElementsByTagName("a")[0];
			largerLink.className = "";
			
			var smallerLink = document.getElementById("smaller-font").getElementsByTagName("a")[0];
			smallerLink.className = "";
			
			if(status=="larger") {	
				if(cookieValue.length == 0) { Lib.setFontSize("scalingLarge", true); }
				else if (cookieValue == "scalingSmallest") { Lib.setFontSize("scalingSmall", true); }
				else if (cookieValue == "scalingSmall") { Lib.setFontSize("scalingNormal", true); }
				else if (cookieValue == "scalingNormal") { Lib.setFontSize("scalingLarge", true); }
				else if (cookieValue == "scalingLarge") { largerLink.className = "disabled"; Lib.setFontSize("scalingLargest", true); }
				else if (cookieValue == "scalingLargest") { largerLink.className = "disabled"; }
			}
			else if(status=="smaller") {
				if(cookieValue.length == 0) { Lib.setFontSize("scalingSmall", true); }
				if (cookieValue == "scalingLargest") {  Lib.setFontSize("scalingLarge", true); }
				else if (cookieValue == "scalingLarge") { Lib.setFontSize("scalingNormal", true); }
				else if (cookieValue == "scalingNormal") { Lib.setFontSize("scalingSmall", true); }
				else if (cookieValue == "scalingSmall") {  smallerLink.className = "disabled"; Lib.setFontSize("scalingSmallest", true); }
				else if (cookieValue == "scalingSmallest") { smallerLink.className = "disabled"; }
			}
		};
		
	} catch (ex){ Lib.errHandler(ex); }	
}	

/* <documentation about="Lib.setFontSize" type="specific function">
	<summary>Sets font size by adding and removing stylesheets</summary>
	<namespace>Lib</namespace>
</documentation> */
Lib.setFontSize = function (status, removeStyleSheets) {
	//alert(status);
	if(removeStyleSheets) {
		//reset
		Lib.removeStyleSheet ("smallest-size.css");
		Lib.removeStyleSheet ("small-size.css");
		Lib.removeStyleSheet ("medium-size.css");
		Lib.removeStyleSheet ("large-size.css");
		Lib.removeStyleSheet ("largest-size.css");
	}
	
	if(status=="scalingSmallest") { Lib.addStyleSheet("../static/css/smallest-size.css");  }
	else if(status=="scalingSmall") { Lib.addStyleSheet("../static/css/small-size.css"); }
	else if(status=="scalingNormal") { Lib.addStyleSheet("../static/css/medium-size.css"); }
	else if(status=="scalingLarge") { Lib.addStyleSheet("../static/css/large-size.css"); }
	else if(status=="scalingLargest") { Lib.addStyleSheet("../static/css/largest-size.css"); }
	
	Lib.setCookie("fontsize", status)
} 

/* <documentation about="Lib.initNavigation" type="specific function">
<summary>Adds dropdown functionality to unordered list with classname "menutree"</summary>
<namespace>Lib</namespace>
</documentation> */
Lib.initNavigation = function (){
	var lists = document.getElementsByTagName('ul');
	for (var i=0;i<lists.length;i++) {
		if (lists[i].className != 'menutree') continue;
		lists[i].onmouseover = Lib.navMouseOver;
		lists[i].onmouseout = Lib.navMouseOut;
		var listItems = lists[i].getElementsByTagName('li');
		for (var j=0;j<listItems.length;j++) {
			var test = listItems[j].getElementsByTagName('ul')[0];
			if (test) {
				listItems[j].firstChild.onfocus = Lib.navMouseOver;
				listItems[j].relatedItem = test;
			}
		}
	}
}

var currentlyOpenedMenus = new Array();
var currentlyFocusedItem;
var closeMenuTimeOut;
var openMenuTimeOut;
var evtTargetGlob;

Lib.navMouseOver = function (e) {
	if (closeMenuTimeOut) {
		clearTimeout(closeMenuTimeOut);
	}
	if (openMenuTimeOut) {
		clearTimeout(openMenuTimeOut);
	}
	var evt = e || window.event;
	var evtTarget = evt.target || evt.srcElement;
	evtTargetGlob = evtTarget;
	openMenuTimeOut = setTimeout('Lib.foldMenuOut(evtTargetGlob)', 300);
}

Lib.navMouseOut = function (e) {
	var evt = e || window.event;
	var relatedNode = evt.relatedTarget || evt.toElement;
	Lib.foldMenuIn(relatedNode);
}

Lib.foldMenuIn = function (targetNode) {
	targetNodecur = targetNode;
	if (closeMenuTimeOut) {
		clearTimeout(closeMenuTimeOut);
	}
	closeMenuTimeOut = setTimeout('Lib.closeMenu(targetNodecur)', 600);
}

Lib.foldMenuOut = function (evtTarget) {
	if (evtTarget.nodeName == 'UL') return;
	while (evtTarget.nodeName != 'LI')
		evtTarget = evtTarget.parentNode;
	Lib.closeMenu(evtTarget);
	if (evtTarget.relatedItem && !evtTarget.relatedItem.opened) {
		//evtTarget.className = 'highlight';  removed because evtTarget is a link
		evtTarget.relatedItem.className = 'fold-out';
		evtTarget.relatedItem.opened = true;
		if(Lib.ie && !(Lib.ie7) && !(Lib.opera)) {
			Lib.createIframeLayer(evtTarget.relatedItem);
		}
		currentlyOpenedMenus.push(evtTarget.relatedItem);
	}
}

Lib.containsElement = function (obj1,obj2) {
	while (obj2.nodeName != 'HTML') {
		if (obj2 == obj1) return true;
		obj2 = obj2.parentNode;
	}
	return false;
}

/** PUSH AND SHIFT FOR IE5 **/
function Array_push() {
	var A_p = 0
	for (A_p = 0; A_p < arguments.length; A_p++) {
		this[this.length] = arguments[A_p]
	}
	return this.length
}

if (typeof Array.prototype.push == "undefined") {
	Array.prototype.push = Array_push
}

function Array_shift() {
	var A_s = 0
	var response = this[0]
	for (A_s = 0; A_s < this.length-1; A_s++) {
		this[A_s] = this[A_s + 1]
	}
	this.length--
	return response
}

if (typeof Array.prototype.shift == "undefined") {
	Array.prototype.shift = Array_shift
}

//====================== These functions creates/remove an iframe 'mask' underneath dropdown lists in main nav
//====================== for internet explorer only
Lib.createIframeLayer = function (menu) {
	var layer = document.createElement('iframe');
    layer.tabIndex = '-1';
    layer.src = 'javascript:false;';
	menu.parentNode.appendChild(layer);
	// make the iframe the same size and position as the dropdown
    layer.style.left = menu.offsetLeft + 'px';
    layer.style.top = menu.offsetTop + 'px';
    layer.style.width = menu.offsetWidth + 'px';
    layer.style.height = menu.offsetHeight + 'px';
}

Lib.removeIframeLayer = function (menu) {
    var layers = menu.parentNode.getElementsByTagName('iframe');
    while (layers.length > 0) {
      layers[0].parentNode.removeChild(layers[0]);
    }
}
/** delay on mouseout **/
Lib.closeMenu = function (targetNode) {
	if (!targetNode) return;
	var newCurrentlyOpenedMenus = new Array();
	for (var i=0;i<currentlyOpenedMenus.length;i++) {
		if (!Lib.containsElement(currentlyOpenedMenus[i],targetNode)) {

			currentlyOpenedMenus[i].className = '';
			//currentlyOpenedMenus[i].parentNode.className = '';
			currentlyOpenedMenus[i].opened = false;

			if(Lib.ie && !(Lib.ie7) && !(Lib.opera)) {
				Lib.removeIframeLayer(currentlyOpenedMenus[i].parentNode);
			}
		}
		else
			newCurrentlyOpenedMenus.push(currentlyOpenedMenus[i]);
	}
	currentlyOpenedMenus = newCurrentlyOpenedMenus;
}


/* ========== END GENERAL FUNCTIONS ========================================================= */

/* <documentation about="Add eventhandler Lib.eventCache.flush on window unload" type="FUNCTION CALL">
	<summary>Calling Lib.addEvent: Add Lib.eventCache.flush as eventhandler on window onunload: Detach all attached events (solves memory leak in ie)</summary>
</documentation> */
Lib.addEvent(window, "unload", Lib.eventCache.flush);