Ext学习笔记03 - 事件

Ext中的事件机制

Ext中的事件机制是在 Ext.util.Observable 中定义的，举一个例子来说明事件机制，先看一下代码，然后慢慢说

 

person.js

Js代码 
  1. Ext.namespace("com.meizhi");  
  2.   
  3. /* 定义NameSpace的别名 */  
  4. Mz = com.meizhi;  
  5.   
  6. Mz.Person = function() {  
  7.     /* 定义事件 */  
  8.     this.addEvents(  
  9.         "nameChange",  
  10.         "sexChange"  
  11.     );  
  12. };  
  13.   
  14. Ext.extend(Mz.Person, Ext.util.Observable, {  
  15.     name:"",  
  16.     sex:"",  
  17.     setName:function(_name){  
  18.         if(this.name != _name) {  
  19.             /* 发布事件 */  
  20.             this.fireEvent("nameChange", this, this.name, _name);  
  21.             this.name = _name;  
  22.         }     
  23.     },  
  24.     setSex:function(_sex){  
  25.         if(this.sex != _sex){  
  26.             /* 发布事件 */  
  27.             this.fireEvent("sexChange", this, this.sex, _sex);  
  28.             this.sex = _sex;  
  29.         }  
  30.     }  
  31. });  

 

看JS文件中的定义

  1. 先定义了一个Person类，在类中只有一个属性addEvents，属性值是一个字符串数组，在这里是定义了两个 Event 事件的名字。
  2. 声明 Person 类继承自 Ext.util.Observable 类，并且定义了Person类的另外一些属性：name，sex，以及它们的写方法（这里把setName和setSex称为属性更合适一些）。
  3. 在属性的写方法 setName ，setSex 中，如果传入的值和实例化的 Person 对象的属性值不一致就会调用相应的事件，并且给属性赋值。
  4. 这样 Person 类的属性定义就完成了，并且现在 Person 是具有Ext事件机制的类，以后在 Person 类的实例中绑定和调用事件就非常方便了。

Ext.util.Observable 维护了一个events 对象的数组，并提供了更加方便的对于事件的封装和调用机制。（参考：http://www.cnblogs.com/meetrice/archive/2008/05/23/1206108.html ）

 

addEvents()：绑定事件，看一下它的源代码

Js代码 
  1. addEvents : function(o){  
  2.     if(!this.events){     
  3.         this.events = {};  
  4.     }  
  5.   
  6.     if(typeof o == 'string'){  
  7.         for(var i = 0, a = arguments, v; v = a[i]; i++){  
  8.             if(!this.events[a[i]]){  
  9.   
  10.             // 将传入的事件名称注册到事件列表中                  
  11.             this.events[a[i]] = true;  
  12.             }  
  13.         }  
  14.     }else{  
  15.         Ext.applyIf(this.events, o);  
  16.     }  
  17. }  

 

该方法实际上就是在 Person 对象上绑定了两个没有任何实现的事件名 ，这样 Person 对象就具有了两个空的Event对象（绑定可以执行操作的Event对象使用 addlistener 方法）。

 

fireEvent()：发布事件，也就是触发绑定的事件。源代码中的定义

Js代码 
  1. fireEvent : function(){  
  2.         if(this.eventsSuspended !== true){  
  3.       //通过addEvents()注册的事件会被封装成events对象  
  4.             var ce = this.events[arguments[0].toLowerCase()];  
  5.             if(typeof ce == "object"){  
  6.             //触发事件对象  
  7.                 return ce.fire.apply(ce, Array.prototype.slice.call(arguments, 1));  
  8.             }  
  9.         }  
  10.         return true;  
  11.     }  

 

 

现在Person类的结构就很清楚了，

  1. name属性
  2. sex属性
  3. setName属性（如果传入参数和name属性不一致，调用 “nameChange” 事件）
  4. setSex属性（如果传入参数和name属性不一致，调用 “sexChange” 事件）

在person.js中完成是事件的定义和发布，那事件是在什么时候被订阅的呢？ 事件触发之后又要进行哪些操作呢？  

 

person.html

