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 (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;
  };

  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);
  };