/*
//EventDispatcher类有2个静态方法: 

  static function initialize(object:Object):Void
  //object:对象
  //initialize:初始化方法，为对象object附加上作为事件源(在这里可以理解为派遣中心吧)的各项功能。
  
  static function _removeEventListener(queue:Object, event:String, handler):Void
  //一个内部方法,注销监听事件源相关事件的监听者,removeEventListener方法会调用它.
  
  EventDispatcher类有4个公共方法:
  function dispatchEvent(eventObj:Object):Void
  事件派遣方法，向外界广播一个消息，并附有关于消息的相关描述(请与broadcastMessage(msg:String)方法比较)
  eventObj:事件对象，它至少应含有2个属性,假设司令部为一个事件派遣中心，一般定义如下:
  var eventObj=new Object();
  eventObj.target=司令部;//定义广播消息的对象
  eventObj.type="on进攻";//定义消息的具体类型 
  其中target属性也可以不定义，dispatchEvent方法会将它设为默认的广播消息的对象。

  function dispatchQueue(queueObj:Object, eventObj:Object):Void
  这个方法的中文意思，我根据它的功能将它称为"事件传达"。
  queueObj:一个事件派遣中心对象
  eventObj:事件对象,注意:与 dispatchEvent不同，它的target并无默认值，需要你手工设定.
  为什么将这个方法称为事件传达呢?因为它可以让当前的事件派遣中心指示另一个事件派遣中心(方法的第一个参数)向外界广播消息。
  其实在dispatchEvent方法的内部就调用了dispatchQueue，只是将参数queueObj设为当前的事件派遣中心罢了。

  function addEventListener(event:String, handler):Void
  注册某个事件的监听者
  event:监听的事件名称
  handler:监听事件的对象
  这个方法与AsBroadcaster类的addListener方法相比，多出了参数event，
  明确了所监听的具体事件。

  function removeEventListener(event:String, handler)
  注销某个事件的监听者
  event:事件名称
  handler:要注销的监听事件的对象
  这个方法与AsBroadcaster类的removeListener方法相比，多出了参数event，明确了从哪个事件中注销监听对象。

  
下面就让我们在战场上实战一下EventDispatcher吧。假设有两个指挥中心，一个是司令部，一个是战地
指挥部。有三个兵种，分别是炮兵、步兵和敢死队。司令部可以指挥炮兵的进攻、驻守和步兵的驻守，战地
指挥部可以指挥步兵的进攻、冲锋和敢死队的冲锋，并且司令部可以向战地指挥部传达指示。下面是实现上
述复杂关系的代码:
*/

import mx.events.EventDispatcher;		//导入 mx.events.EventDispatcher类
var 司令部 = new Object();
司令部.名称 = "司令部";
EventDispatcher.initialize(司令部);		//为司令部对象附加上派遣中心的相关功能。
var 战地指挥部 = new Object();
战地指挥部.名称 = "战地指挥部";
EventDispatcher.initialize(战地指挥部);	//为战地指挥部对象附加上派遣中心的相关功能。
var 步兵 = new Object();
步兵.on进攻 = function(eventObj) {		//步兵的'on进攻'事件处理方法，记住需要有参数
	var 来自 = eventObj.target.名称;		//eventObj.target引用广播'on进攻'事件的对象，用它可以访问事件源并反馈消息。
	var 阵地 = eventObj.阵地;			//获取事件的关于' 阵地'属性值
	trace("步兵接到"+来自+"来电，轻装上阵，火速向敌方"+阵地+"前进!");
};
步兵.on驻守 = function(eventObj) {
	var 来自 = eventObj.target.名称;
	trace("步兵接到"+来自+"来电，就地待命，多设岗哨,严防来犯之敌!");
};
步兵.on冲锋 = function(eventObj) {
	var 来自 = eventObj.target.名称;
	var 阵地 = eventObj.阵地;
	trace("步兵接到"+来自+"来电，向敌方"+阵地+"发起冲锋!");
};
司令部.addEventListener("on驻守", 步兵);		//向司令部的'on驻守'事件注册监听对象'步兵'
战地指挥部.addEventListener("on进攻", 步兵);	//向司令部的'on进攻'事件注册监听对象'步兵'
战地指挥部.addEventListener("on冲锋", 步兵);	//向战地指挥部的'on冲锋'事件注册监听对象'步兵'
var 炮兵 = new Object();
炮兵.on进攻 = function(eventObj) {
	var 来自 = eventObj.target.名称;
	var 阵地 = eventObj.阵地;
	trace("炮兵接到"+来自+"来电，向敌方"+阵地+"阵地猛烈轰击!");
};
炮兵.on驻守 = function(eventObj) {
	var 来自 = eventObj.target.名称;
	trace("炮兵接到"+来自+"来电，就地待命，保证弹药准备充足!");
};
司令部.addEventListener("on驻守", 炮兵);
司令部.addEventListener("on进攻", 炮兵);
var 敢死队 = new Object();
敢死队.on冲锋 = function(eventObj) {
	var 来自 = eventObj.target.名称;
	var 阵地 = eventObj.阵地;
	trace("敢死队接到"+来自+"来电，向敌方"+阵地+"发起冲锋!拼死也要拿下！");
};
战地指挥部.addEventListener("on冲锋", 敢死队);
//---------------------------------------------------------------------
trace("司令部指示:");
var eventObj1 = new Object();	//定义事件对象eventObj1
eventObj1.target = 司令部;		//定义事件对象eventObj1的target属性值为司令部
eventObj1.type = "on进攻";		//定义事件对象的事件类型为'on进攻'
eventObj1.阵地 = "505阵地";		//一个自定义的属性'阵地',你可以附加更多其他的属性
司令部.dispatchEvent(eventObj1);//司令部将定义好的事件对象广播出去，只有向它注册了'on进攻'属性的监听对象才能收到。步兵并不会发动进攻。
trace("战地指挥部指示:");
var eventObj2 = new Object();	//eventObj2.target=战地指挥部;
								//因为dispatchEvent方法会自动将事件对象的target属性设为默认的广播消息的对象，所以这句也可以注释掉。
