var Core = {};

// W3C DOM 2 Events model
if (document.addEventListener)
{
  Core.addEventListener = function(target, type, listener)
  {
    target.addEventListener(type, listener, false);
  };

  Core.removeEventListener = function(target, type, listener)
  {
    target.removeEventListener(type, listener, false);
  };

  Core.preventDefault = function(event)
  {
    event.preventDefault();
  };

  Core.stopPropagation = function(event)
  {
    event.stopPropagation();
  };
}
// Internet Explorer Events model
else if (document.attachEvent)
{
  Core.addEventListener = function(target, type, listener)
  {
    // prevent adding the same listener twice, since DOM 2 Events ignores
    // duplicates like this
    if (Core._findListener(target, type, listener) != -1) return;

    // listener2 calls listener as a method of target in one of two ways,
    // depending on what this version of IE supports, and passes it the global
    // event object as an argument
    var listener2 = function()
    {
      var event = window.event;

      if (Function.prototype.call)
      {
        listener.call(target, event);
      }
      else
      {
        target._currentListener = listener;
        target._currentListener(event)
        target._currentListener = null;
      }
    };

    // add listener2 using IE's attachEvent method
    target.attachEvent("on" + type, listener2);

    // create an object describing this listener so we can clean it up later
    var listenerRecord =
    {
      target: target,
      type: type,
      listener: listener,
      listener2: listener2
    };

    // get a reference to the window object containing target
    var targetDocument = target.document || target;
    var targetWindow = targetDocument.parentWindow;

    // create a unique ID for this listener
    var listenerId = "l" + Core._listenerCounter++;

    // store a record of this listener in the window object
    if (!targetWindow._allListeners) targetWindow._allListeners = {};
    targetWindow._allListeners[listenerId] = listenerRecord;

    // store this listener's ID in target
    if (!target._listeners) target._listeners = [];
    target._listeners[target._listeners.length] = listenerId;

    // set up Core._removeAllListeners to clean up all listeners on unload
    if (!targetWindow._unloadListenerAdded)
    {
      targetWindow._unloadListenerAdded = true;
      targetWindow.attachEvent("onunload", Core._removeAllListeners);
    }
  };

  Core.removeEventListener = function(target, type, listener)
  {
    // find out if the listener was actually added to target
    var listenerIndex = Core._findListener(target, type, listener);
    if (listenerIndex == -1) return;

    // get a reference to the window object containing target
    var targetDocument = target.document || target;
    var targetWindow = targetDocument.parentWindow;

    // obtain the record of the listener from the window object
    var listenerId = target._listeners[listenerIndex];
    var listenerRecord = targetWindow._allListeners[listenerId];

    // remove the listener, and remove its ID from target
    target.detachEvent("on" + type, listenerRecord.listener2);
    target._listeners.splice(listenerIndex, 1);

    // remove the record of the listener from the window object
    delete targetWindow._allListeners[listenerId];
  };

  Core.preventDefault = function(event)
  {
    event.returnValue = false;
  };

  Core.stopPropagation = function(event)
  {
    event.cancelBubble = true;
  };

  Core._findListener = function(target, type, listener)
  {
    // get the array of listener IDs added to target
    var listeners = target._listeners;
    if (!listeners) return -1;

    // get a reference to the window object containing target
    var targetDocument = target.document || target;
    var targetWindow = targetDocument.parentWindow;

    // searching backward (to speed up onunload processing), find the listener
    for (var i = listeners.length - 1; i >= 0; i--)
    {
      // get the listener's ID from target
      var listenerId = listeners[i];

      // get the record of the listener from the window object
      var listenerRecord = targetWindow._allListeners[listenerId];

      // compare type and listener with the retrieved record
      if (listenerRecord.type == type && listenerRecord.listener == listener)
      {
        return i;
      }
    }
    return -1;
  };

  Core._removeAllListeners = function()
  {
    var targetWindow = this;

    for (id in targetWindow._allListeners)
    {
      var listenerRecord = targetWindow._allListeners[id];
      listenerRecord.target.detachEvent(
          "on" + listenerRecord.type, listenerRecord.listener2);
      delete targetWindow._allListeners[id];
    }
  };

  Core._listenerCounter = 0;
}

Core.addClass = function(target, theClass)
{
  if (!Core.hasClass(target, theClass))
  {
    if (target.className == "")
    {
      target.className = theClass;
    }
    else
    {
      target.className += " " + theClass;
    }
  }
};

