Cocos2d-x 学习笔记(15.2) EventDispatcher 事件分发机制 dispatchEvent(event)

来源：cnblogs　　作者：深潮　　时间：2019/8/5 9:39:41　　对本文有异议

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