eventObj2.type = "on进攻";
eventObj2.阵地 = "105阵地";
战地指挥部.dispatchEvent(eventObj2);
trace("传达司令部指示:");
var eventObj3 = new Object();
eventObj3.target = 战地指挥部;	//这里必须设定事件对象的target属性。因为dispatchQueue不会为target属性设定默认值
eventObj3.type = "on冲锋";
eventObj3.阵地 = "123阵地";
司令部.dispatchQueue(战地指挥部, eventObj3);

//战争时期也许司令部并不知道前线部队的布置情况，所以它可以将指令传达给战地指挥部，由战
//地指挥部将事件对象广播给向自己的相关事件注册的监听对具体的测试结果我就不贴出来了。

//最后说说EventDispatcher类的几个有趣的地方:

// 1、监听事件的对象可以是Object、MovieClip，还可以是Function.例如：
//假设在战场上每当发起冲锋时，都要呐喊助威，可以这样写：

function 鼓励士气() {trace("冲啊!杀啊!");}
战地指挥部.addEventListener("on冲锋", 鼓励士气);

//2、当监听事件的对象是自身时,一般的写法是这样的:

战地指挥部.on冲锋 = function() {	trace("同志们，我们一定会取得最后的胜利！");};
战地指挥部.addEventListener("on冲锋", 战地指挥部);
//但是还有一种更简洁的写法:
战地指挥部.on冲锋Handler = function() {
	trace("同志们，我们一定会取得最后的胜利！");
};
// 这种写法不再需要用"addEventListener"来注册了。它有两点需要注意,一是它总在其他监听对象的事件处理之前执行，再就是它无法用'removeEventListener'方法注销监听。

// 3、监听对象的事件处理程序也可以这样写: 
步兵.handlerEvent = function(eventObj) {
	var 来自 = eventObj.target.名称;
	var 阵地 = eventObj.阵地;
	var e = eventObj.type;
	switch (e) {
	case "on进攻" :
		trace("步兵接到"+来自+"来电，轻装上阵，火速向敌方"+阵地+"前进!");
		break;
	case "on驻守" :
		trace("步兵接到"+来自+"来电，就地待命，多设岗哨,严防来犯之敌!");
		break;
	case "on冲锋" :
		trace("步兵接到"+来自+"来电，向敌方"+阵地+"发起冲锋!");
		break;
	default :
		break;
	}
};
司令部.addEventListener("on驻守", 步兵);
战地指挥部.addEventListener("on进攻", 步兵);
战地指挥部.addEventListener("on冲锋", 步兵);


//-------------------------------------------------------------------------------------------------------------

import mx.events.EventDispatcher;
var myObj:Object = new Object();
EventDispatcher.initialize(myObj);
// 注册侦听器对象有三种写法 ////////////////////
// 写法一
myListener = new Object();
myListener.a_evt = function(evt) {
	trace("type:"+evt.type+",target:"+evt.target);
};
myObj.addEventListener("a_evt", myListener);
myObj.dispatchEvent({type:"a_evt"});
// 写法二
function b_evt(evt) {
	trace(evt.type+"!");
}
myObj.addEventListener("b_evt", {b_evt:b_evt});
myObj.dispatchEvent({type:"b_evt"});
// 写法三
myObj.addEventListener("c_evt", {c_evt:function (evt) {
	trace(evt.type+"!");
}});
myObj.dispatchEvent({type:"c_evt"});
//调用方法