init

jssource/src_files/include/javascript/yui3/build/compat/compat.js

@@ -0,0 +1,896 @@
+/*
+Copyright (c) 2009, Yahoo! Inc. All rights reserved.
+Code licensed under the BSD License:
+http://developer.yahoo.net/yui/license.txt
+version: 3.0.0
+build: 1549
+*/
+YUI.add('compat', function(Y) {
+
+
+var COMPAT_ARG = '~yui|2|compat~';
+
+
+if (window.YAHOO != YUI) {
+
+    // get any existing YAHOO obj props
+    var o = (window.YAHOO) ? YUI.merge(window.YAHOO) : null;
+
+    // Make the YUI global the YAHOO global
+    window.YAHOO = YUI;
+
+    // augment old YAHOO props
+    if (o) {
+        Y.mix(Y, o);
+    }
+}
+
+// add old namespaces
+Y.namespace("util", "widget", "example");
+
+// case/location change
+Y.env = (Y.env) ? Y.mix(Y.env, Y.Env) : Y.Env;
+Y.lang = (Y.lang) ? Y.mix(Y.lang, Y.Lang) : Y.Lang;
+Y.env.ua = Y.UA; 
+
+// support Y.register
+Y.mix(Y.env, {
+        modules: [],
+        listeners: [],
+        getVersion: function(name) {
+            return this.Env.modules[name] || null;
+        }
+});
+
+var L = Y.lang;
+
+// add old lang properties 
+Y.mix(L, {
+
+    augmentObject: function(r, s) {
+        var a = arguments, wl = (a.length > 2) ? Y.Array(a, 2, true) : null;
+        return Y.mix(r, s, (wl), wl);
+    },
+ 
+    augmentProto: function(r, s) {
+        var a = arguments, wl = (a.length > 2) ? Y.Array(a, 2, true) : null;
+        return Y.mix(r, s, (wl), wl, 1);
+    },
+
+    // extend: Y.bind(Y.extend, Y), 
+    extend: Y.extend,
+    // merge: Y.bind(Y.merge, Y)
+    merge: Y.merge
+}, true);
+
+L.augment = L.augmentProto;
+
+L.hasOwnProperty = function(o, k) {
+    return (o.hasOwnProperty(k));
+};
+
+Y.augmentProto = L.augmentProto;
+
+// add register function
+Y.mix(Y, {
+    register: function(name, mainClass, data) {
+        var mods = Y.Env.modules;
+        if (!mods[name]) {
+            mods[name] = { versions:[], builds:[] };
+        }
+        var m=mods[name],v=data.version,b=data.build,ls=Y.Env.listeners;
+        m.name = name;
+        m.version = v;
+        m.build = b;
+        m.versions.push(v);
+        m.builds.push(b);
+        m.mainClass = mainClass;
+        // fire the module load listeners
+        for (var i=0;i<ls.length;i=i+1) {
+            ls[i](m);
+        }
+        // label the main class
+        if (mainClass) {
+            mainClass.VERSION = v;
+            mainClass.BUILD = b;
+        } else {
+        }
+    }
+});
+
+// add old load listeners
+if ("undefined" !== typeof YAHOO_config) {
+    var l=YAHOO_config.listener,ls=Y.Env.listeners,unique=true,i;
+    if (l) {
+        // if YAHOO is loaded multiple times we need to check to see if
+        // this is a new config object.  If it is, add the new component
+        // load listener to the stack
+        for (i=0;i<ls.length;i=i+1) {
+            if (ls[i]==l) {
+                unique=false;
+                break;
+            }
+        }
+        if (unique) {
+            ls.push(l);
+        }
+    }
+}
+    
+// add old registration for yahoo
+Y.register("yahoo", Y, {version: "3.0.0", build: "1549"});
+
+if (Y.Event) {
+
+    var o = {
+        
+        /**
+         * Safari detection
+         * @property isSafari
+         * @private
+         * @static
+         * @deprecated use Y.Env.UA.webkit
+         */
+        isSafari: Y.UA.webkit,
+        
+        /**
+         * webkit version
+         * @property webkit
+         * @type string
+         * @private
+         * @static
+         * @deprecated use Y.Env.UA.webkit
+         */
+        webkit: Y.UA.webkit,
+
+        /**
+         * Normalized keycodes for webkit/safari
+         * @property webkitKeymap
+         * @type {int: int}
+         * @private
+         * @static
+         * @final
+         */
+        webkitKeymap: {
+            63232: 38, // up
+            63233: 40, // down
+            63234: 37, // left
+            63235: 39, // right
+            63276: 33, // page up
+            63277: 34, // page down
+            25: 9      // SHIFT-TAB (Safari provides a different key code in
+                       // this case, even though the shiftKey modifier is set)
+        },
+        
+        /**
+         * IE detection 
+         * @property isIE
+         * @private
+         * @static
+         * @deprecated use Y.Env.UA.ie
+         */
+        isIE: Y.UA.ie,
+
+        /**
+         * Returns scrollLeft
+         * @method _getScrollLeft
+         * @static
+         * @private
+         */
+        _getScrollLeft: function() {
+            return this._getScroll()[1];
+        },
+
+        /**
+         * Returns scrollTop
+         * @method _getScrollTop
+         * @static
+         * @private
+         */
+        _getScrollTop: function() {
+            return this._getScroll()[0];
+        },
+
+        /**
+         * Returns the scrollTop and scrollLeft.  Used to calculate the 
+         * pageX and pageY in Internet Explorer
+         * @method _getScroll
+         * @static
+         * @private
+         */
+        _getScroll: function() {
+            var d = Y.config.doc, dd = d.documentElement, db = d.body;
+            if (dd && (dd.scrollTop || dd.scrollLeft)) {
+                return [dd.scrollTop, dd.scrollLeft];
+            } else if (db) {
+                return [db.scrollTop, db.scrollLeft];
+            } else {
+                return [0, 0];
+            }
+        },
+
+        /**
+         * Returns the event's pageX
+         * @method getPageX
+         * @param {Event} ev the event
+         * @return {int} the event's pageX
+         * @static
+         */
+        getPageX: function(ev) {
+            var x = ev.pageX;
+            if (!x && 0 !== x) {
+                x = ev.clientX || 0;
+
+                if ( Y.UA.ie ) {
+                    x += this._getScrollLeft();
+                }
+            }
+
+            return x;
+        },
+
+        /**
+         * Returns the charcode for an event
+         * @method getCharCode
+         * @param {Event} ev the event
+         * @return {int} the event's charCode
+         * @static
+         */
+        getCharCode: function(ev) {
+            var code = ev.keyCode || ev.charCode || 0;
+
+            // webkit normalization
+            if (Y.UA.webkit && (code in Y.Event.webkitKeymap)) {
+                code = Y.Event.webkitKeymap[code];
+            }
+            return code;
+        },
+
+        /**
+         * Returns the event's pageY
+         * @method getPageY
+         * @param {Event} ev the event
+         * @return {int} the event's pageY
+         * @static
+         */
+        getPageY: function(ev) {
+            var y = ev.pageY;
+            if (!y && 0 !== y) {
+                y = ev.clientY || 0;
+
+                if ( Y.UA.ie ) {
+                    y += this._getScrollTop();
+                }
+            }
+
+
+            return y;
+        },
+
+        /**
+         * Returns the pageX and pageY properties as an indexed array.
+         * @method getXY
+         * @param {Event} ev the event
+         * @return {[x, y]} the pageX and pageY properties of the event
+         * @static
+         */
+        getXY: function(ev) {
+            return [this.getPageX(ev), this.getPageY(ev)];
+        },
+
+        /**
+         * Returns the event's related target 
+         * @method getRelatedTarget
+         * @param {Event} ev the event
+         * @return {HTMLElement} the event's relatedTarget
+         * @static
+         */
+        getRelatedTarget: function(ev) {
+            var t = ev.relatedTarget;
+            if (!t) {
+                if (ev.type == "mouseout") {
+                    t = ev.toElement;
+                } else if (ev.type == "mouseover") {
+                    t = ev.fromElement;
+                }
+            }
+
+            return this.resolveTextNode(t);
+        },
+
+        /**
+         * Returns the time of the event.  If the time is not included, the
+         * event is modified using the current time.
+         * @method getTime
+         * @param {Event} ev the event
+         * @return {Date} the time of the event
+         * @static
+         */
+        getTime: function(ev) {
+            if (!ev.time) {
+                var t = new Date().getTime();
+                try {
+                    ev.time = t;
+                } catch(ex) { 
+                    this.lastError = ex;
+                    return t;
+                }
+            }
+
+            return ev.time;
+        },
+
+        /**
+         * Convenience method for stopPropagation + preventDefault
+         * @method stopEvent
+         * @param {Event} ev the event
+         * @static
+         */
+        stopEvent: function(ev) {
+            this.stopPropagation(ev);
+            this.preventDefault(ev);
+        },
+
+        /**
+         * Stops event propagation
+         * @method stopPropagation
+         * @param {Event} ev the event
+         * @static
+         */
+        stopPropagation: function(ev) {
+            if (ev.stopPropagation) {
+                ev.stopPropagation();
+            } else {
+                ev.cancelBubble = true;
+            }
+        },
+
+        /**
+         * Prevents the default behavior of the event
+         * @method preventDefault
+         * @param {Event} ev the event
+         * @static
+         */
+        preventDefault: function(ev) {
+            if (ev.preventDefault) {
+                ev.preventDefault();
+            } else {
+                ev.returnValue = false;
+            }
+        },
+
+        /**
+         * Returns the event's target element.  Safari sometimes provides
+         * a text node, and this is automatically resolved to the text
+         * node's parent so that it behaves like other browsers.
+         * @method getTarget
+         * @param {Event} ev the event
+         * @param {boolean} resolveTextNode when set to true the target's
+         *                  parent will be returned if the target is a 
+         *                  text node.  @deprecated, the text node is
+         *                  now resolved automatically
+         * @return {HTMLElement} the event's target
+         * @static
+         */
+        getTarget: function(ev, resolveTextNode) {
+            var t = ev.target || ev.srcElement;
+            return this.resolveTextNode(t);
+        },
+
+        /**
+         * In some cases, some browsers will return a text node inside
+         * the actual element that was targeted.  This normalizes the
+         * return value for getTarget and getRelatedTarget.
+         * @method resolveTextNode
+         * @param {HTMLElement} node node to resolve
+         * @return {HTMLElement} the normized node
+         * @static
+         */
+        resolveTextNode: function(node) {
+            if (node && 3 == node.nodeType) {
+                return node.parentNode;
+            } else {
+                return node;
+            }
+        },
+
+        /**
+         * We cache elements bound by id because when the unload event 
+         * fires, we can no longer use document.getElementById
+         * @method getEl
+         * @static
+         * @private
+         * @deprecated Elements are not cached any longer
+         */
+        getEl: function(id) {
+            return Y.get(id);
+        }
+    };
+
+    Y.mix(Y.Event, o);
+
+    /**
+     * Calls Y.Event.attach with the correct argument order
+     * @method removeListener
+     */
+    Y.Event.removeListener = function(el, type, fn, data, override) {
+
+        var context, a=[type, fn, el];
+
+        if (data) {
+
+            if (override) {
+                context = (override === true) ? data : override;
+            }
+
+            a.push(context);
+            a.push(data);
+        }
+
+        a.push(COMPAT_ARG);
+
+        return Y.Event.detach.apply(Y.Event, a);
+    };
+
+    /**
+     * Calls Y.Event.detach with the correct argument order
+     * @method addListener
+     */
+    Y.Event.addListener = function(el, type, fn, data, override) {
+
+
+        // var a = Y.Array(arguments, 0, true), el = a.shift();
+        // a.splice(2, 0, el);
+        // return Y.Event.attach.apply(Y.Event, a);
+        var context, a=[type, fn, el];
+
+        if (data) {
+
+            if (override) {
+                context = (override === true) ? data : override;
+            }
+
+            a.push(context);
+            a.push(data);
+        }
+
+        a.push(COMPAT_ARG);
+
+        return Y.Event.attach.apply(Y.Event, a);
+    };
+
+    Y.Event.on = Y.Event.addListener;
+
+    var newOnavail = Y.Event.onAvailable;
+
+    Y.Event.onAvailable = function(id, fn, p_obj, p_override) {
+        return newOnavail(id, fn, p_obj, p_override, false, true);
+    };
+
+    Y.Event.onContentReady = function(id, fn, p_obj, p_override) {
+        return newOnavail(id, fn, p_obj, p_override, true, true);
+    };
+
+    Y.Event.onDOMReady = function(fn) {
+        var a = Y.Array(arguments, 0, true);
+        a.unshift('event:ready');
+        return Y.on.apply(Y, a);
+    };
+
+    Y.util.Event = Y.Event;
+
+    var CE = function(type, oScope, silent, signature) {
+        //debugger;
+
+        var o = {
+            context: oScope,
+            silent: silent || false
+            // signature: signature || CE.LIST
+        };
+
+        CE.superclass.constructor.call(this, type, o);
+
+        this.signature = signature || CE.LIST;
+    };
+
+    Y.extend(CE, Y.CustomEvent, {
+
+    });
+
+    /**
+     * Subscriber listener sigature constant.  The LIST type returns three
+     * parameters: the event type, the array of args passed to fire, and
+     * the optional custom object
+     * @property YAHOO.util.CustomEvent.LIST
+     * @static
+     * @type int
+     */
+    CE.LIST = 0;
+
+    /**
+     * Subscriber listener sigature constant.  The FLAT type returns two
+     * parameters: the first argument passed to fire and the optional 
+     * custom object
+     * @property YAHOO.util.CustomEvent.FLAT
+     * @static
+     * @type int
+     */
+    CE.FLAT = 1;
+
+    Y.util.CustomEvent = CE;
+
+    var EP = function() {
+        //console.log('Compat CustomEvent constructor executed: ' + this._yuid);
+        if (!this._yuievt) {
+            var sub = this.subscribe;
+            Y.EventTarget.apply(this, arguments);
+            this.subscribe = sub;
+            this.__yuiepinit = function() {};
+        }
+    };
+
+    Y.extend(EP, Y.EventTarget, {
+
+        createEvent: function(type, o) {
+            o = o || {};
+            o.signature = o.signature || CE.FLAT;
+            return this.publish(type, o);
+        },
+
+        subscribe: function(type, fn, obj, override) {
+            var ce = this._yuievt.events[type] || this.createEvent(type),
+                a = Y.Array(arguments);
+
+            if (override && true !== override) {
+                // a[2] = override;
+                // a[1] = obj;
+            }
+
+            Y.EventTarget.prototype.subscribe.apply(this, a);
+        },
+
+        fireEvent: function(type) {
+            return this.fire.apply(this, arguments);
+        },
+
+        hasEvent: function(type) {
+            return this.getEvent(type);
+        }
+    });
+
+    Y.util.EventProvider = EP;
+
+}
+
+
+Y.register("event", Y, {version: "3.0.0", build: "1549"});
+
+
+var propertyCache = {};
+var patterns = {
+    HYPHEN: /(-[a-z])/i, // to normalize get/setStyle
+    ROOT_TAG: /^body|html$/i, // body for quirks mode, html for standards,
+    OP_SCROLL:/^(?:inline|table-row)$/i
+};
+
+var hyphenToCamel = function(property) {
+    if ( !patterns.HYPHEN.test(property) ) {
+        return property; // no hyphens
+    }
+    
+    if (propertyCache[property]) { // already converted
+        return propertyCache[property];
+    }
+   
+    var converted = property;
+
+    while( patterns.HYPHEN.exec(converted) ) {
+        converted = converted.replace(RegExp.$1,
+                RegExp.$1.substr(1).toUpperCase());
+    }
+    
+    propertyCache[property] = converted;
+    return converted;
+    //return property.replace(/-([a-z])/gi, function(m0, m1) {return m1.toUpperCase()}) // cant use function as 2nd arg yet due to safari bug
+};
+
+var Dom = {
+    get: function(el) {
+        if (el) {
+            if (el.nodeType || el.item) { // Node, or NodeList
+                return el;
+            }
+
+            if (typeof el === 'string') { // id
+                return document.getElementById(el);
+            }
+            
+            if ('length' in el) { // array-like 
+                var c = [];
+                for (var i = 0, len = el.length; i < len; ++i) {
+                    c[c.length] = Dom.get(el[i]);
+                }
+                
+                return c;
+            }
+
+            return el; // some other object, just pass it back
+        }
+
+        return null;
+    },
+
+    isAncestor: function(haystack, needle) {
+        return YUI.DOM.contains(Dom.get(haystack), Dom.get(needle));
+    },
+
+    inDocument: function(el) {
+        return Dom.isAncestor(Y.config.doc.documentElement, el);
+    },
+   
+    batch: function(el, method, o, override, args) {
+        el = (el && (el.tagName || el.item)) ? el : Dom.get(el); // skip get() when possible 
+
+        if (!el || !method) { 
+            return false; 
+        }  
+        if (args) {
+            args = Y.Array(args);
+        }
+        var scope = (override) ? o : window; 
+         
+        var apply = function(el) {
+            if (args) {
+                var tmp = slice.call(args);
+                tmp.unshift(el);
+                return method.apply(scope, tmp);
+            } else {
+                return method.call(scope, el, o);
+            }
+        };
+
+        if (el.tagName || el.length === undefined) { // element or not array-like  
+            return apply(el); 
+        }  
+
+        var collection = []; 
+         
+        for (var i = 0, len = el.length; i < len; ++i) { 
+            collection[collection.length] = apply(el[i]);
+        } 
+        
+        return collection;
+    },
+
+    // 2.x returns false if already present
+    _addClass: function(el, className) {
+        if ( YUI.DOM.hasClass(el, className) ) {
+            return false;
+        }
+
+        YUI.DOM.addClass(el, className);
+        return true;
+    },
+
+    // 2.x returns false if not present
+    _removeClass: function(el, className) {
+        if ( !YUI.DOM.hasClass(el, className) ) {
+            return false;
+        }
+
+        YUI.DOM.removeClass(el, className);
+        return true;
+    },
+
+    // 2.x returns false if no newClass or same as oldClass
+    _replaceClass: function(el, oldClass, newClass) {
+        if (!newClass || oldClass === newClass) {
+            return false;
+        }
+
+        YUI.DOM.replaceClass(el, oldClass, newClass);
+        return true;
+    },
+
+    getElementsByClassName: function(className, tag, root) {
+        tag = tag || '*';
+        root = (root) ? Dom.get(root) : Y.config.doc; 
+        var nodes = [];
+        if (root) {
+            nodes = Y.Selector.query(tag + '.' + className, root);
+        }
+        return nodes;
+    },
+
+    getElementsBy: function(method, tag, root) {
+        tag = tag || '*';
+        root = (root) ? Dom.get(root) : null || document;
+
+        var nodes = [];
+        if (root) {
+            nodes = YUI.DOM.byTag(tag, root, method);
+        }
+        return nodes;
+    },
+
+    getViewportWidth: YUI.DOM.winWidth,
+    getViewportHeight: YUI.DOM.winHeight,
+    getDocumentWidth: YUI.DOM.docWidth,
+    getDocumentHeight: YUI.DOM.docHeight,
+    getDocumentScrollTop: YUI.DOM.docScrollY,
+    getDocumentScrollLeft: YUI.DOM.docScrollX,
+    getDocumentHeight: YUI.DOM.docHeight,
+
+    _guid: function(el, prefix) {
+        prefix = prefix || 'yui-gen';
+        Dom._id_counter = Dom._id_counter || 0;
+
+        if (el && el.id) { // do not override existing ID
+            return el.id;
+        } 
+
+        var id = prefix + Dom._id_counter++;
+
+        if (el) {
+            el.id = id;
+        }
+        
+        return id;
+    },
+
+    _region: function(el) {
+        if ( (el.parentNode === null || el.offsetParent === null ||
+                YUI.DOM.getStyle(el, 'display') == 'none') && el != el.ownerDocument.body) {
+            return false;
+        }
+
+        return YUI.DOM.region(el);
+
+    },
+
+    _ancestorByClass: function(element, className) {
+        return YUI.DOM.ancestor(element, function(el) {
+            return YUI.DOM.hasClass(el, className);
+        });
+    },
+
+    _ancestorByTag: function(element, tag) {
+        tag = tag.toUpperCase();
+        return YUI.DOM.ancestor(element, function(el) {
+            return el.tagName.toUpperCase() === tag;
+        });
+    }
+};
+
+var slice = [].slice;
+
+var wrap = function(fn, name) {
+    Dom[name] = function() {
+        var args = slice.call(arguments);
+        args[0] = Dom.get(args[0]);
+        return fn.apply(Dom, args);
+    };
+};
+
+var wrapped = {
+    getAncestorBy: YUI.DOM.ancestor,
+    getAncestorByClassName: Dom._ancestorByClass,
+    getAncestorByTagName: Dom._ancestorByTag,
+    getPreviousSiblingBy: YUI.DOM.previous,
+    getPreviousSibling: YUI.DOM.previous,
+    getNextSiblingBy: YUI.DOM.next,
+    getNextSibling: YUI.DOM.next,
+    getFirstChildBy: YUI.DOM.firstChild,
+    getFirstChild: YUI.DOM.firstChild,
+    getLastChildBy: YUI.DOM.lastChild,
+    getLastChild: YUI.DOM.lastChild,
+    getChildrenBy: YUI.DOM.children,
+    getChildren: YUI.DOM.children,
+    insertBefore: function(newNode, refNode) {
+        YUI.DOM.insertBefore(Dom.get(newNode), Dom.get(refNode));
+    },
+    insertAfter: function(newNode, refNode) {
+        YUI.DOM.insertAfter(Dom.get(newNode), Dom.get(refNode));
+    }
+};
+
+Y.each(wrapped, wrap);
+
+var batched = {
+    getStyle: YUI.DOM.getStyle,
+    setStyle: YUI.DOM.setStyle,
+    getXY: YUI.DOM.getXY,
+    setXY: YUI.DOM.setXY,
+    getX: YUI.DOM.getX,
+    getY: YUI.DOM.getY,
+    setX: YUI.DOM.setX, 
+    setY: YUI.DOM.setY, 
+    getRegion: Dom._region,
+    hasClass: YUI.DOM.hasClass,
+    addClass: Dom._addClass,
+    removeClass: Dom._removeClass,
+    replaceClass: Dom._replaceClass,
+    generateId: Dom._guid
+};
+
+Y.each(batched, function(v, n) {
+    Dom[n] = function(el) {
+        var args = slice.call(arguments, 1);
+        return Dom.batch(el, v, null, null, args);
+    };
+});
+
+Y.util.Dom = Dom;
+
+YAHOO.util.Region = function(t, r, b, l) {
+    this.top = t;
+    this[1] = t;
+    this.right = r;
+    this.bottom = b;
+    this.left = l;
+    this[0] = l;
+};
+
+YAHOO.util.Region.prototype.contains = function(region) {
+    return ( region.left   >= this.left   && 
+             region.right  <= this.right  && 
+             region.top    >= this.top    && 
+             region.bottom <= this.bottom    );
+
+};
+
+YAHOO.util.Region.prototype.getArea = function() {
+    return ( (this.bottom - this.top) * (this.right - this.left) );
+};
+
+YAHOO.util.Region.prototype.intersect = function(region) {
+    var t = Math.max( this.top,    region.top    );
+    var r = Math.min( this.right,  region.right  );
+    var b = Math.min( this.bottom, region.bottom );
+    var l = Math.max( this.left,   region.left   );
+    
+    if (b >= t && r >= l) {
+        return new YAHOO.util.Region(t, r, b, l);
+    } else {
+        return null;
+    }
+};
+
+YAHOO.util.Region.prototype.union = function(region) {
+    var t = Math.min( this.top,    region.top    );
+    var r = Math.max( this.right,  region.right  );
+    var b = Math.max( this.bottom, region.bottom );
+    var l = Math.min( this.left,   region.left   );
+
+    return new YAHOO.util.Region(t, r, b, l);
+};
+
+YAHOO.util.Region.prototype.toString = function() {
+    return ( "Region {"    +
+             "top: "       + this.top    + 
+             ", right: "   + this.right  + 
+             ", bottom: "  + this.bottom + 
+             ", left: "    + this.left   + 
+             "}" );
+};
+
+YAHOO.util.Region.getRegion = function(el) {
+    return YUI.DOM.region(el);
+};
+
+YAHOO.util.Point = function(x, y) {
+   if (YAHOO.lang.isArray(x)) { // accept input from Dom.getXY, Event.getXY, etc.
+      y = x[1]; // dont blow away x yet
+      x = x[0];
+   }
+   
+    this.x = this.right = this.left = this[0] = x;
+    this.y = this.top = this.bottom = this[1] = y;
+};
+
+YAHOO.util.Point.prototype = new YAHOO.util.Region();
+
+
+
+}, '3.0.0' ,{requires:['dom','event']});
+YUI._setup(); YUI.use('dom', 'event', 'compat');