开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 中间件编程 > 查看源码
ext-base-event.js
资源名称：ext-3.0.0.zip　[点击查看]
上传用户：shuoshiled
上传日期：2018-01-28
资源大小：10124k
文件大小：14k
源码类别：

中间件编程

开发平台：

JavaScript

ext-base-event.js：源码内容
  1. /*!  * Ext JS Library 3.0.0  * Copyright(c) 2006-2009 Ext JS, LLC  * licensing@extjs.com  * http://www.extjs.com/license  */ Ext.lib.Event = function() {
  2.     var loadComplete = false,
  3.         listeners = [],
  4.         unloadListeners = [],
  5.         retryCount = 0,
  6.         onAvailStack = [],
  7.         _interval,
  8.         locked = false,
  9.         win = window,
  10.         doc = document,
  11.         
  12.         // constants            
  13.         POLL_RETRYS = 200,
  14.         POLL_INTERVAL = 20,
  15.         EL = 0,
  16.         TYPE = 1,
  17.         FN = 2,
  18.         WFN = 3,
  19.         OBJ = 3,
  20.         ADJ_SCOPE = 4,   
  21.         SCROLLLEFT = 'scrollLeft',
  22.         SCROLLTOP = 'scrollTop',
  23.         UNLOAD = 'unload',
  24.         MOUSEOVER = 'mouseover',
  25.         MOUSEOUT = 'mouseout',
  26.         // private
  27.         doAdd = function() {
  28.             var ret;
  29.             if (win.addEventListener) {
  30.                 ret = function(el, eventName, fn, capture) {
  31.                     if (eventName == 'mouseenter') {
  32.                         fn = fn.createInterceptor(checkRelatedTarget);
  33.                         el.addEventListener(MOUSEOVER, fn, (capture));
  34.                     } else if (eventName == 'mouseleave') {
  35.                         fn = fn.createInterceptor(checkRelatedTarget);
  36.                         el.addEventListener(MOUSEOUT, fn, (capture));
  37.                     } else {
  38.                         el.addEventListener(eventName, fn, (capture));
  39.                     }
  40.                     return fn;
  41.                 };
  42.             } else if (win.attachEvent) {
  43.                 ret = function(el, eventName, fn, capture) {
  44.                     el.attachEvent("on" + eventName, fn);
  45.                     return fn;
  46.                 };
  47.             } else {
  48.                 ret = function(){};
  49.             }
  50.             return ret;
  51.         }(),    
  52.         // private
  53.         doRemove = function(){
  54.             var ret;
  55.             if (win.removeEventListener) {
  56.                 ret = function (el, eventName, fn, capture) {
  57.                     if (eventName == 'mouseenter') {
  58.                         eventName = MOUSEOVER;
  59.                     } else if (eventName == 'mouseleave') {
  60.                         eventName = MOUSEOUT;
  61.                     }                        
  62.                     el.removeEventListener(eventName, fn, (capture));
  63.                 };
  64.             } else if (win.detachEvent) {
  65.                 ret = function (el, eventName, fn) {
  66.                     el.detachEvent("on" + eventName, fn);
  67.                 };
  68.             } else {
  69.                 ret = function(){};
  70.             }
  71.             return ret;
  72.         }();        
  74.     var isXUL = Ext.isGecko ? function(node){ 
  75.         return Object.prototype.toString.call(node) == '[object XULElement]';
  76.     } : function(){};
  77.         
  78.     var isTextNode = Ext.isGecko ? function(node){
  79.         try{
  80.             return node.nodeType == 3;
  81.         }catch(e) {
  82.             return false;
  83.         }
  85.     } : function(node){
  86.         return node.nodeType == 3;
  87.     };
  88.         
  89.     function checkRelatedTarget(e) {
  90.         var related = pub.getRelatedTarget(e);
  91.         return !(isXUL(related) || elContains(e.currentTarget,related));
  92.     }
  94.     function elContains(parent, child) {
  95.        if(parent && parent.firstChild){  
  96.          while(child) {
  97.             if(child === parent) {
  98.                 return true;
  99.             }
  100.             try {
  101.                 child = child.parentNode;
  102.             } catch(e) {
  103.                 // In FF if you mouseout an text input element
  104.                 // thats inside a div sometimes it randomly throws
  105.                 // Permission denied to get property HTMLDivElement.parentNode
  106.                 // See https://bugzilla.mozilla.org/show_bug.cgi?id=208427
  107.                 
  108.                 return false;
  109.             }                
  110.             if(child && (child.nodeType != 1)) {
  111.                 child = null;
  112.             }
  113.           }
  114.         }
  115.         return false;
  116.     }
  118.         
  119.     // private  
  120.     function _getCacheIndex(el, eventName, fn) {
  121.         var index = -1;
  122.         Ext.each(listeners, function (v,i) {
  123.             if(v && v[FN] == fn && v[EL] == el && v[TYPE] == eventName) {
  124.                 index = i;
  125.             }
  126.         });
  127.         return index;
  128.     }
  129.                     
  130.     // private
  131.     function _tryPreloadAttach() {
  132.         var ret = false,                
  133.             notAvail = [],
  134.             element,
  135.             tryAgain = !loadComplete || (retryCount > 0);                       
  136.         
  137.         if (!locked) {
  138.             locked = true;
  139.             
  140.             Ext.each(onAvailStack, function (v,i,a){
  141.                 if(v && (element = doc.getElementById(v.id))){
  142.                     if(!v.checkReady || loadComplete || element.nextSibling || (doc && doc.body)) {
  143.                         element = v.override ? (v.override === true ? v.obj : v.override) : element;
  144.                         v.fn.call(element, v.obj);
  145.                         onAvailStack[i] = null;
  146.                     } else {
  147.                         notAvail.push(v);
  148.                     }
  149.                 }   
  150.             });
  152.             retryCount = (notAvail.length === 0) ? 0 : retryCount - 1;
  154.             if (tryAgain) { 
  155.                 startInterval();
  156.             } else {
  157.                 clearInterval(_interval);
  158.                 _interval = null;
  159.             }
  161.             ret = !(locked = false);
  162.         }
  163.         return ret;
  164.     }
  165.     
  166.     // private              
  167.     function startInterval() {            
  168.         if(!_interval){                    
  169.             var callback = function() {
  170.                 _tryPreloadAttach();
  171.             };
  172.             _interval = setInterval(callback, POLL_INTERVAL);
  173.         }
  174.     }
  175.     
  176.     // private 
  177.     function getScroll() {
  178.         var dd = doc.documentElement, 
  179.             db = doc.body;
  180.         if(dd && (dd[SCROLLTOP] || dd[SCROLLLEFT])){
  181.             return [dd[SCROLLLEFT], dd[SCROLLTOP]];
  182.         }else if(db){
  183.             return [db[SCROLLLEFT], db[SCROLLTOP]];
  184.         }else{
  185.             return [0, 0];
  186.         }
  187.     }
  188.         
  189.     // private
  190.     function getPageCoord (ev, xy) {
  191.         ev = ev.browserEvent || ev;
  192.         var coord  = ev['page' + xy];
  193.         if (!coord && coord !== 0) {
  194.             coord = ev['client' + xy] || 0;
  196.             if (Ext.isIE) {
  197.                 coord += getScroll()[xy == "X" ? 0 : 1];
  198.             }
  199.         }
  201.         return coord;
  202.     }
  204.     var pub =  {
  205.         onAvailable : function(p_id, p_fn, p_obj, p_override) {             
  206.             onAvailStack.push({ 
  207.                 id:         p_id,
  208.                 fn:         p_fn,
  209.                 obj:        p_obj,
  210.                 override:   p_override,
  211.                 checkReady: false });
  213.             retryCount = POLL_RETRYS;
  214.             startInterval();
  215.         },
  218.         addListener: function(el, eventName, fn) {
  219.             var ret;                
  220.             el = Ext.getDom(el);                
  221.             if (el && fn) {
  222.                 if (UNLOAD == eventName) {
  223.                     ret = !!(unloadListeners[unloadListeners.length] = [el, eventName, fn]);                    
  224.                 } else {
  225.                     listeners.push([el, eventName, fn, ret = doAdd(el, eventName, fn, false)]);
  226.                 }
  227.             }
  228.             return !!ret;
  229.         },
  231.         removeListener: function(el, eventName, fn) {
  232.             var ret = false,
  233.                 index, 
  234.                 cacheItem;
  236.             el = Ext.getDom(el);
  238.             if(!fn) {                   
  239.                 ret = this.purgeElement(el, false, eventName);
  240.             } else if (UNLOAD == eventName) {   
  241.                 Ext.each(unloadListeners, function(v, i, a) {
  242.                     if( v && v[0] == el && v[1] == eventName && v[2] == fn) {
  243.                         unloadListeners.splice(i, 1);
  244.                         ret = true;
  245.                     }
  246.                 });
  247.             } else {    
  248.                 index = arguments[3] || _getCacheIndex(el, eventName, fn);
  249.                 cacheItem = listeners[index];
  250.                 
  251.                 if (el && cacheItem) {
  252.                     doRemove(el, eventName, cacheItem[WFN], false);     
  253.                     cacheItem[WFN] = cacheItem[FN] = null;                       
  254.                     listeners.splice(index, 1);     
  255.                     ret = true;
  256.                 }
  257.             }
  258.             return ret;
  259.         },
  261.         getTarget : function(ev) {
  262.             ev = ev.browserEvent || ev;                
  263.             return this.resolveTextNode(ev.target || ev.srcElement);
  264.         },
  266.         resolveTextNode : function(node) {
  267.             return node && !isXUL(node) && isTextNode(node) ? node.parentNode : node;
  268.         },
  270.         getRelatedTarget : function(ev) {
  271.             ev = ev.browserEvent || ev;
  272.             return this.resolveTextNode(ev.relatedTarget || 
  273.                     (ev.type == MOUSEOUT ? ev.toElement :
  274.                      ev.type == MOUSEOVER ? ev.fromElement : null));
  275.         },
  276.         
  277.         getPageX : function(ev) {
  278.             return getPageCoord(ev, "X");
  279.         },
  281.         getPageY : function(ev) {
  282.             return getPageCoord(ev, "Y");
  283.         },
  286.         getXY : function(ev) {                             
  287.             return [this.getPageX(ev), this.getPageY(ev)];
  288.         },
  290. // Is this useful?  Removing to save space unless use case exists.
  291. //             getTime: function(ev) {
  292. //                 ev = ev.browserEvent || ev;
  293. //                 if (!ev.time) {
  294. //                     var t = new Date().getTime();
  295. //                     try {
  296. //                         ev.time = t;
  297. //                     } catch(ex) {
  298. //                         return t;
  299. //                     }
  300. //                 }
  302. //                 return ev.time;
  303. //             },
  305.         stopEvent : function(ev) {                            
  306.             this.stopPropagation(ev);
  307.             this.preventDefault(ev);
  308.         },
  310.         stopPropagation : function(ev) {
  311.             ev = ev.browserEvent || ev;
  312.             if (ev.stopPropagation) {
  313.                 ev.stopPropagation();
  314.             } else {
  315.                 ev.cancelBubble = true;
  316.             }
  317.         },
  319.         preventDefault : function(ev) {
  320.             ev = ev.browserEvent || ev;
  321.             if (ev.preventDefault) {
  322.                 ev.preventDefault();
  323.             } else {
  324.                 ev.returnValue = false;
  325.             }
  326.         },
  327.         
  328.         getEvent : function(e) {
  329.             e = e || win.event;
  330.             if (!e) {
  331.                 var c = this.getEvent.caller;
  332.                 while (c) {
  333.                     e = c.arguments[0];
  334.                     if (e && Event == e.constructor) {
  335.                         break;
  336.                     }
  337.                     c = c.caller;
  338.                 }
  339.             }
  340.             return e;
  341.         },
  343.         getCharCode : function(ev) {
  344.             ev = ev.browserEvent || ev;
  345.             return ev.charCode || ev.keyCode || 0;
  346.         },
  348.         //clearCache: function() {},
  350.         _load : function(e) {
  351.             loadComplete = true;
  352.             var EU = Ext.lib.Event;    
  353.             if (Ext.isIE && e !== true) {
  354.         // IE8 complains that _load is null or not an object
  355.         // so lets remove self via arguments.callee
  356.                 doRemove(win, "load", arguments.callee);
  357.             }
  358.         },            
  359.         
  360.         purgeElement : function(el, recurse, eventName) {
  361.             var me = this;
  362.             Ext.each( me.getListeners(el, eventName), function(v){
  363.                 if(v){
  364.                     me.removeListener(el, v.type, v.fn);
  365.                 }
  366.             });
  368.             if (recurse && el && el.childNodes) {
  369.                 Ext.each(el.childNodes, function(v){
  370.                     me.purgeElement(v, recurse, eventName);
  371.                 });
  372.             }
  373.         },
  375.         getListeners : function(el, eventName) {
  376.             var me = this,
  377.                 results = [], 
  378.                 searchLists;
  380.             if (eventName){  
  381.                 searchLists = eventName == UNLOAD ? unloadListeners : listeners;
  382.             }else{
  383.                 searchLists = listeners.concat(unloadListeners);
  384.             }
  386.             Ext.each(searchLists, function(v, i){
  387.                 if (v && v[EL] == el && (!eventName || eventName == v[TYPE])) {
  388.                     results.push({
  389.                                 type:   v[TYPE],
  390.                                 fn:     v[FN],
  391.                                 obj:    v[OBJ],
  392.                                 adjust: v[ADJ_SCOPE],
  393.                                 index:  i
  394.                             });
  395.                 }   
  396.             });                
  398.             return results.length ? results : null;
  399.         },
  401.         _unload : function(e) {
  402.              var EU = Ext.lib.Event, 
  403.                 i, 
  404.                 j, 
  405.                 l, 
  406.                 len, 
  407.                 index,
  408.                 scope;
  409.                 
  411.             Ext.each(unloadListeners, function(v) {
  412.                 if (v) {
  413.                     try{
  414.                         scope =  v[ADJ_SCOPE] ? (v[ADJ_SCOPE] === true ? v[OBJ] : v[ADJ_SCOPE]) :  win; 
  415.                         v[FN].call(scope, EU.getEvent(e), v[OBJ]);
  416.                     }catch(ex){}
  417.                 }   
  418.             });     
  420.             unloadListeners = null;
  422.             if(listeners && (j = listeners.length)){                    
  423.                 while(j){                        
  424.                     if((l = listeners[index = --j])){
  425.                         EU.removeListener(l[EL], l[TYPE], l[FN], index);
  426.                     }                        
  427.                 }
  428.                 //EU.clearCache();
  429.             }
  431.             doRemove(win, UNLOAD, EU._unload);
  432.         }            
  433.     };        
  434.     
  435.     // Initialize stuff.
  436.     pub.on = pub.addListener;
  437.     pub.un = pub.removeListener;
  438.     if (doc && doc.body) {
  439.         pub._load(true);
  440.     } else {
  441.         doAdd(win, "load", pub._load);
  442.     }
  443.     doAdd(win, UNLOAD, pub._unload);    
  444.     _tryPreloadAttach();
  445.     
  446.     return pub;
  447. }();