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;
  }