Laya鼠标事件阅读

1. 点击事件核心类：MouseManager和TouchManager。
   MouseManager负责收集相关事件，进行捕获阶段和目标阶段。
   TouchManger负责处理和分发事件，进行冒泡阶段。
   • 捕获阶段：此阶段引擎会从stage开始递归检测stage及其子对象，直到找到命中的目标对象或者未命中任何对象；
   • 目标阶段：找到命中的目标对象；
   • 冒泡阶段：事件离开目标对象，按节点层级向上逐层通知，直到到达舞台的过程。

      

2. 事件是由Canvas（浏览器控件等）发起，在MouseManager中注册处理。
3. MouseManager在监听到事件后，会将事件添加到队列中，在stage进入下一帧时（Stage._loop），一次性处理完所有事件。
4. 捕获、目标阶段核心逻辑：（从根节点开始，向子节点查找）
   1. 初始化Event。MouseManager维护一个唯一的Event对象，保留鼠标事件相关信息，如target、touchid等。
   2. 先判断sp是否有scrollRect，如果则scrollRect外，直接判定为没点到，返回false。
   3. 优先检测（HitTestPrior），并且没有点击到，则直接返回false。（width>0并且没有点击穿透的View，默认会被设置为HitTestPrior = true）
   4. 命中检测逻辑（hitTest）
      1. 参数为被判断的sp和转换为相对与sp的鼠标坐标（通过fromParentPoint方法）
      2. 如果有scrollRect，则先偏移鼠标点击位置。
      3. 如果sp的hitArea字段不为空，则返回sp的hitArea.isHit结果。
      4. 如果mouseThrough为true，则检测子对象的实际大小进行碰撞。否则就使用（0,0,width,height）的矩形检测点是否在矩形内。
   5. 倒叙遍历子对象，从外向内检测，检测到后，直接跳过内部检测。
   6. 将目标对象和Event对象传递给TouchManager。
5. 冒泡阶段核心逻辑：（从子节点开始，向根节点查找）
   1. 获取或创建的点击信息，用于检测拖拽、双击等。
   2. 从当前sp开始，递归收集父节点，按顺序放入数组中，子节点在前，父节点在后。
   3. 按照数组属性，对节点发送相关事件，如果事件被阻断（event.stopPropagation），则直接跳过所有父节点。事件的currentTarget为最先被点击的sp。
6. 鼠标事件触发后，参数默认为MouseManager中的event对象。如果监听事件时，自己设置参数，则会在自定义参数数组后，添加event事件。
   else if (args) result = method.apply(caller, args.concat(data));

