// Patch for Prototype 1.6.0
 
Event.Methods = (function() {
 
  var isButton;
 
 
 
  if (Prototype.Browser.IE) {
 
    var buttonMap = { 0: 1, 1: 4, 2: 2 };
 
    isButton = function(event, code) {
 
      return event.button == buttonMap[code];
 
    };
 
 
 
  } else if (Prototype.Browser.WebKit) {
 
    isButton = function(event, code) {
 
      switch (code) {
 
        case 0: return event.which == 1 && !event.metaKey;
 
        case 1: return event.which == 1 && event.metaKey;
 
        default: return false;
 
      }
 
    };
 
 
 
  } else {
 
    isButton = function(event, code) {
 
      return event.which ? (event.which === code + 1) : (event.button === code);
 
    };
 
  }
 
 
 
  return {
 
    isLeftClick:   function(event) { return isButton(event, 0) },
 
    isMiddleClick: function(event) { return isButton(event, 1) },
 
    isRightClick:  function(event) { return isButton(event, 2) },
 
 
 
    element: function(event) {
 
      var node = Event.extend(event).target;
 
      return Element.extend(node.nodeType == Node.TEXT_NODE ? node.parentNode : node);
 
    },
 
 
 
    findElement: function(event, expression) {
 
      var element = Event.element(event);
 
      if (!expression) return element;
 
      var elements = [element].concat(element.ancestors());
 
      return Selector.findElement(elements, expression, 0);
 
    },
 
 
 
    pointer: function(event) {
 
      return {
 
        x: event.pageX || (event.clientX +
 
          (document.documentElement.scrollLeft || document.body.scrollLeft)),
 
        y: event.pageY || (event.clientY +
 
          (document.documentElement.scrollTop || document.body.scrollTop))
 
      };
 
    },
 
 
 
    pointerX: function(event) { return Event.pointer(event).x },
 
    pointerY: function(event) { return Event.pointer(event).y },
 
 
 
    stop: function(event) {
 
      Event.extend(event);
 
      event.preventDefault();
 
      event.stopPropagation();
 
      event.stopped = true;
 
    }
 
  };
 
})();
 
 
 
Object.extend(Event, (function() {
 
  var cache = Event.cache;
 
 
 
  function getEventID(element) {
 
    if (element._eventID) return element._eventID;
 
    arguments.callee.id = arguments.callee.id || 1;
 
    return element._eventID = ++arguments.callee.id;
 
  }
 
 
 
  function getDOMEventName(eventName) {
 
    if (eventName && eventName.include(':')) return "dataavailable";
 
      if(!Prototype.Browser.IE) eventName = {mouseenter: "mouseover", mouseleave: "mouseout"}[eventName] || eventName;
 
    return eventName;
 
  }
 
 
 
  function getCacheForID(id) {
 
    return cache[id] = cache[id] || { };
 
  }
 
 
 
  function getWrappersForEventName(id, eventName) {
 
    var c = getCacheForID(id);
 
    return c[eventName] = c[eventName] || [];
 
  }
 
 
 
  function createWrapper(element, eventName, handler) {
 
    var id = getEventID(element);
 
    var c = getWrappersForEventName(id, eventName);
 
    if (c.pluck("handler").include(handler)) return false;
 
 
 
    var wrapper = function(event) {
 
      if (!Event || !Event.extend ||
 
        (event.eventName && event.eventName != eventName))
 
          return false;
 
 
 
      Event.extend(event);
      if (handler)
    	  handler.call(element, event)
 
    };
 
      
 
      if (!(Prototype.Browser.IE) && ['mouseenter', 'mouseleave'].include(eventName)){
 
      wrapper = wrapper.wrap( function(proceed, event) {
 
        var rel = event.relatedTarget, cur = event.currentTarget;
 
        if (rel && rel.nodeType == Node.TEXT_NODE) rel = rel.parentNode;
 
        if (rel && rel != cur && !rel.descendantOf(cur))
 
          return proceed(event);  
 
        });
 
    }
 
    wrapper.handler = handler;
 
    c.push(wrapper);
 
    return wrapper;
 
  }
 
 
 
  function findWrapper(id, eventName, handler) {
 
    var c = getWrappersForEventName(id, eventName);
 
    return c.find(function(wrapper) { return wrapper.handler == handler });
 
  }
 
 
 
  function destroyWrapper(id, eventName, handler) {
 
    var c = getCacheForID(id);
 
    if (!c[eventName]) return false;
 
    c[eventName] = c[eventName].without(findWrapper(id, eventName, handler));
 
  }
 
 
 
  function destroyCache() {
 
    for (var id in cache)
 
      for (var eventName in cache[id])
 
        cache[id][eventName] = null;
 
  }
 
 
 
  if (window.attachEvent) {
 
    window.attachEvent("onunload", destroyCache);
 
  }
 
 
 
  return {
 
    observe: function(element, eventName, handler) {
 
      element = $(element);
 
      var name = getDOMEventName(eventName);
 
      var wrapper = createWrapper(element, eventName, handler);
 
      if (!wrapper) return element;
 
 
 
      if (element.addEventListener) {
 
        element.addEventListener(name, wrapper, false);
 
      } else {
 
        element.attachEvent("on" + name, wrapper);
 
      }
 
 
 
      return element;
 
    },
 
 
 
    stopObserving: function(element, eventName, handler) {
 
      element = $(element);
 
      var id = getEventID(element), name = getDOMEventName(eventName);
 
 
 
      if (!handler && eventName) {
 
        getWrappersForEventName(id, eventName).each(function(wrapper) {
 
          element.stopObserving(eventName, wrapper.handler);
 
        });
 
        return element;
 
 
 
      } else if (!eventName) {
 
       Object.keys(getCacheForID(id)).each(function(eventName) {
 
          element.stopObserving(eventName);
 
        });
 
        return element;
 
      }
 
 
 
      var wrapper = findWrapper(id, eventName, handler);
 
      if (!wrapper) return element;
 
 
 
      if (element.removeEventListener) {
 
        element.removeEventListener(name, wrapper, false);
 
      } else {
 
        element.detachEvent("on" + name, wrapper);
 
      }
 
 
 
      destroyWrapper(id, eventName, handler);
 
 
 
      return element;
 
    },
 
 
 
    fire: function(element, eventName, memo) {  
 
      element = $(element);
 
      if (element == document && document.createEvent && !element.dispatchEvent)
 
        element = document.documentElement;
 
 
 
      if (document.createEvent) {
 
        var event = document.createEvent("HTMLEvents");
 
        event.initEvent("dataavailable", true, true);
 
      } else {
 
        var event = document.createEventObject();
 
        event.eventType = "ondataavailable";
 
      }
 
 
 
      event.eventName = eventName;
 
      event.memo = memo || { };
 
 
 
      if (document.createEvent) {
 
        element.dispatchEvent(event);
 
      } else {
 
        element.fireEvent(event.eventType, event);
 
      }
 
 
 
      return event;
 
    }
 
  };
 
})());
 
 
 
Object.extend(Event, Event.Methods);
 
 
 
Element.addMethods({
 
  fire:          Event.fire,
 
  observe:       Event.observe,
 
  stopObserving: Event.stopObserving
 
});
 
 
 
Object.extend(document, {
 
  fire:          Element.Methods.fire.methodize(),
 
  observe:       Element.Methods.observe.methodize(),
 
  stopObserving: Element.Methods.stopObserving.methodize()
 
});
 
// End of Patch for Prototype 1.6.0