Core.getElementsByClass = function(theClass)
{
  var elementArray = [];

  if (typeof document.all != "undefined")
  {
    elementArray = document.all;
  }
  else
  {
    elementArray = document.getElementsByTagName("*");
  }

  var matchedArray = [];
  var pattern = new RegExp("(^| )" + theClass + "( |$)");

  for (var i = 0; i < elementArray.length; i++)
  {
    if (pattern.test(elementArray[i].className))
    {
      matchedArray[matchedArray.length] = elementArray[i];
    }
  }

  return matchedArray;
};

Core.hasClass = function(target, theClass)
{
  var pattern = new RegExp("(^| )" + theClass + "( |$)");

  if (pattern.test(target.className))
  {
    return true;
  }

  return false;
};

Core.removeClass = function(target, theClass)
{
  var pattern = new RegExp("(^| )" + theClass + "( |$)");

  target.className = target.className.replace(pattern, "$1");
  target.className = target.className.replace(/ $/, "");
};

Core.getComputedStyle = function(element, styleProperty)
{
  var computedStyle = null;

  if (typeof element.currentStyle != "undefined")
  {
    computedStyle = element.currentStyle;
  }
  else
  {
    computedStyle = document.defaultView.getComputedStyle(element, null);
  }

  return computedStyle[styleProperty];
};

Core.start = function(runnable)
{
  Core.addEventListener(window, "load", runnable.init);
};



Core.start = function(runnable)
{
	Core.addEventListener(window, "load", runnable.init);
}

var Accordion =
{
	init: function()
	{
		var accordions = Core.getElementsByClass("accordion");
		
		for (var i = 0; i < accordions.length; i++)
		{
			var folds = accordions[i].childNodes;
			for (var j = 0; j < folds.length; j++)
			{
			
				if (folds[j].nodeType == 1)
				{
					Accordion.collapse(folds[j]);
					var foldLinks = folds[j].getElementsByTagName("a");
					var foldTitleLink = foldLinks[0];
					Core.addEventListener(foldTitleLink, "click", Accordion.clickListener);
					
					for (var k = 1; k < foldLinks.length; k++)
					{
						Core.addEventListener(foldLinks[k], "focus", Accordion.focusListener);
					}
				}
			}
			
			if (location.hash.length > 1)
			{
				var activeFold = document.getElementById(location.hash.substring(1));
				if (activeFold && activeFold.parentNode == accordions[i])
				{
					Accordion.expand(activeFold);
				}
			}
		}
	},
	
	collapse: function(fold)
	{
		Core.removeClass(fold, "expanded");
		Core.addClass(fold, "collapsed");
	},
	
	collapseAll: function(accordion)
	{
		var folds = accordion.childNodes;
		for (var i = 0; i < folds.length; i++)
		{
			if (folds[i].nodeType == 1)
			{
				Accordion.collapse(folds[i]);
			}
		}
	},
	
	expand: function(fold)
	{
		//Accordion.collapseAll(fold.parentNode);
		Core.removeClass(fold, "collapsed");
		Core.addClass(fold, "expanded");
	},
	
	clickListener: function(event)
	{
		var fold = this.parentNode.parentNode;
		if (Core.hasClass(fold, "collapsed"))
		{
			Accordion.expand(fold);
		}
		else
		{
			Accordion.collapse(fold);
		}
		Core.preventDefault(event);
	},
	
	focusListener: function(event)
	{
		var element = this;
		while (element.parentNode)
		{
			if (Core.hasClass(element.parentNode, "accordion"))
			{
				Accordion.expand(element);
				return;
			}
			element = element.parentNode;
		}
	}
};

Core.start(Accordion);		


MyImages=new Array();
MyImages[0]='./images/leaf.jpg';
MyImages[1]='./images/swirl.jpg';
MyImages[2]='./images/graph.jpg';

function newImage()
{
  document.getElementById("mainImage").setAttribute("src", MyImages[Math.floor(Math.random()*3)])
}

