/*
                             * Custom event engine, DOM event listener abstraction layer, synthetic DOM
                             * events.
                             * @module event
                             * @submodule event-base
                             */
                            
                            function IEEventFacade() {
                                // IEEventFacade.superclass.constructor.apply(this, arguments);
                                Y.DOM2EventFacade.apply(this, arguments);
                            }
                            
                            /*
                             * (intentially left out of API docs)
                             * Alternate Facade implementation that is based on Object.defineProperty, which
                             * is partially supported in IE8.  Properties that involve setup work are
                             * deferred to temporary getters using the static _define method.
                             */
                            function IELazyFacade(e) {
                                var proxy = Y.config.doc.createEventObject(e),
                                    proto = IELazyFacade.prototype;
                            
                                // TODO: necessary?
                                proxy.hasOwnProperty = function () { return true; };
                            
                                proxy.init = proto.init;
                                proxy.halt = proto.halt;
                                proxy.preventDefault           = proto.preventDefault;
                                proxy.stopPropagation          = proto.stopPropagation;
                                proxy.stopImmediatePropagation = proto.stopImmediatePropagation;
                            
                                Y.DOM2EventFacade.apply(proxy, arguments);
                            
                                return proxy;
                            }
                            
                            
                            var imp = Y.config.doc && Y.config.doc.implementation,
                                useLazyFacade = Y.config.lazyEventFacade,
                            
                                buttonMap = {
                                    0: 1, // left click
                                    4: 2, // middle click
                                    2: 3  // right click
                                },
                                relatedTargetMap = {
                                    mouseout: 'toElement',
                                    mouseover: 'fromElement'
                                },
                            
                                resolve = Y.DOM2EventFacade.resolve,
                            
                                proto = {
                                    init: function() {
                            
                                        IEEventFacade.superclass.init.apply(this, arguments);
                            
                                        var e = this._event,
                                            x, y, d, b, de, t;
                            
                                        this.target = resolve(e.srcElement);
                            
                                        if (('clientX' in e) && (!x) && (0 !== x)) {
                                            x = e.clientX;
                                            y = e.clientY;
                            
                                            d = Y.config.doc;
                                            b = d.body;
                                            de = d.documentElement;
                            
                                            x += (de.scrollLeft || (b && b.scrollLeft) || 0);
                                            y += (de.scrollTop  || (b && b.scrollTop)  || 0);
                            
                                            this.pageX = x;
                                            this.pageY = y;
                                        }
                            
                                        if (e.type == "mouseout") {
                                            t = e.toElement;
                                        } else if (e.type == "mouseover") {
                                            t = e.fromElement;
                                        }
                            
                                        // fallback to t.relatedTarget to support simulated events.
                                        // IE doesn't support setting toElement or fromElement on generic
                                        // events, so Y.Event.simulate sets relatedTarget instead.
                                        this.relatedTarget = resolve(t || e.relatedTarget);
                            
                                        // which should contain the unicode key code if this is a key event.
                                        // For click events, which is normalized for which mouse button was
                                        // clicked.
                                        this.which = // chained assignment
                                        this.button = e.keyCode || buttonMap[e.button] || e.button;
                                    },
                            
                                    stopPropagation: function() {
                                        this._event.cancelBubble = true;
                                        this._wrapper.stopped = 1;
                                        this.stopped = 1;
                                    },
                            
                                    stopImmediatePropagation: function() {
                                        this.stopPropagation();
                                        this._wrapper.stopped = 2;
                                        this.stopped = 2;
                                    },
                            
                                    preventDefault: function(returnValue) {
                                        this._event.returnValue = returnValue || false;
                                        this._wrapper.prevented = 1;
                                        this.prevented = 1;
                                    }
                                };
                            
                            Y.extend(IEEventFacade, Y.DOM2EventFacade, proto);
                            
                            Y.extend(IELazyFacade, Y.DOM2EventFacade, proto);
                            IELazyFacade.prototype.init = function () {
                                var e         = this._event,
                                    overrides = this._wrapper.overrides,
                                    define    = IELazyFacade._define,
                                    lazyProperties = IELazyFacade._lazyProperties,
                                    prop;
                            
                                this.altKey   = e.altKey;
                                this.ctrlKey  = e.ctrlKey;
                                this.metaKey  = e.metaKey;
                                this.shiftKey = e.shiftKey;
                                this.type     = (overrides && overrides.type) || e.type;
                                this.clientX  = e.clientX;
                                this.clientY  = e.clientY;
                                this.keyCode  = // chained assignment
                                this.charCode = e.keyCode;
                                this.which    = // chained assignment
                                this.button   = e.keyCode || buttonMap[e.button] || e.button;
                            
                                for (prop in lazyProperties) {
                                    if (lazyProperties.hasOwnProperty(prop)) {
                                        define(this, prop, lazyProperties[prop]);
                                    }
                                }
                            
                                if (this._touch) {
                                    this._touch(e, this._currentTarget, this._wrapper);
                                }
                            };
                            
                            IELazyFacade._lazyProperties = {
                                target: function () {
                                    return resolve(this._event.srcElement);
                                },
                                relatedTarget: function () {
                                    var e = this._event,
                                        targetProp = relatedTargetMap[e.type] || 'relatedTarget';
                            
                                    // fallback to t.relatedTarget to support simulated events.
                                    // IE doesn't support setting toElement or fromElement on generic
                                    // events, so Y.Event.simulate sets relatedTarget instead.
                                    return resolve(e[targetProp] || e.relatedTarget);
                                },
                                currentTarget: function () {
                                    return resolve(this._currentTarget);
                                },
                            
                                wheelDelta: function () {
                                    var e = this._event;
                            
                                    if (e.type === "mousewheel" || e.type === "DOMMouseScroll") {
                                        return (e.detail) ?
                                            (e.detail * -1) :
                                            // wheelDelta between -80 and 80 result in -1 or 1
                                            Math.round(e.wheelDelta / 80) || ((e.wheelDelta < 0) ? -1 : 1);
                                    }
                                },
                            
                                pageX: function () {
                                    var e = this._event,
                                        val = e.pageX,
                                        doc, bodyScroll, docScroll;
                            
                                    if (val === undefined) {
                                        doc = Y.config.doc;
                                        bodyScroll = doc.body && doc.body.scrollLeft;
                                        docScroll = doc.documentElement.scrollLeft;
                            
                                        val = e.clientX + (docScroll || bodyScroll || 0);
                                    }
                            
                                    return val;
                                },
                                pageY: function () {
                                    var e = this._event,
                                        val = e.pageY,
                                        doc, bodyScroll, docScroll;
                            
                                    if (val === undefined) {
                                        doc = Y.config.doc;
                                        bodyScroll = doc.body && doc.body.scrollTop;
                                        docScroll = doc.documentElement.scrollTop;
                            
                                        val = e.clientY + (docScroll || bodyScroll || 0);
                                    }
                            
                                    return val;
                                }
                            };
                            
                            
                            /**
                             * Wrapper function for Object.defineProperty that creates a property whose
                             * value will be calulated only when asked for.  After calculating the value,
                             * the getter wll be removed, so it will behave as a normal property beyond that
                             * point.  A setter is also assigned so assigning to the property will clear
                             * the getter, so foo.prop = 'a'; foo.prop; won't trigger the getter,
                             * overwriting value 'a'.
                             *
                             * Used only by the DOMEventFacades used by IE8 when the YUI configuration
                             * <code>lazyEventFacade</code> is set to true.
                             *
                             * @method _define
                             * @param o {DOMObject} A DOM object to add the property to
                             * @param prop {String} The name of the new property
                             * @param valueFn {Function} The function that will return the initial, default
                             *                  value for the property.
                             * @static
                             * @private
                             */
                            IELazyFacade._define = function (o, prop, valueFn) {
                                function val(v) {
                                    var ret = (arguments.length) ? v : valueFn.call(this);
                            
                                    delete o[prop];
                                    Object.defineProperty(o, prop, {
                                        value: ret,
                                        configurable: true,
                                        writable: true
                                    });
                                    return ret;
                                }
                                Object.defineProperty(o, prop, {
                                    get: val,
                                    set: val,
                                    configurable: true
                                });
                            };
                            
                            if (imp && (!imp.hasFeature('Events', '2.0'))) {
                                if (useLazyFacade) {
                                    // Make sure we can use the lazy facade logic
                                    try {
                                        Object.defineProperty(Y.config.doc.createEventObject(), 'z', {});
                                    } catch (e) {
                                        useLazyFacade = false;
                                    }
                                }
                            
                                Y.DOMEventFacade = (useLazyFacade) ? IELazyFacade : IEEventFacade;
                            }