var Core = {};

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

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

  Core.preventDefault = function(event)
  {
     try
	{
		event.preventDefault();
	}
	catch(error){}
  };

  Core.stopPropagation = function(event)
  {
     try
	{
		event.stopPropagation();
	}
	catch(error){}
  };
}
// Internet Explorer Events model
else if (document.attachEvent)
{
  Core.addEventListener = function(target, type, listener)
  {
     try
	{
	// 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);
    }
	
	}catch(error){}
  };

  Core.removeEventListener = function(target, type, listener)
  {
     try
	{
		// 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];
	}
	catch(error){}
  };

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

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

  Core._findListener = function(target, type, listener)
  {
    try
	{
		// 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;
	}
	catch(error){}
  };

  Core._removeAllListeners = function()
  {
    
	 try
	{
		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];
		}
	}
	catch(error){}
  };

  Core._listenerCounter = 0;
}

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

Core.getElementsByClass = function(theClass)
{
	try
	{
	  var elementArray = [];
	  if (document.all)
	  {
		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;
	}
	catch(error){}
};

Core.hasClass = function(target, theClass)
{
 try
	{
	 var pattern = new RegExp("(^| )" + theClass + "( |$)");
	
	  if (pattern.test(target.className))
	  {
		return true;
	  }
	
	  return false;
	}
	catch(error){}
};

Core.removeClass = function(target, theClass)
{
  try
	{
	  var pattern = new RegExp("(^| )" + theClass + "( |$)");
	  target.className = target.className.replace(pattern, "$1");
	  target.className = target.className.replace(/ $/, "");
 	}
	catch(error){}
};

Core.getComputedStyle = function(element, styleProperty)
{
  try
	{
	  var computedStyle = null;
	
	  if (typeof element.currentStyle != "undefined")
	  {
		computedStyle = element.currentStyle;
	  }
	  else
	  {
		computedStyle = document.defaultView.getComputedStyle(element, null);
	  }
	
	  return computedStyle[styleProperty];
	}
	catch(error){}
};

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