var GLT = {
	
	titleClassName : 'glt-elm',	
	topImagePath : '',
	bottomImagePath : '',
	suppressAltTooltipsInIE : true,
	timeBeforeShow : 100,
	titleOffsetX : 15,
	titleOffsetY : 15,
	fadeInTitle : true,
	fadeOutTitle : true,
	fadeStartLevel : 0.1,
	originalFadeLevel : 0.9,
	fadeIncrement : 0.1,
	timePerFadeStep : 50,
	
	// GLT parameters
	titleElm : null,
	titleTextElm : null,
	titleTopImage : null,
	titleBottomImage : null,
	elementsWithTitles : null,
	currentElm : null,
	currentTitle : "",
	currentFadeLevel : 0,
	fadeTimer : null,
	
	init : function (){
		if(document.getElementById){
		
			this.elementsWithTitles = getElementsByAttribute(document, 'b', 'title');

			if(this.elementsWithTitles.length > 0){
				this.titleElm = document.createElement('div');
				this.titleElm.className = this.titleClassName;
				if(this.topImagePath){
					this.titleTopImage = document.createElement('img');
					this.titleTopImage.setAttribute('src', this.topImagePath);
					this.titleElm.appendChild(this.titleTopImage);
				}				
				this.titleTextElm = document.createElement('p');
				this.titleElm.appendChild(this.titleTextElm);
				if(this.bottomImagePath){
					this.titleBottomImage = document.createElement('img');
					this.titleBottomImage.setAttribute('src', this.bottomImagePath);
					this.titleElm.appendChild(this.titleBottomImage);
				}
				document.body.appendChild(this.titleElm);
				this.useMSFilter = typeof this.titleElm.style.filter != 'undefined';
				this.applyEvents();
			
			}			
		}
	},
	
	applyEvents : function (){
		var oElm;
		var strClassName;
		for(var i=0; i<this.elementsWithTitles.length; i++){
			oElm = this.elementsWithTitles[i];
			if(this.suppressAltTooltipsInIE){
				oElm.setAttribute('alt', '');
			}
			oElm.onmouseover = GLT.mouseOverElm;
			oElm.onmouseout = GLT.mouseOutElm;
		}
	},
	
	mouseOverElm : function (oEvent){
		var oEvent = (typeof oEvent != 'undefined')? oEvent : event;
		if(typeof GLT != 'undefined'){
			GLT.startTimer(this, oEvent);
			oEvent.cancelBubble = true;
			oEvent.returnValue = false;
			if(oEvent.stopPropagation){
				oEvent.stopPropagation();
			}
		}
	},
	
	mouseOutElm : function (oEvent){
		var oEvent = (typeof oEvent != 'undefined')? oEvent : event;
		if(typeof GLT != 'undefined'){
			GLT.hideTitle(this, oEvent);
		}
	},
	
	startTimer : function (oElm, oEvent){
		if(!this.currentElm || this.currentElm != oElm || this.fadeTimer > 0){
			if(this.fadeTimer){
				clearTimeout(this.fadeTimer);
			}	
			if(this.currentElm){
				this.hideTitle(null, false, true);
			}
			this.currentElm = oElm;
			this.currentTitle = this.currentElm.getAttribute('title');
			this.currentElm.setAttribute('title', '');
			this.currentX = oEvent.clientX;
			this.currentY = oEvent.clientY;
			this.fadeTimer = setTimeout('GLT.showTitle()', GLT.timeBeforeShow);
		}
    },
	
	stopTimer : function (oElm){
		clearTimeout(GLT.fadeTimer);
    },
	
	showTitle : function (){
		this.setTitlePos();
		this.titleTextElm.innerHTML = this.currentTitle;
		this.titleElm.style.visibility = 'visible';
		if(this.fadeInTitle){
			this.currentFadeLevel = this.fadeStartLevel;
			this.fadeIn();
		}
	},
	
	hideTitle : function (oElm, oEvent, forceHide){		
		if(this.currentElm && (oElm || forceHide)){
			var bIsChildOfCurrentElm = false;
			if(typeof oEvent != 'undefined' && typeof oEvent == 'object'){
				var oEventTarget = (typeof oEvent.relatedTarget != 'undefined')? oEvent.relatedTarget : oEvent.toElement;
				if(oEventTarget){
					while(!bIsChildOfCurrentElm && oEventTarget && oEventTarget.nodeName && oEventTarget.nodeName.search(/body/i) == -1){
						if(oEventTarget == oElm){
							bIsChildOfCurrentElm = true;
							break;
						}
						oEventTarget = oEventTarget.parentNode;
					}
				}
			}
			if(!bIsChildOfCurrentElm){
				this.stopTimer();
				if(this.fadeOutTitle && (typeof forceHide == 'undefined' || !forceHide)){
					this.fadeOut();
				}
				else{
					clearTimeout(this.fadeTimer);
					this.currentElm.setAttribute('title', this.currentTitle);
					this.currentElm = null;
					this.titleElm.style.visibility = 'hidden';
				}
			}
		}
	},
	
	setTitlePos : function (){	
		var arrScroll = this.getWinSizeAndScroll();
		var intTitleElmWidthAndPos = this.titleElm.offsetWidth + this.currentX + this.titleOffsetX;
		var intDiff = intTitleElmWidthAndPos - arrScroll[0];
		var intX = (intDiff > 0)? (this.currentX - intDiff) : (this.currentX + this.titleOffsetX);
		this.titleElm.style.left = intX + arrScroll[2] + 'px';
		this.titleElm.style.top = this.currentY + arrScroll[3] + this.titleOffsetY + 'px';
	},
	
	fadeIn : function (fadeOut){
		this.currentFadeLevel = this.currentFadeLevel + this.fadeIncrement;
		if(this.currentFadeLevel < this.originalFadeLevel){
			this.fadeTimer = setTimeout('GLT.fadeIn()', GLT.timePerFadeStep);
		}
		else{
			this.currentFadeLevel = this.originalFadeLevel;
			clearTimeout(this.fadeTimer);
		}
		this.setFade();
	},
	
	fadeOut : function (){
		this.currentFadeLevel = this.currentFadeLevel - this.fadeIncrement;
		if(this.currentFadeLevel > this.fadeStartLevel){
			this.fadeTimer = setTimeout('GLT.fadeOut()', GLT.timePerFadeStep);
		}
		else{
			this.currentFadeLevel = this.originalFadeLevel;
			this.hideTitle(null, false, true);
		}
		this.setFade();
	},
	
	setFade : function (){
		// This line is b/c of a floating point bug in JavaScript
		this.currentFadeLevel = Math.round(this.currentFadeLevel * 10) / 10;
		if(this.titleElm){
			if(this.useMSFilter){
				this.titleElm.style.filter = 'progid:DXImageTransform.Microsoft.Alpha(opacity=' + (this.currentFadeLevel * 100) + ')';
			}
			else{
				this.titleElm.style.opacity = this.currentFadeLevel;
			}
		}
	},
	
	getWinSizeAndScroll : function (){
		var intWidth = document.body.offsetWidth;
		var intHeight = (typeof window.innerHeight != 'undefined')? window.innerHeight : (document.documentElement && document.documentElement.clientHeight > 0)? document.documentElement.clientHeight : document.body.clientHeight;		
		var intXScroll = (typeof window.pageXOffset != 'undefined')? window.pageXOffset : document.body.scrollLeft;		
		var intYScroll = (typeof window.window.pageYOffset != 'undefined')? window.window.pageYOffset : (document.documentElement && document.documentElement.scrollTop > 0)? document.documentElement.scrollTop : document.body.scrollTop;
		return [intWidth, intHeight, intXScroll, intYScroll];
	},
	
	closeSession : function (oEvent){		
		this.removeEvent(window, 'load', function(){GLT.init();}, false);
		GLT = null;
		delete GLT;
	},
	
	addEvent : function (oObject, strEvent, oFunction, bCapture){
		if(oObject){
			if(oObject.addEventListener){
				oObject.addEventListener(strEvent, oFunction, bCapture);
			}
			else if(window.attachEvent){
				oObject.attachEvent(('on' + strEvent), oFunction)
			}
		}
	},

	removeEvent : function (oObject, strEvent, oFunction, bCapture){
		if(oObject){
			if(oObject.removeEventListener){
				oObject.removeEventListener(strEvent, oFunction, false);
			}
			else if(window.detachEvent){
				oObject.detachEvent(('on' + strEvent), oFunction)
			}
		}
	}
};
// ---
GLT.addEvent(window, 'load', function(){GLT.init();}, false);
// ---
// Utility functions
// ---
function getElementsByAttribute(oElm, strTagName, strAttributeName, strAttributeValue){
	var arrElements = (strTagName == '*' && oElm.all)? oElm.all : oElm.getElementsByTagName(strTagName);
	var arrReturnElements = new Array();
	var oAttributeValue = (typeof strAttributeValue != 'undefined')? new RegExp('(^|\\s)' + strAttributeValue + '(\\s|$)') : null;
	var oCurrent;
	var oAttribute;
	for(var i=0; i<arrElements.length; i++){
		oCurrent = arrElements[i];
		oAttribute = oCurrent.getAttribute && oCurrent.getAttribute(strAttributeName);
		if(typeof oAttribute == 'string' && oAttribute.length > 0){
			if(typeof strAttributeValue == 'undefined' || (oAttributeValue && oAttributeValue.test(oAttribute))){
				arrReturnElements.push(oCurrent);
			}
		}
	}
	return arrReturnElements;
}
// ---
if(typeof Array.prototype.push != 'function'){
	Array.prototype.push = ArrayPush;
	function ArrayPush(value){
		this[this.length] = value;
	}
}