1. 事件分发方法 EventDispatcher::dispatchEvent(Event* event)
首先通过_isEnabled标志判断事件分发是否启用。
执行 updateDirtyFlagForSceneGraph()。把一些node对应的ID置脏标记。
对_inDispatch++，当前正在分发的事件数+1。
DispatchGuard guard(_inDispatch);
接下来是一个判断，如果是触摸事件，会调用触摸专用的分发方法，而不是本方法。
if (event->getType() == Event::Type::TOUCH) { dispatchTouchEvent(static_cast<EventTouch*>(event)); return; }
获取参数事件的ID作为监听器ID。
auto listenerID = __getListenerID(event);
接下来对事件同ID的所有监听器进行排序。
sortEventListeners(listenerID);
又是一个类型判断，如果是鼠标事件，定义触摸事件分发函数指针，否则，定义通用的事件分发函数指针。
auto pfnDispatchEventToListeners = &EventDispatcher::dispatchEventToListeners; if (event->getType() == Event::Type::MOUSE) { pfnDispatchEventToListeners = &EventDispatcher::dispatchTouchEventToListeners; }
然后通过参数事件监听器ID从_listenerMap中找到对应的Vector，该类包含两个存储监听器的容器。
auto iter = _listenerMap.find(listenerID); if (iter != _listenerMap.end()) { auto listeners = iter->second; //... }
定义匿名函数。
auto onEvent = [&event](EventListener* listener) -> bool{ event->setCurrentTarget(listener->getAssociatedNode()); listener->_onEvent(event); return event->isStopped(); };
进行事件分发。
(this->*pfnDispatchEventToListeners)(listeners, onEvent);
最后对所有待添加和待删除的监听器进行处理。
updateListeners(event);
简而言之，事件分发的逻辑是，通过参数事件，找到事件对应的监听器ID，分发前还要判断ID对应的监听器容器是否需要重新排序，把该事件分发给所有同ID监听器的回调函数进行处理。
接下来对一些重点方法进行学习。
2. updateDirtyFlagForSceneGraph()
当调用resumeEventListenersForTarget方法，把node的所有关联监听器从暂停状态恢复时，需要把node加入_dirtyNodes。
该函数是就是把_dirtyNodes中的node相关的曾经暂停的监听器的ID在_priorityDirtyFlagMap置脏标记SCENE_GRAPH_PRIORITY，对这些ID的监听器容器之后重新排序。
3. DispatchGuard guard(_inDispatch)
创建了DispatchGuard类的对象，_inDispatch作为构造函数。
DispatchGuard(int& count): _count(count) { ++_count; } ~DispatchGuard() { --_count; }
可以看出，对一件事件进行分发时，_inDispatch++。在分发方法结束时，会对这个局部对象析构，_inDispatch--。十分巧妙的实现了对_inDispatch的自动管理。
4. sortEventListeners(listenerID)
简要的说，在_priorityDirtyFlagMap中判断每种ID的脏标记，根据脏标记的不同，决定ID的哪些容器要重新排序。
该方法首先获取待排序的监听器ID的脏标记。
DirtyFlag dirtyFlag = DirtyFlag::NONE; auto dirtyIter = _priorityDirtyFlagMap.find(listenerID); if (dirtyIter != _priorityDirtyFlagMap.end()) { dirtyFlag = dirtyIter->second; }
脏标记不为NONE，说明容器需要重新排序，于是先把脏标记置NONE，接下来开始排序。脏标记为NONE时，因为已排好序，排序函数执行完成。
if (dirtyFlag != DirtyFlag::NONE) { dirtyIter->second = DirtyFlag::NONE; //...
这里用按位与操作判断是否对ID的两个容器排序。根据按位与的结果，可能两容器都要重新排序，也可能只有一个容器需要排序。
if ((int)dirtyFlag & (int)DirtyFlag::FIXED_PRIORITY) { sortEventListenersOfFixedPriority(listenerID); } if ((int)dirtyFlag & (int)DirtyFlag::SCENE_GRAPH_PRIORITY) { auto rootNode = Director::getInstance()->getRunningScene(); if (rootNode) { sortEventListenersOfSceneGraphPriority(listenerID, rootNode); } else { dirtyIter->second = DirtyFlag::SCENE_GRAPH_PRIORITY; } }
对两个容器排序分别用到了两个方法：
sortEventListenersOfFixedPriority(listenerID);
sortEventListenersOfSceneGraphPriority(listenerID, rootNode);
4.1 sortEventListenersOfFixedPriority(listenerID)
该方法首先获取ID对应的fixedListeners容器。
auto listeners = getListeners(listenerID); if (listeners == nullptr) return; auto fixedListeners = listeners->getFixedPriorityListeners(); if (fixedListeners == nullptr) return;
对容器进行排序，按优先级从小到大的顺序。
std::stable_sort(fixedListeners->begin(), fixedListeners->end(), [](const EventListener* l1, const EventListener* l2) { return l1->getFixedPriority() < l2->getFixedPriority(); });
对排好序的容器从小到大查找，找到第一个优先级不小于0的监听器，把其下标记录，作为Vector的成员_gt0Index。
int index = 0; for (auto& listener : *fixedListeners) { if (listener->getFixedPriority() >= 0) break; ++index; } listeners->setGt0Index(index);
4.2 sortEventListenersOfSceneGraphPriority(listenerID, rootNode)
参数rootNode是当前运行的场景。
同上面的排序一样，显先获取容器。不同之处在于sceneGraphListeners容器里的监听器优先级都为0，排序需要按照node的顺序。
需要_nodePriorityIndex容器记录node的优先级。
_nodePriorityIndex = 0; _nodePriorityMap.clear(); visitTarget(rootNode, true);
visitTarget方法将计算好的node和node优先级存储在_nodePriorityMap。接下来对sceneGraphListeners进行排序，排序依照每个监听器关联的node在_nodePriorityMap的优先级大小，node优先级大，监听器排序在前。
std::stable_sort(sceneGraphListeners->begin(), sceneGraphListeners->end(), [this](const EventListener* l1, const EventListener* l2) { return _nodePriorityMap[l1->getAssociatedNode()] > _nodePriorityMap[l2->getAssociatedNode()]; });
4.3 visitTarget(rootNode, true)
简要的说，将计算好的node和node优先级存储在_nodePriorityMap
该方法首先对node的子节点排序。排序后子节点按LocalZOrder从小到大排列，相同时按添加到node的顺序（即顺序不变）。
node->sortAllChildren();
获取子节点容器，数量。
auto& children = node->getChildren();
auto childrenCount = children.size();
对children进行中序遍历，遍历到的node的globalZOrder和node存入_globalZOrderNodeMap中。此时，map中的每个node容器中node都是按LocalZOrder从小到大排列。
if(childrenCount > 0) { Node* child = nullptr; // visit children zOrder < 0 for( ; i < childrenCount; i++ ) { child = children.at(i); if ( child && child->getLocalZOrder() < 0 ) visitTarget(child, false); else break; } if (_nodeListenersMap.find(node) != _nodeListenersMap.end()) { _globalZOrderNodeMap[node->getGlobalZOrder()].push_back(node); } for( ; i < childrenCount; i++ ) { child = children.at(i); if (child) visitTarget(child, false); } } else { if (_nodeListenersMap.find(node) != _nodeListenersMap.end()) { _globalZOrderNodeMap[node->getGlobalZOrder()].push_back(node); } }
场景节点中，先获取场景中所有节点globalZOrder，并对globalZOrder从小到大排序。
遍历_globalZOrderNodeMap，获取每个node。遍历按globalZOrder从小到大的顺序，相同globalZOrder则按先后顺序（LocalZOrder从小到大）遍历。按遍历的顺序，将node依次添加到_nodePriorityMap。优先级按node的顺序依次+1。即，越晚绘制的node优先级越高。
if (isRootNode) { std::vector<float> globalZOrders; //存储scene中所有node的globalZOrder globalZOrders.reserve(_globalZOrderNodeMap.size()); for (const auto& e : _globalZOrderNodeMap) { globalZOrders.push_back(e.first); } std::stable_sort(globalZOrders.begin(), globalZOrders.end(), [](const float a, const float b){ return a < b; }); //globalZOrder从小到大排序 for (const auto& globalZ : globalZOrders) { for (const auto& n : _globalZOrderNodeMap[globalZ]) { _nodePriorityMap[n] = ++_nodePriorityIndex; } } _globalZOrderNodeMap.clear(); }
5. 进行事件分发 dispatchEventToListeners(listeners, onEvent)
函数指针pfnDispatchEventToListeners根据事件ID是否是鼠标类型指向不同的函数。
以非触摸dispatchEventToListeners为例。
首先获取ID的两个监听器容器：fixedPriorityListeners sceneGraphPriorityListeners。
按照优先级<0 =0 >0的顺序，对每个监听器执行以下代码。fixedPriorityListeners通过getGt0Index()获取优先级大于0的监听器序号为分界点，进行分类。
if (l->isEnabled() && !l->isPaused() && l->isRegistered() && onEvent(l)) { shouldStopPropagation = true; break; }
这里调用了之前定义的匿名函数onEvent(listener)。
6. 匿名函数 onEvent(listener)
设置事件的_currentTarget为监听器关联的node，监听器执行回调函数_onEvent(event)对事件进行处理。
auto onEvent = [&event](EventListener* listener) -> bool{ event->setCurrentTarget(listener->getAssociatedNode()); listener->_onEvent(event); return event->isStopped(); };
7. 收尾处理 updateListeners(event)
删除所有待删除容器里的监听器。添加所有待添加容器里的监听器。删除Vector里isRegistered为false的监听器。删除_listenerMap中Vector为空的元素。