Html代码 
  1. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">  
  2. <html>  
  3. <head>  
  4. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">  
  5. <title>Event</title>  
  6. <link type="text/css" rel="stylesheet" href="http://www.cnblogs.com/ext/resources/css/ext-all.css">  
  7. <script type="text/javascript" src="http://www.cnblogs.com/ext/adapter/ext/ext-base.js"></script>  
  8. <script type="text/javascript" src="http://www.cnblogs.com/ext/ext-all.js"></script>  
  9.   
  10. <script type="text/javascript" src="person.js"></script>  
  11. <script type="text/javascript">  
  12.     var _person = null;  
  13.       
  14.     button_click = function() {  
  15.         _person.setName(prompt("请输入姓名", ""));  
  16.         _person.setSex(prompt("请输入性别", ""));  
  17.     }  
  18.       
  19.     Ext.onReady(function(){  
  20.         var txt_name = Ext.get("txt_name");  
  21.         var txt_sex = Ext.get("txt_sex");  
  22.           
  23.         /* 构建Person类 */  
  24.         _person = new Mz.Person();  
  25.           
  26.         /* 订阅事件 */  
  27.         _person.on("nameChange",   
  28.                         function(_person, _old, _new){  
  29.                             txt_name.dom.value = _new;  
  30.                         });  
  31.         /* 订阅事件 */                        
  32.         _person.on("sexChange",  
  33.                         function(_person, _old, _new){  
  34.                             txt_sex.dom.value = _new;  
  35.                         });  
  36.         /* 订阅事件 */  
  37.         _person.on("nameChange",   
  38.                         function(_person, _old, _new){  
  39.                             document.title = _new;  
  40.                         });  
  41.     });  
  42. </script>  
  43. </head>  
  44. <body>  
  45. 姓名：<input type="text" id="txt_name" maxlength="10" /><br/>  
  46. 性别：<input type="text" id="txt_sex" maxlength="10" /><br/>  
  47. <input type="button" value="输入" onclick="button_click()"/>  
  48. </body>  
  49. </html>  

 

HTML文件页面中定义了两个输入框，和一个按钮，通过Ext.onReady()，页面初始化后首先执行里面的代码

  1. Ext.get()取得文本框中的值
  2. 构造 Person 类实例
  3. 订阅事件，这个时候定义 Person 中的设值属性的操作具体执行的内容，给setName()和setSex()订阅的事件中添加内容，这一点非常灵活，我们一开始只要先定义一个事件，而这个事件只有一个名字，没有具体实现，我们在订阅这个事件的时候才告诉它如果事件发生我们需要进行什么样的操作。

在点击按钮的时候，调用 button_click 方法来给 person 实例属性赋值。

 

 

 

在订阅事件的时候，用到的是 Observable.on 方法，实际上它是 Observable.addListener 的缩写（Ext里面的缩写好多啊...），源代码中是这样定义的

Js代码 
  1. Ext.util.Observable.prototype.on = Ext.util.Observable.prototype.addListener;  

 

 

绑定事件真正起作用的方法就是addListener()方法，源码中的定义

Js代码 
  1. addListener : function(fn, scope, options){  
  2.     scope = scope || this.obj;  
  3.     if(!this.isListening(fn, scope)){  
  4.         var l = this.createListener(fn, scope, options);  
  5.         if(!this.firing){  
  6.             this.listeners.push(l);  
  7.         }else{ // if we are currently firing this event, don't disturb the listener loop  
  8.             this.listeners = this.listeners.slice(0);  
  9.             this.listeners.push(l);  
  10.         }  
  11.     }  
  12. }  

 

 

最后看一下效果：

  • 页面中有两个input框和一个button


  • 点击“输入”button，然后弹出来一个对话框，要求输入姓名


  • 点击确定，输入框的内容会自动赋值到 id 为 txt_name 的 input 框中，HTML文档的标题也会变成刚才输入的姓名的值，同时会弹出第二个对话框要求输入性别


  • 输入性别确认，值被带到 id 为 txt_sex 的 input 框中


 

顺便说一下例子中涉及到的其他的方法：

  • Ext.onReady()：用法相当于 window.onload ，是在页面装载完成时调用的方法，Ext.onReady是一个简写，定义在Ext.core.EventManager中，源代码：
Js代码 
  1. onDocumentReady : function(fn, scope, options){  
  2.     if(!docReadyEvent){  
  3.                 initDocReady();  
  4.     }  
  5.     if(docReadyState || Ext.isReady){ // if it already fired  
  6.         options || (options = {});  
  7.         fn.defer(options.delay||0, scope);  
  8.     }else{  
  9.         docReadyEvent.addListener(fn, scope, options);  
  10.     }  
  11. }  

 

在这个例子中，我们订阅了两次 nameChange 事件，这也是Ext中很重要的一个机制 -- 事件列表 ，在整个应用当中，公布一个事件，这个事件可以被多次订阅，这一点是很常用的，实现了一个完善的应用体系。

 

通过上面的例子也可以看出Ext的一些缺点：完成这样一个 事件定义、发布、过程所用到的代码比较复杂，不够简洁，要是更加直观一些就更好了，可以让人更加容易理解一些。

posted on 2010-11-17 10:13  滴d  阅读(1467)  评论(0)  编辑  收藏  举报

导航