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 = ;
for (auto& listener : *fixedListeners)
{
if (listener->getFixedPriority() >= )
break;
++index;
} listeners->setGt0Index(index);
4.2 sortEventListenersOfSceneGraphPriority(listenerID, rootNode)
参数rootNode是当前运行的场景。
同上面的排序一样，显先获取容器。不同之处在于sceneGraphListeners容器里的监听器优先级都为0，排序需要按照node的顺序。
需要_nodePriorityIndex容器记录node的优先级。
_nodePriorityIndex = ;
_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 > )
{
Node* child = nullptr;
// visit children zOrder < 0
for( ; i < childrenCount; i++ )
{
child = children.at(i); if ( child && child->getLocalZOrder() < )
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为空的元素。