MouseManager:
private function check(sp:Sprite, mouseX:Number, mouseY:Number, callBack:Function):Boolean {
   this._point.setTo(mouseX, mouseY);
   sp.fromParentPoint(this._point);
   mouseX = this._point.x;
   mouseY = this._point.y;

   //如果有裁剪，则先判断是否在裁剪范围内
   var scrollRect:Rectangle = sp.scrollRect;
   if (scrollRect) {
    _rect.setTo(scrollRect.x, scrollRect.y, scrollRect.width, scrollRect.height);
    if (!_rect.contains(mouseX, mouseY)) return false;
   }

   //先判定子对象是否命中
   if (!disableMouseEvent) {
    //优先判断父对象
    //默认情况下，hitTestPrior=mouseThrough=false，也就是优先check子对象
    //$NEXTBIG:下个重大版本将sp.mouseThrough从此逻辑中去除，从而使得sp.mouseThrough只负责目标对象的穿透
    if (sp.hitTestPrior && !sp.mouseThrough && !hitTest(sp, mouseX, mouseY)) {
     return false;
    }
    for (var i:int = sp._childs.length - 1; i > -1; i--) {  //倒叙遍历，从外向内检测，如果检测到则跳过内部检测
     var child:Sprite = sp._childs[i];
     //只有接受交互事件的，才进行处理
     if (!child.destroyed && child.mouseEnabled && child.visible) {
      if (check(child, mouseX, mouseY, callBack)) return true;
     }
    }
   }

   //避免重复进行碰撞检测，考虑了判断条件的命中率。
   var isHit:Boolean = (sp.hitTestPrior && !sp.mouseThrough && !disableMouseEvent) ? true : hitTest(sp, mouseX, mouseY);

   if (isHit) {
    _target = sp;
    callBack.call(this, sp);
   } else if (callBack === onMouseUp && sp === _stage) {
    //如果stage外mouseUP
    _target = _stage;
    callBack.call(this, _target);
   }

   return isHit;
  }

  private function hitTest(sp:Sprite, mouseX:Number, mouseY:Number):Boolean {
   var isHit:Boolean = false;
   if (sp.scrollRect) {
    mouseX -= sp.scrollRect.x;
    mouseY -= sp.scrollRect.y;
   }
   if (sp.hitArea is HitArea) {
    return sp.hitArea.isHit(mouseX, mouseY);
   }
   if (sp.width > 0 && sp.height > 0 || sp.mouseThrough || sp.hitArea) {
    //判断是否在矩形区域内
    if (!sp.mouseThrough) {
     var hitRect:Rectangle = this._rect;
     if (sp.hitArea) hitRect = sp.hitArea;
     else hitRect.setTo(0, 0, sp.width, sp.height); //坐标已转换为本地坐标系
     isHit = hitRect.contains(mouseX, mouseY);
    } else {
     //如果可穿透，则根据子对象实际大小进行碰撞
     isHit = sp.getGraphicBounds().contains(mouseX, mouseY);
    }
   }
   return isHit;
  }

  /**
   * 执行事件处理。
   */
  public function runEvent():void {
   var len:int = _eventList.length;
   if (!len) return;

   var _this:MouseManager = this;
   var i:int = 0,j:int,n:int,touch:*;
   while (i < len) {
    var evt:* = _eventList[i];

    if (evt.type !== 'mousemove') _prePoint.x = _prePoint.y = -1000000;

    switch (evt.type) {
    case 'mousedown': 
     _touchIDs[0] = _id++;
     if (!_isTouchRespond) {
      _this._isLeftMouse = evt.button === 0;
      _this.initEvent(evt);
      _this.check(_this._stage, _this.mouseX, _this.mouseY, _this.onMouseDown);
     } else
      _isTouchRespond = false;
     break;
    case 'mouseup': 
     _this._isLeftMouse = evt.button === 0;
     _this.initEvent(evt);
     _this.check(_this._stage, _this.mouseX, _this.mouseY, _this.onMouseUp);
     break;
    case 'mousemove': 
     if ((Math.abs(_prePoint.x - evt.clientX) + Math.abs(_prePoint.y - evt.clientY)) >= mouseMoveAccuracy) {
      _prePoint.x = evt.clientX;
      _prePoint.y = evt.clientY;
      _this.initEvent(evt);
      _this.check(_this._stage, _this.mouseX, _this.mouseY, _this.onMouseMove);
       //   _this.checkMouseOut();
     }
     break;
    case "touchstart": 
     _isTouchRespond = true;
     _this._isLeftMouse = true;
     var touches:Array = evt.changedTouches;
     for (j = 0, n = touches.length; j < n; j++) {
      touch = touches[j];
      //是否禁用多点触控
      if (multiTouchEnabled || isNaN(_curTouchID)) {
       _curTouchID = touch.identifier;
       //200次点击清理一下id资源
       if (_id % 200 === 0) _touchIDs = {};
       _touchIDs[touch.identifier] = _id++;
       _this.initEvent(touch, evt);
       _this.check(_this._stage, _this.mouseX, _this.mouseY, _this.onMouseDown);
      }
     }

     break;
    case "touchend": 
    case "touchcancel":
     _isTouchRespond = true;
     _this._isLeftMouse = true;
     var touchends:Array = evt.changedTouches;
     for (j = 0, n = touchends.length; j < n; j++) {
      touch = touchends[j];
      //是否禁用多点触控
      if (multiTouchEnabled || touch.identifier == _curTouchID) {
       _curTouchID = NaN;
       _this.initEvent(touch, evt);
       var isChecked:Boolean;
       isChecked = _this.check(_this._stage, _this.mouseX, _this.mouseY, _this.onMouseUp);
       if (!isChecked)
       {
        _this.onMouseUp(null);
       }
      }
     }

     break;
    case "touchmove": 
     var touchemoves:Array = evt.changedTouches;
     for (j = 0, n = touchemoves.length; j < n; j++) {
      touch = touchemoves[j];
      //是否禁用多点触控
      if (multiTouchEnabled || touch.identifier == _curTouchID) {
       _this.initEvent(touch, evt);
       _this.check(_this._stage, _this.mouseX, _this.mouseY, _this.onMouseMove);
      }
     }
     break;
    case "wheel": 
    case "mousewheel": 
    case "DOMMouseScroll": 
     _this.checkMouseWheel(evt);
     break;
    case "mouseout": 
     //_this._stage.event(Event.MOUSE_OUT, _this._event.setTo(Event.MOUSE_OUT, _this._stage, _this._stage));
     TouchManager.I.stageMouseOut();
     break;
    case "mouseover": 
     _this._stage.event(Event.MOUSE_OVER, _this._event.setTo(Event.MOUSE_OVER, _this._stage, _this._stage));
     break;
    }
    i++;
   }
   _eventList.length = 0;
  }
 }
TouchManager
/**
   * 派发事件。
   * @param eles    对象列表。
   * @param type    事件类型。
   * @param touchID （可选）touchID，默认为0。
   */
  private function sendEvents(eles:Array, type:String, touchID:int = 0):void {
   var i:int, len:int;
   len = eles.length;
   _event._stoped = false;
   var _target:*;
   _target = eles[0];
   var tE:Sprite;
   for (i = 0; i < len; i++) {
    tE = eles[i];
    if (tE.destroyed) return;
    tE.event(type, _event.setTo(type, tE, _target));
    if (_event._stoped)
     break;
   }
  }

  /**
   * 获取对象列表。
   * @param start   起始节点。
   * @param end 结束节点。
   * @param rst 返回值。如果此值不为空，则将其赋值为计算结果，从而避免创建新数组；如果此值为空，则创建新数组返回。
   * @return Array 返回节点列表。
   */
  private function getEles(start:Node, end:Node = null, rst:Array = null):Array {
   if (!rst) {
    rst = [];
   } else {
    rst.length = 0;
   }
   while (start && start != end) {
    rst.push(start);
    start = start.parent;
   }
   return rst;
  }