1 /*

     2 Copyright (c) 2009, Yahoo! Inc. All rights reserved.

     3 Code licensed under the BSD License:

     4 http://developer.yahoo.net/yui/license.txt

     5 version: 3.0.0

     6 build: 1549

     7 */

     8 YUI.add('compat', function(Y) {

     9 

    10 

    11 var COMPAT_ARG = '~yui|2|compat~';

    12 

    13 

    14 if (window.YAHOO != YUI) {

    15 

    16     // get any existing YAHOO obj props

    17     var o = (window.YAHOO) ? YUI.merge(window.YAHOO) : null;

    18 

    19     // Make the YUI global the YAHOO global

    20     window.YAHOO = YUI;

    21 

    22     // augment old YAHOO props

    23     if (o) {

    24         Y.mix(Y, o);

    25     }

    26 }

    27 

    28 // add old namespaces

    29 Y.namespace("util", "widget", "example");

    30 

    31 // case/location change

    32 Y.env = (Y.env) ? Y.mix(Y.env, Y.Env) : Y.Env;

    33 Y.lang = (Y.lang) ? Y.mix(Y.lang, Y.Lang) : Y.Lang;

    34 Y.env.ua = Y.UA; 

    35 

    36 // support Y.register

    37 Y.mix(Y.env, {

    38         modules: [],

    39         listeners: [],

    40         getVersion: function(name) {

    41             return this.Env.modules[name] || null;

    42         }

    43 });

    44 

    45 var L = Y.lang;

    46 

    47 // add old lang properties 

    48 Y.mix(L, {

    49 

    50     augmentObject: function(r, s) {

    51         var a = arguments, wl = (a.length > 2) ? Y.Array(a, 2, true) : null;

    52         return Y.mix(r, s, (wl), wl);

    53     },

    54  

    55     augmentProto: function(r, s) {

    56         var a = arguments, wl = (a.length > 2) ? Y.Array(a, 2, true) : null;

    57         return Y.mix(r, s, (wl), wl, 1);

    58     },

    59 

    60     // extend: Y.bind(Y.extend, Y), 

    61     extend: Y.extend,

    62     // merge: Y.bind(Y.merge, Y)

    63     merge: Y.merge

    64 }, true);

    65 

    66 L.augment = L.augmentProto;

    67 

    68 L.hasOwnProperty = function(o, k) {

    69     return (o.hasOwnProperty(k));

    70 };

    71 

    72 Y.augmentProto = L.augmentProto;

    73 

    74 // add register function

    75 Y.mix(Y, {

    76     register: function(name, mainClass, data) {

    77         var mods = Y.Env.modules;

    78         if (!mods[name]) {

    79             mods[name] = { versions:[], builds:[] };

    80         }

    81         var m=mods[name],v=data.version,b=data.build,ls=Y.Env.listeners;

    82         m.name = name;

    83         m.version = v;

    84         m.build = b;

    85         m.versions.push(v);

    86         m.builds.push(b);

    87         m.mainClass = mainClass;

    88         // fire the module load listeners

    89         for (var i=0;i<ls.length;i=i+1) {

    90             ls[i](m);

    91         }

    92         // label the main class

    93         if (mainClass) {

    94             mainClass.VERSION = v;

    95             mainClass.BUILD = b;

    96         } else {

    97             Y.log("mainClass is undefined for module " + name, "warn");

    98         }

    99     }

   100 });

   101 

   102 // add old load listeners

   103 if ("undefined" !== typeof YAHOO_config) {

   104     var l=YAHOO_config.listener,ls=Y.Env.listeners,unique=true,i;

   105     if (l) {

   106         // if YAHOO is loaded multiple times we need to check to see if

   107         // this is a new config object.  If it is, add the new component

   108         // load listener to the stack

   109         for (i=0;i<ls.length;i=i+1) {

   110             if (ls[i]==l) {

   111                 unique=false;

   112                 break;

   113             }

   114         }

   115         if (unique) {

   116             ls.push(l);

   117         }

   118     }

   119 }

   120     

   121 // add old registration for yahoo

   122 Y.register("yahoo", Y, {version: "3.0.0", build: "1549"});

   123 

   124 if (Y.Event) {

   125 

   126     var o = {

   127         

   128         /**

   129          * Safari detection

   130          * @property isSafari

   131          * @private

   132          * @static

   133          * @deprecated use Y.Env.UA.webkit

   134          */

   135         isSafari: Y.UA.webkit,

   136         

   137         /**

   138          * webkit version

   139          * @property webkit

   140          * @type string

   141          * @private

   142          * @static

   143          * @deprecated use Y.Env.UA.webkit

   144          */

   145         webkit: Y.UA.webkit,

   146 

   147         /**

   148          * Normalized keycodes for webkit/safari

   149          * @property webkitKeymap

   150          * @type {int: int}

   151          * @private

   152          * @static

   153          * @final

   154          */

   155         webkitKeymap: {

   156             63232: 38, // up

   157             63233: 40, // down

   158             63234: 37, // left

   159             63235: 39, // right

   160             63276: 33, // page up

   161             63277: 34, // page down

   162             25: 9      // SHIFT-TAB (Safari provides a different key code in

   163                        // this case, even though the shiftKey modifier is set)

   164         },

   165         

   166         /**

   167          * IE detection 

   168          * @property isIE

   169          * @private

   170          * @static

   171          * @deprecated use Y.Env.UA.ie

   172          */

   173         isIE: Y.UA.ie,

   174 

   175         /**

   176          * Returns scrollLeft

   177          * @method _getScrollLeft

   178          * @static

   179          * @private

   180          */

   181         _getScrollLeft: function() {

   182             return this._getScroll()[1];

   183         },

   184 

   185         /**

   186          * Returns scrollTop

   187          * @method _getScrollTop

   188          * @static

   189          * @private

   190          */

   191         _getScrollTop: function() {

   192             return this._getScroll()[0];

   193         },

   194 

   195         /**

   196          * Returns the scrollTop and scrollLeft.  Used to calculate the 

   197          * pageX and pageY in Internet Explorer

   198          * @method _getScroll

   199          * @static

   200          * @private

   201          */

   202         _getScroll: function() {

   203             var d = Y.config.doc, dd = d.documentElement, db = d.body;

   204             if (dd && (dd.scrollTop || dd.scrollLeft)) {

   205                 return [dd.scrollTop, dd.scrollLeft];

   206             } else if (db) {

   207                 return [db.scrollTop, db.scrollLeft];

   208             } else {

   209                 return [0, 0];

   210             }

   211         },

   212 

   213         /**

   214          * Returns the event's pageX

   215          * @method getPageX

   216          * @param {Event} ev the event

   217          * @return {int} the event's pageX

   218          * @static

   219          */

   220         getPageX: function(ev) {

   221             var x = ev.pageX;

   222             if (!x && 0 !== x) {

   223                 x = ev.clientX || 0;

   224 

   225                 if ( Y.UA.ie ) {

   226                     x += this._getScrollLeft();

   227                 }

   228             }

   229 

   230             return x;

   231         },

   232 

   233         /**

   234          * Returns the charcode for an event

   235          * @method getCharCode

   236          * @param {Event} ev the event

   237          * @return {int} the event's charCode

   238          * @static

   239          */

   240         getCharCode: function(ev) {

   241             var code = ev.keyCode || ev.charCode || 0;

   242 

   243             // webkit normalization

   244             if (Y.UA.webkit && (code in Y.Event.webkitKeymap)) {

   245                 code = Y.Event.webkitKeymap[code];

   246             }

   247             return code;

   248         },

   249 

   250         /**

   251          * Returns the event's pageY

   252          * @method getPageY

   253          * @param {Event} ev the event

   254          * @return {int} the event's pageY

   255          * @static

   256          */

   257         getPageY: function(ev) {

   258             var y = ev.pageY;

   259             if (!y && 0 !== y) {

   260                 y = ev.clientY || 0;

   261 

   262                 if ( Y.UA.ie ) {

   263                     y += this._getScrollTop();

   264                 }

   265             }

   266 

   267 

   268             return y;

   269         },

   270 

   271         /**

   272          * Returns the pageX and pageY properties as an indexed array.

   273          * @method getXY

   274          * @param {Event} ev the event

   275          * @return {[x, y]} the pageX and pageY properties of the event

   276          * @static

   277          */

   278         getXY: function(ev) {

   279             return [this.getPageX(ev), this.getPageY(ev)];

   280         },

   281 

   282         /**

   283          * Returns the event's related target 

   284          * @method getRelatedTarget

   285          * @param {Event} ev the event

   286          * @return {HTMLElement} the event's relatedTarget

   287          * @static

   288          */

   289         getRelatedTarget: function(ev) {

   290             var t = ev.relatedTarget;

   291             if (!t) {

   292                 if (ev.type == "mouseout") {

   293                     t = ev.toElement;

   294                 } else if (ev.type == "mouseover") {

   295                     t = ev.fromElement;

   296                 }

   297             }

   298 

   299             return this.resolveTextNode(t);

   300         },

   301 

   302         /**

   303          * Returns the time of the event.  If the time is not included, the

   304          * event is modified using the current time.

   305          * @method getTime

   306          * @param {Event} ev the event

   307          * @return {Date} the time of the event

   308          * @static

   309          */

   310         getTime: function(ev) {

   311             if (!ev.time) {

   312                 var t = new Date().getTime();

   313                 try {

   314                     ev.time = t;

   315                 } catch(ex) { 

   316                     this.lastError = ex;

   317                     return t;

   318                 }

   319             }

   320 

   321             return ev.time;

   322         },

   323 

   324         /**

   325          * Convenience method for stopPropagation + preventDefault

   326          * @method stopEvent

   327          * @param {Event} ev the event

   328          * @static

   329          */

   330         stopEvent: function(ev) {

   331             this.stopPropagation(ev);

   332             this.preventDefault(ev);

   333         },

   334 

   335         /**

   336          * Stops event propagation

   337          * @method stopPropagation

   338          * @param {Event} ev the event

   339          * @static

   340          */

   341         stopPropagation: function(ev) {

   342             if (ev.stopPropagation) {

   343                 ev.stopPropagation();

   344             } else {

   345                 ev.cancelBubble = true;

   346             }

   347         },

   348 

   349         /**

   350          * Prevents the default behavior of the event

   351          * @method preventDefault

   352          * @param {Event} ev the event

   353          * @static

   354          */

   355         preventDefault: function(ev) {

   356             if (ev.preventDefault) {

   357                 ev.preventDefault();

   358             } else {

   359                 ev.returnValue = false;

   360             }

   361         },

   362 

   363         /**

   364          * Returns the event's target element.  Safari sometimes provides

   365          * a text node, and this is automatically resolved to the text

   366          * node's parent so that it behaves like other browsers.

   367          * @method getTarget

   368          * @param {Event} ev the event

   369          * @param {boolean} resolveTextNode when set to true the target's

   370          *                  parent will be returned if the target is a 

   371          *                  text node.  @deprecated, the text node is

   372          *                  now resolved automatically

   373          * @return {HTMLElement} the event's target

   374          * @static

   375          */

   376         getTarget: function(ev, resolveTextNode) {

   377             var t = ev.target || ev.srcElement;

   378             return this.resolveTextNode(t);

   379         },

   380 

   381         /**

   382          * In some cases, some browsers will return a text node inside

   383          * the actual element that was targeted.  This normalizes the

   384          * return value for getTarget and getRelatedTarget.

   385          * @method resolveTextNode

   386          * @param {HTMLElement} node node to resolve

   387          * @return {HTMLElement} the normized node

   388          * @static

   389          */

   390         resolveTextNode: function(node) {

   391             if (node && 3 == node.nodeType) {

   392                 return node.parentNode;

   393             } else {

   394                 return node;

   395             }

   396         },

   397 

   398         /**

   399          * We cache elements bound by id because when the unload event 

   400          * fires, we can no longer use document.getElementById

   401          * @method getEl

   402          * @static

   403          * @private

   404          * @deprecated Elements are not cached any longer

   405          */

   406         getEl: function(id) {

   407             return Y.get(id);

   408         }

   409     };

   410 

   411     Y.mix(Y.Event, o);

   412 

   413     /**

   414      * Calls Y.Event.attach with the correct argument order

   415      * @method removeListener

   416      */

   417     Y.Event.removeListener = function(el, type, fn, data, override) {

   418 

   419         var context, a=[type, fn, el];

   420 

   421         if (data) {

   422 

   423             if (override) {

   424                 context = (override === true) ? data : override;

   425             }

   426 

   427             a.push(context);

   428             a.push(data);

   429         }

   430 

   431         a.push(COMPAT_ARG);

   432 

   433         return Y.Event.detach.apply(Y.Event, a);

   434     };

   435 

   436     /**

   437      * Calls Y.Event.detach with the correct argument order

   438      * @method addListener

   439      */

   440     Y.Event.addListener = function(el, type, fn, data, override) {

   441 

   442         // Y.log('addListener:');

   443         // Y.log(Y.Array(arguments, 0, true), 1);

   444 

   445         // var a = Y.Array(arguments, 0, true), el = a.shift();

   446         // a.splice(2, 0, el);

   447         // return Y.Event.attach.apply(Y.Event, a);

   448         var context, a=[type, fn, el];

   449 

   450         if (data) {

   451 

   452             if (override) {

   453                 context = (override === true) ? data : override;

   454             }

   455 

   456             a.push(context);

   457             a.push(data);

   458         }

   459 

   460         a.push(COMPAT_ARG);

   461 

   462         return Y.Event.attach.apply(Y.Event, a);

   463     };

   464 

   465     Y.Event.on = Y.Event.addListener;

   466 

   467     var newOnavail = Y.Event.onAvailable;

   468 

   469     Y.Event.onAvailable = function(id, fn, p_obj, p_override) {

   470         return newOnavail(id, fn, p_obj, p_override, false, true);

   471     };

   472 

   473     Y.Event.onContentReady = function(id, fn, p_obj, p_override) {

   474         return newOnavail(id, fn, p_obj, p_override, true, true);

   475     };

   476 

   477     Y.Event.onDOMReady = function(fn) {

   478         var a = Y.Array(arguments, 0, true);

   479         a.unshift('event:ready');

   480         return Y.on.apply(Y, a);

   481     };

   482 

   483     Y.util.Event = Y.Event;

   484 

   485     var CE = function(type, oScope, silent, signature) {

   486         //debugger;

   487 

   488         var o = {

   489             context: oScope,

   490             silent: silent || false

   491             // signature: signature || CE.LIST

   492         };

   493 

   494         CE.superclass.constructor.call(this, type, o);

   495 

   496         this.signature = signature || CE.LIST;

   497     };

   498 

   499     Y.extend(CE, Y.CustomEvent, {

   500 

   501     });

   502 

   503     /**

   504      * Subscriber listener sigature constant.  The LIST type returns three

   505      * parameters: the event type, the array of args passed to fire, and

   506      * the optional custom object

   507      * @property YAHOO.util.CustomEvent.LIST

   508      * @static

   509      * @type int

   510      */

   511     CE.LIST = 0;

   512 

   513     /**

   514      * Subscriber listener sigature constant.  The FLAT type returns two

   515      * parameters: the first argument passed to fire and the optional 

   516      * custom object

   517      * @property YAHOO.util.CustomEvent.FLAT

   518      * @static

   519      * @type int

   520      */

   521     CE.FLAT = 1;

   522 

   523     Y.util.CustomEvent = CE;

   524 

   525     var EP = function() {

   526         //console.log('Compat CustomEvent constructor executed: ' + this._yuid);

   527         if (!this._yuievt) {

   528             var sub = this.subscribe;

   529             Y.EventTarget.apply(this, arguments);

   530             this.subscribe = sub;

   531             this.__yuiepinit = function() {};

   532         }

   533     };

   534 

   535     Y.extend(EP, Y.EventTarget, {

   536 

   537         createEvent: function(type, o) {

   538             o = o || {};

   539             o.signature = o.signature || CE.FLAT;

   540             return this.publish(type, o);

   541         },

   542 

   543         subscribe: function(type, fn, obj, override) {

   544             var ce = this._yuievt.events[type] || this.createEvent(type),

   545                 a = Y.Array(arguments);

   546 

   547             if (override && true !== override) {

   548                 // a[2] = override;

   549                 // a[1] = obj;

   550             }

   551 

   552             Y.EventTarget.prototype.subscribe.apply(this, a);

   553         },

   554 

   555         fireEvent: function(type) {

   556             return this.fire.apply(this, arguments);

   557         },

   558 

   559         hasEvent: function(type) {

   560             return this.getEvent(type);

   561         }

   562     });

   563 

   564     Y.util.EventProvider = EP;

   565 

   566 }

   567 

   568 

   569 Y.register("event", Y, {version: "3.0.0", build: "1549"});

   570 

   571 

   572 var propertyCache = {};

   573 var patterns = {

   574     HYPHEN: /(-[a-z])/i, // to normalize get/setStyle

   575     ROOT_TAG: /^body|html$/i, // body for quirks mode, html for standards,

   576     OP_SCROLL:/^(?:inline|table-row)$/i

   577 };

   578 

   579 var hyphenToCamel = function(property) {

   580     if ( !patterns.HYPHEN.test(property) ) {

   581         return property; // no hyphens

   582     }

   583     

   584     if (propertyCache[property]) { // already converted

   585         return propertyCache[property];

   586     }

   587    

   588     var converted = property;

   589 

   590     while( patterns.HYPHEN.exec(converted) ) {

   591         converted = converted.replace(RegExp.$1,

   592                 RegExp.$1.substr(1).toUpperCase());

   593     }

   594     

   595     propertyCache[property] = converted;

   596     return converted;

   597     //return property.replace(/-([a-z])/gi, function(m0, m1) {return m1.toUpperCase()}) // cant use function as 2nd arg yet due to safari bug

   598 };

   599 

   600 var Dom = {

   601     get: function(el) {

   602         if (el) {

   603             if (el.nodeType || el.item) { // Node, or NodeList

   604                 return el;

   605             }

   606 

   607             if (typeof el === 'string') { // id

   608                 return document.getElementById(el);

   609             }

   610             

   611             if ('length' in el) { // array-like 

   612                 var c = [];

   613                 for (var i = 0, len = el.length; i < len; ++i) {

   614                     c[c.length] = Dom.get(el[i]);

   615                 }

   616                 

   617                 return c;

   618             }

   619 

   620             return el; // some other object, just pass it back

   621         }

   622 

   623         return null;

   624     },

   625 

   626     isAncestor: function(haystack, needle) {

   627         return YUI.DOM.contains(Dom.get(haystack), Dom.get(needle));

   628     },

   629 

   630     inDocument: function(el) {

   631         return Dom.isAncestor(Y.config.doc.documentElement, el);

   632     },

   633    

   634     batch: function(el, method, o, override, args) {

   635         el = (el && (el.tagName || el.item)) ? el : Dom.get(el); // skip get() when possible 

   636 

   637         if (!el || !method) { 

   638             return false; 

   639         }  

   640         if (args) {

   641             args = Y.Array(args);

   642         }

   643         var scope = (override) ? o : window; 

   644          

   645         var apply = function(el) {

   646             if (args) {

   647                 var tmp = slice.call(args);

   648                 tmp.unshift(el);

   649                 return method.apply(scope, tmp);

   650             } else {

   651                 return method.call(scope, el, o);

   652             }

   653         };

   654 

   655         if (el.tagName || el.length === undefined) { // element or not array-like  

   656             return apply(el); 

   657         }  

   658 

   659         var collection = []; 

   660          

   661         for (var i = 0, len = el.length; i < len; ++i) { 

   662             collection[collection.length] = apply(el[i]);

   663         } 

   664         

   665         return collection;

   666     },

   667 

   668     // 2.x returns false if already present

   669     _addClass: function(el, className) {

   670         if ( YUI.DOM.hasClass(el, className) ) {

   671             return false;

   672         }

   673 

   674         YUI.DOM.addClass(el, className);

   675         return true;

   676     },

   677 

   678     // 2.x returns false if not present

   679     _removeClass: function(el, className) {

   680         if ( !YUI.DOM.hasClass(el, className) ) {

   681             return false;

   682         }

   683 

   684         YUI.DOM.removeClass(el, className);

   685         return true;

   686     },

   687 

   688     // 2.x returns false if no newClass or same as oldClass

   689     _replaceClass: function(el, oldClass, newClass) {

   690         if (!newClass || oldClass === newClass) {

   691             return false;

   692         }

   693 

   694         YUI.DOM.replaceClass(el, oldClass, newClass);

   695         return true;

   696     },

   697 

   698     getElementsByClassName: function(className, tag, root) {

   699         tag = tag || '*';

   700         root = (root) ? Dom.get(root) : Y.config.doc; 

   701         var nodes = [];

   702         if (root) {

   703             nodes = Y.Selector.query(tag + '.' + className, root);

   704         }

   705         return nodes;

   706     },

   707 

   708     getElementsBy: function(method, tag, root) {

   709         tag = tag || '*';

   710         root = (root) ? Dom.get(root) : null || document;

   711 

   712         var nodes = [];

   713         if (root) {

   714             nodes = YUI.DOM.byTag(tag, root, method);

   715         }

   716         return nodes;

   717     },

   718 

   719     getViewportWidth: YUI.DOM.winWidth,

   720     getViewportHeight: YUI.DOM.winHeight,

   721     getDocumentWidth: YUI.DOM.docWidth,

   722     getDocumentHeight: YUI.DOM.docHeight,

   723     getDocumentScrollTop: YUI.DOM.docScrollY,

   724     getDocumentScrollLeft: YUI.DOM.docScrollX,

   725     getDocumentHeight: YUI.DOM.docHeight,

   726 

   727     _guid: function(el, prefix) {

   728         prefix = prefix || 'yui-gen';

   729         Dom._id_counter = Dom._id_counter || 0;

   730 

   731         if (el && el.id) { // do not override existing ID

   732             return el.id;

   733         } 

   734 

   735         var id = prefix + Dom._id_counter++;

   736 

   737         if (el) {

   738             el.id = id;

   739         }

   740         

   741         return id;

   742     },

   743 

   744     _region: function(el) {

   745         if ( (el.parentNode === null || el.offsetParent === null ||

   746                 YUI.DOM.getStyle(el, 'display') == 'none') && el != el.ownerDocument.body) {

   747             return false;

   748         }

   749 

   750         return YUI.DOM.region(el);

   751 

   752     },

   753 

   754     _ancestorByClass: function(element, className) {

   755         return YUI.DOM.ancestor(element, function(el) {

   756             return YUI.DOM.hasClass(el, className);

   757         });

   758     },

   759 

   760     _ancestorByTag: function(element, tag) {

   761         tag = tag.toUpperCase();

   762         return YUI.DOM.ancestor(element, function(el) {

   763             return el.tagName.toUpperCase() === tag;

   764         });

   765     }

   766 };

   767 

   768 var slice = [].slice;

   769 

   770 var wrap = function(fn, name) {

   771     Dom[name] = function() {

   772         var args = slice.call(arguments);

   773         args[0] = Dom.get(args[0]);

   774         return fn.apply(Dom, args);

   775     };

   776 };

   777 

   778 var wrapped = {

   779     getAncestorBy: YUI.DOM.ancestor,

   780     getAncestorByClassName: Dom._ancestorByClass,

   781     getAncestorByTagName: Dom._ancestorByTag,

   782     getPreviousSiblingBy: YUI.DOM.previous,

   783     getPreviousSibling: YUI.DOM.previous,

   784     getNextSiblingBy: YUI.DOM.next,

   785     getNextSibling: YUI.DOM.next,

   786     getFirstChildBy: YUI.DOM.firstChild,

   787     getFirstChild: YUI.DOM.firstChild,

   788     getLastChildBy: YUI.DOM.lastChild,

   789     getLastChild: YUI.DOM.lastChild,

   790     getChildrenBy: YUI.DOM.children,

   791     getChildren: YUI.DOM.children,

   792     insertBefore: function(newNode, refNode) {

   793         YUI.DOM.insertBefore(Dom.get(newNode), Dom.get(refNode));

   794     },

   795     insertAfter: function(newNode, refNode) {

   796         YUI.DOM.insertAfter(Dom.get(newNode), Dom.get(refNode));

   797     }

   798 };

   799 

   800 Y.each(wrapped, wrap);

   801 

   802 var batched = {

   803     getStyle: YUI.DOM.getStyle,

   804     setStyle: YUI.DOM.setStyle,

   805     getXY: YUI.DOM.getXY,

   806     setXY: YUI.DOM.setXY,

   807     getX: YUI.DOM.getX,

   808     getY: YUI.DOM.getY,

   809     setX: YUI.DOM.setX, 

   810     setY: YUI.DOM.setY, 

   811     getRegion: Dom._region,

   812     hasClass: YUI.DOM.hasClass,

   813     addClass: Dom._addClass,

   814     removeClass: Dom._removeClass,

   815     replaceClass: Dom._replaceClass,

   816     generateId: Dom._guid

   817 };

   818 

   819 Y.each(batched, function(v, n) {

   820     Dom[n] = function(el) {

   821         var args = slice.call(arguments, 1);

   822         return Dom.batch(el, v, null, null, args);

   823     };

   824 });

   825 

   826 Y.util.Dom = Dom;

   827 

   828 YAHOO.util.Region = function(t, r, b, l) {

   829     this.top = t;

   830     this[1] = t;

   831     this.right = r;

   832     this.bottom = b;

   833     this.left = l;

   834     this[0] = l;

   835 };

   836 

   837 YAHOO.util.Region.prototype.contains = function(region) {

   838     return ( region.left   >= this.left   && 

   839              region.right  <= this.right  && 

   840              region.top    >= this.top    && 

   841              region.bottom <= this.bottom    );

   842 

   843     // this.logger.debug("does " + this + " contain " + region + " ... " + ret);

   844 };

   845 

   846 YAHOO.util.Region.prototype.getArea = function() {

   847     return ( (this.bottom - this.top) * (this.right - this.left) );

   848 };

   849 

   850 YAHOO.util.Region.prototype.intersect = function(region) {

   851     var t = Math.max( this.top,    region.top    );

   852     var r = Math.min( this.right,  region.right  );

   853     var b = Math.min( this.bottom, region.bottom );

   854     var l = Math.max( this.left,   region.left   );

   855     

   856     if (b >= t && r >= l) {

   857         return new YAHOO.util.Region(t, r, b, l);

   858     } else {

   859         return null;

   860     }

   861 };

   862 

   863 YAHOO.util.Region.prototype.union = function(region) {

   864     var t = Math.min( this.top,    region.top    );

   865     var r = Math.max( this.right,  region.right  );

   866     var b = Math.max( this.bottom, region.bottom );

   867     var l = Math.min( this.left,   region.left   );

   868 

   869     return new YAHOO.util.Region(t, r, b, l);

   870 };

   871 

   872 YAHOO.util.Region.prototype.toString = function() {

   873     return ( "Region {"    +

   874              "top: "       + this.top    + 

   875              ", right: "   + this.right  + 

   876              ", bottom: "  + this.bottom + 

   877              ", left: "    + this.left   + 

   878              "}" );

   879 };

   880 

   881 YAHOO.util.Region.getRegion = function(el) {

   882     return YUI.DOM.region(el);

   883 };

   884 

   885 YAHOO.util.Point = function(x, y) {

   886    if (YAHOO.lang.isArray(x)) { // accept input from Dom.getXY, Event.getXY, etc.

   887       y = x[1]; // dont blow away x yet

   888       x = x[0];

   889    }

   890    

   891     this.x = this.right = this.left = this[0] = x;

   892     this.y = this.top = this.bottom = this[1] = y;

   893 };

   894 

   895 YAHOO.util.Point.prototype = new YAHOO.util.Region();

   896 

   897 

   898 

   899 }, '3.0.0' ,{requires:['dom','event']});

   900 YUI._setup(); YUI.use('dom', 'event', 'compat');