src/adapter/core/ext-base-event.js

   1 /*!
   2  * Ext JS Library 3.1.0
   3  * Copyright(c) 2006-2009 Ext JS, LLC
   4  * licensing@extjs.com
   5  * http://www.extjs.com/license
   6  */
   7 Ext.lib.Event = function() {
   8     var loadComplete = false,
   9         unloadListeners = {},
  10         retryCount = 0,
  11         onAvailStack = [],
  12         _interval,
  13         locked = false,
  14         win = window,
  15         doc = document,
  16
  17         // constants
  18         POLL_RETRYS = 200,
  19         POLL_INTERVAL = 20,
  20         EL = 0,
  21         TYPE = 0,
  22         FN = 1,
  23         WFN = 2,
  24         OBJ = 2,
  25         ADJ_SCOPE = 3,
  26         SCROLLLEFT = 'scrollLeft',
  27         SCROLLTOP = 'scrollTop',
  28         UNLOAD = 'unload',
  29         MOUSEOVER = 'mouseover',
  30         MOUSEOUT = 'mouseout',
  31         // private
  32         doAdd = function() {
  33             var ret;
  34             if (win.addEventListener) {
  35                 ret = function(el, eventName, fn, capture) {
  36                     if (eventName == 'mouseenter') {
  37                         fn = fn.createInterceptor(checkRelatedTarget);
  38                         el.addEventListener(MOUSEOVER, fn, (capture));
  39                     } else if (eventName == 'mouseleave') {
  40                         fn = fn.createInterceptor(checkRelatedTarget);
  41                         el.addEventListener(MOUSEOUT, fn, (capture));
  42                     } else {
  43                         el.addEventListener(eventName, fn, (capture));
  44                     }
  45                     return fn;
  46                 };
  47             } else if (win.attachEvent) {
  48                 ret = function(el, eventName, fn, capture) {
  49                     el.attachEvent("on" + eventName, fn);
  50                     return fn;
  51                 };
  52             } else {
  53                 ret = function(){};
  54             }
  55             return ret;
  56         }(),
  57         // private
  58         doRemove = function(){
  59             var ret;
  60             if (win.removeEventListener) {
  61                 ret = function (el, eventName, fn, capture) {
  62                     if (eventName == 'mouseenter') {
  63                         eventName = MOUSEOVER;
  64                     } else if (eventName == 'mouseleave') {
  65                         eventName = MOUSEOUT;
  66                     }
  67                     el.removeEventListener(eventName, fn, (capture));
  68                 };
  69             } else if (win.detachEvent) {
  70                 ret = function (el, eventName, fn) {
  71                     el.detachEvent("on" + eventName, fn);
  72                 };
  73             } else {
  74                 ret = function(){};
  75             }
  76             return ret;
  77         }();
  78
  79     function checkRelatedTarget(e) {
  80         return !elContains(e.currentTarget, pub.getRelatedTarget(e));
  81     }
  82
  83     function elContains(parent, child) {
  84        if(parent && parent.firstChild){
  85          while(child) {
  86             if(child === parent) {
  87                 return true;
  88             }
  89             child = child.parentNode;
  90             if(child && (child.nodeType != 1)) {
  91                 child = null;
  92             }
  93           }
  94         }
  95         return false;
  96     }
  97
  98     // private
  99     function _tryPreloadAttach() {
 100         var ret = false,
 101             notAvail = [],
 102             element, i, len, v,
 103             tryAgain = !loadComplete || (retryCount > 0);
 104
 105         if (!locked) {
 106             locked = true;
 107
 108             for (i = 0, len = onAvailStack.length; i < len; i++) {
 109                 v = onAvailStack[i];
 110                 if(v && (element = doc.getElementById(v.id))){
 111                     if(!v.checkReady || loadComplete || element.nextSibling || (doc && doc.body)) {
 112                         element = v.override ? (v.override === true ? v.obj : v.override) : element;
 113                         v.fn.call(element, v.obj);
 114                         v = null;
 115                     } else {
 116                         notAvail.push(v);
 117                     }
 118                 }
 119             }
 120
 121             retryCount = (notAvail.length === 0) ? 0 : retryCount - 1;
 122
 123             if (tryAgain) {
 124                 startInterval();
 125             } else {
 126                 clearInterval(_interval);
 127                 _interval = null;
 128             }
 129
 130             ret = !(locked = false);
 131         }
 132         return ret;
 133     }
 134
 135     // private
 136     function startInterval() {
 137         if(!_interval){
 138             var callback = function() {
 139                 _tryPreloadAttach();
 140             };
 141             _interval = setInterval(callback, POLL_INTERVAL);
 142         }
 143     }
 144
 145     // private
 146     function getScroll() {
 147         var dd = doc.documentElement,
 148             db = doc.body;
 149         if(dd && (dd[SCROLLTOP] || dd[SCROLLLEFT])){
 150             return [dd[SCROLLLEFT], dd[SCROLLTOP]];
 151         }else if(db){
 152             return [db[SCROLLLEFT], db[SCROLLTOP]];
 153         }else{
 154             return [0, 0];
 155         }
 156     }
 157
 158     // private
 159     function getPageCoord (ev, xy) {
 160         ev = ev.browserEvent || ev;
 161         var coord  = ev['page' + xy];
 162         if (!coord && coord !== 0) {
 163             coord = ev['client' + xy] || 0;
 164
 165             if (Ext.isIE) {
 166                 coord += getScroll()[xy == "X" ? 0 : 1];
 167             }
 168         }
 169
 170         return coord;
 171     }
 172
 173     var pub =  {
 174         extAdapter: true,
 175         onAvailable : function(p_id, p_fn, p_obj, p_override) {
 176             onAvailStack.push({
 177                 id:         p_id,
 178                 fn:         p_fn,
 179                 obj:        p_obj,
 180                 override:   p_override,
 181                 checkReady: false });
 182
 183             retryCount = POLL_RETRYS;
 184             startInterval();
 185         },
 186
 187         // This function should ALWAYS be called from Ext.EventManager
 188         addListener: function(el, eventName, fn) {
 189             el = Ext.getDom(el);
 190             if (el && fn) {
 191                 if (eventName == UNLOAD) {
 192                     if (unloadListeners[el.id] === undefined) {
 193                         unloadListeners[el.id] = [];
 194                     }
 195                     unloadListeners[el.id].push([eventName, fn]);
 196                     return fn;
 197                 }
 198                 return doAdd(el, eventName, fn, false);
 199             }
 200             return false;
 201         },
 202
 203         // This function should ALWAYS be called from Ext.EventManager
 204         removeListener: function(el, eventName, fn) {
 205             el = Ext.getDom(el);
 206             var i, len, li;
 207             if (el && fn) {
 208                 if (eventName == UNLOAD) {
 209                     if (unloadListeners[id] !== undefined) {
 210                         for (i = 0, len = unloadListeners[id].length; i < len; i++) {
 211                             li = unloadListeners[id][i];
 212                             if (li && li[TYPE] == eventName && li[FN] == fn) {
 213                                 unloadListeners[id].splice(i, 1);
 214                             }
 215                         }
 216                     }
 217                     return;
 218                 }
 219                 doRemove(el, eventName, fn, false);
 220             }
 221         },
 222
 223         getTarget : function(ev) {
 224             ev = ev.browserEvent || ev;
 225             return this.resolveTextNode(ev.target || ev.srcElement);
 226         },
 227
 228         resolveTextNode : Ext.isGecko ? function(node){
 229             if(!node){
 230                 return;
 231             }
 232             // work around firefox bug, https://bugzilla.mozilla.org/show_bug.cgi?id=101197
 233             var s = HTMLElement.prototype.toString.call(node);
 234             if(s == '[xpconnect wrapped native prototype]' || s == '[object XULElement]'){
 235                 return;
 236             }
 237             return node.nodeType == 3 ? node.parentNode : node;
 238         } : function(node){
 239             return node && node.nodeType == 3 ? node.parentNode : node;
 240         },
 241
 242         getRelatedTarget : function(ev) {
 243             ev = ev.browserEvent || ev;
 244             return this.resolveTextNode(ev.relatedTarget ||
 245                     (ev.type == MOUSEOUT ? ev.toElement :
 246                      ev.type == MOUSEOVER ? ev.fromElement : null));
 247         },
 248
 249         getPageX : function(ev) {
 250             return getPageCoord(ev, "X");
 251         },
 252
 253         getPageY : function(ev) {
 254             return getPageCoord(ev, "Y");
 255         },
 256
 257
 258         getXY : function(ev) {
 259             return [this.getPageX(ev), this.getPageY(ev)];
 260         },
 261
 262         stopEvent : function(ev) {
 263             this.stopPropagation(ev);
 264             this.preventDefault(ev);
 265         },
 266
 267         stopPropagation : function(ev) {
 268             ev = ev.browserEvent || ev;
 269             if (ev.stopPropagation) {
 270                 ev.stopPropagation();
 271             } else {
 272                 ev.cancelBubble = true;
 273             }
 274         },
 275
 276         preventDefault : function(ev) {
 277             ev = ev.browserEvent || ev;
 278             if (ev.preventDefault) {
 279                 ev.preventDefault();
 280             } else {
 281                 ev.returnValue = false;
 282             }
 283         },
 284
 285         getEvent : function(e) {
 286             e = e || win.event;
 287             if (!e) {
 288                 var c = this.getEvent.caller;
 289                 while (c) {
 290                     e = c.arguments[0];
 291                     if (e && Event == e.constructor) {
 292                         break;
 293                     }
 294                     c = c.caller;
 295                 }
 296             }
 297             return e;
 298         },
 299
 300         getCharCode : function(ev) {
 301             ev = ev.browserEvent || ev;
 302             return ev.charCode || ev.keyCode || 0;
 303         },
 304
 305         //clearCache: function() {},
 306         // deprecated, call from EventManager
 307         getListeners : function(el, eventName) {
 308             Ext.EventManager.getListeners(el, eventName);
 309         },
 310
 311         // deprecated, call from EventManager
 312         purgeElement : function(el, recurse, eventName) {
 313             Ext.EventManager.purgeElement(el, recurse, eventName);
 314         },
 315
 316         _load : function(e) {
 317             loadComplete = true;
 318             var EU = Ext.lib.Event;
 319             if (Ext.isIE && e !== true) {
 320         // IE8 complains that _load is null or not an object
 321         // so lets remove self via arguments.callee
 322                 doRemove(win, "load", arguments.callee);
 323             }
 324         },
 325
 326         _unload : function(e) {
 327              var EU = Ext.lib.Event,
 328                 i, j, l, v, ul, id, len, index, scope;
 329
 330
 331             for (id in unloadListeners) {
 332                 ul = unloadListeners[id];
 333                 for (i = 0, len = ul.length; i < len; i++) {
 334                     v = ul[i];
 335                     if (v) {
 336                         try{
 337                             scope = v[ADJ_SCOPE] ? (v[ADJ_SCOPE] === true ? v[OBJ] : v[ADJ_SCOPE]) :  win;
 338                             v[FN].call(scope, EU.getEvent(e), v[OBJ]);
 339                         }catch(ex){}
 340                     }
 341                 }
 342             };
 343
 344             unloadListeners = null;
 345             Ext.EventManager._unload();
 346
 347             doRemove(win, UNLOAD, EU._unload);
 348         }
 349     };
 350
 351     // Initialize stuff.
 352     pub.on = pub.addListener;
 353     pub.un = pub.removeListener;
 354     if (doc && doc.body) {
 355         pub._load(true);
 356     } else {
 357         doAdd(win, "load", pub._load);
 358     }
 359     doAdd(win, UNLOAD, pub._unload);
 360     _tryPreloadAttach();
 361
 362     return pub;
 363 }();