cocos2dx-3.0 ： EventDispatcher

http://blog.csdn.net/u012085988/article/details/16881387

1. <pre name="code" class="cpp"></pre><pre name="code" class="cpp"><pre name="code" class="cpp"><pre name="code" class="cpp"><pre name="code" class="cpp"><pre name="code" class="cpp"><pre name="code" class="cpp">.h  
2. #ifndef __CC_EVENT_DISPATCHER_H__  
3. #define __CC_EVENT_DISPATCHER_H__  
4.   
5. #include "CCPlatformMacros.h"  
6. #include "CCEventListener.h"  
7. #include "CCEvent.h"  
8.   
9. #include <functional>  
10. #include <string>  
11. #include <unordered_map>  
12. #include <list>  
13. #include <vector>  
14.   
15. NS_CC_BEGIN  
16.   
17. class Event;  
18. class EventTouch;  
19. class Node;  
20.   
21. /** 
22. 管理 event listener 服务以及事件分发 （event dispatching）. 
23.  
24. The EventListener list is managed in such a way that 
25. event listeners can be added and removed even 
26. from within an EventListener, while events are being 
27. dispatched. 
28. */  
29. class EventDispatcher : public Object  
30. {  
31. public:  
32.     /** 注册监听事件 （优先级 基于 Node绘制顺序 ） 
33.     *  在消息路由时，先处理优先级<0的，在处理优先级=0（按Node绘制顺序），最后处理优先级>0的 
34.     * @param listener 监听器 
35.     * @param node 监听的node 
36.     * @note fixedProprity必须是0 
37.     */  
38.     void addEventListenerWithSceneGraphPriority(EventListener* listener, Node* node);  
39.   
40.     /** 注册监听事件 （指定优先级） 
41.     *  @param listener The listener of a specified event. 
42.     *  @param fixedPriority The fixed priority of the listener. 
43.     *  @note A lower priority will be called before the ones that have a higher value. 
44.     *        0 priority is forbidden for fixed priority since it's used for scene graph based priority. 
45.     */  
46.     void addEventListenerWithFixedPriority(EventListener* listener, int fixedPriority);  
47.   
48.     /** 删除某一个监听器 
49.     *  @param listener The specified event listener which needs to be removed. 
50.     */  
51.     void removeEventListener(EventListener* listener);  
52.   
53.     /** 删除某一类监听器 */  
54.     void removeEventListeners(EventListener::Type listenerType);  
55.   
56.     /** Removes all custom listeners with the same event name */  
57.     void removeCustomEventListeners(const std::string& customEventName);  
58.   
59.     /** 删除所有监听器 */  
60.     void removeAllEventListeners();  
61.   
62.     /** 修改某监听器的优先级 */  
63.     void setPriority(EventListener* listener, int fixedPriority);  
64.   
65.     /** 设置事件分发器是否可用 */  
66.     void setEnabled(bool isEnabled);  
67.   
68.     /** Checks whether dispatching events is enabled */  
69.     bool isEnabled() const;  
70.   
71.     /** 分发事件 
72.     *  同时从dispatcher list 中删除标记为deletion的监听器 
73.     */  
74.     void dispatchEvent(Event* event);  
75.   
76.     /** Constructor of EventDispatcher */  
77.     EventDispatcher();  
78.     /** Destructor of EventDispatcher */  
79.     ~EventDispatcher();  
80.   
81. private:  
82.     friend class Node;  
83.   
84.     /** 将Node记为Dirty 
85.         即将Node加入_dirtyNodes*/  
86.     void setDirtyForNode(Node* node);  
87.   
88.     /** 跟node相关联的所有listener都暂停 */  
89.     void pauseTarget(Node* node);  
90.   
91.     /** 跟node相关联的所有listener都唤醒 */  
92.     void resumeTarget(Node* node);  
93.   
94.     /** 删除所有跟node相关联的listener */  
95.     void cleanTarget(Node* node);  
96.   
97.     /** 
98.     *  The vector to store event listeners with scene graph based priority and fixed priority. 
99.     */  
100.     class EventListenerVector  
101.     {  
102.     public:  
103.         EventListenerVector();  
104.         ~EventListenerVector();  
105.         size_t size() const;  
106.         bool empty() const;  
107.   
108.         void push_back(EventListener* item);  
109.         void clearSceneGraphListeners();  
110.         void clearFixedListeners();  
111.         void clear();  
112.   
113.         inline std::vector<EventListener*>* getFixedPriorityListeners() const { return _fixedListeners; };  
114.         inline std::vector<EventListener*>* getSceneGraphPriorityListeners() const { return _sceneGraphListeners; };  
115.         inline long getGt0Index() const { return _gt0Index; };  
116.         inline void setGt0Index(long index) { _gt0Index = index; };  
117.     private:  
118.         std::vector<EventListener*>* _fixedListeners;  
119.         std::vector<EventListener*>* _sceneGraphListeners;  
120.         long _gt0Index;  
121.     };  
122.   
123.     /** Adds event listener with item */  
124.     void addEventListener(EventListener* listener);  
125.   
126.     /** Gets event the listener list for the event listener type. */  
127.     EventListenerVector* getListeners(EventListener::ListenerID listenerID);  
128.   
129.     /** Update dirty flag */  
130.     void updateDirtyFlagForSceneGraph();  
131.   
132.     /** Removes all listeners with the same event listener ID */  
133.     void removeEventListenersForListenerID(EventListener::ListenerID listenerID);  
134.   
135.     /** 排序 */  
136.     void sortEventListeners(EventListener::ListenerID listenerID);  
137.   
138.     /** 根据node优先级排序 */  
139.     void sortEventListenersOfSceneGraphPriority(EventListener::ListenerID listenerID);  
140.   
141.     /** 根据优先级排序 */  
142.     void sortEventListenersOfFixedPriority(EventListener::ListenerID listenerID);  
143.   
144.     /** Updates all listeners 
145.     *  1) 删除所有标记为 deleted 的监听器. 
146.     *  2) 添加_toAddedListeners中的监听器. 
147.     */  
148.     void updateListeners(Event* event);  
149.   
150.     /** Touch event needs to be processed different with other events since it needs support ALL_AT_ONCE and ONE_BY_NONE mode. */  
151.     void dispatchTouchEvent(EventTouch* event);  
152.   
153.     /** Associates node with event listener */  
154.     void associateNodeAndEventListener(Node* node, EventListener* listener);  
155.   
156.     /** Dissociates node with event listener */  
157.     void dissociateNodeAndEventListener(Node* node, EventListener* listener);  
158.   
159.     /** Dispatches event to listeners with a specified listener type */  
160.     void dispatchEventToListeners(EventListenerVector* listeners, std::function<bool(EventListener*)> onEvent);  
161.   
162.     /// Priority dirty flag  
163.     enum class DirtyFlag  
164.     {  
165.         NONE = 0,  
166.         FIXED_PRITORY = 1 << 0,  
167.         SCENE_GRAPH_PRIORITY = 1 << 1,  
168.         ALL = FIXED_PRITORY | SCENE_GRAPH_PRIORITY  
169.     };  
170.   
171.     /** Sets the dirty flag for a specified listener ID */  
172.     void setDirty(EventListener::ListenerID listenerID, DirtyFlag flag);  
173.   
174.     /** 遍历场景，获取每个Node的绘制顺序； 
175.         此函数在sortEventListenersOfSceneGraphPriority之前调用 */  
176.     void visitTarget(Node* node);  
177.   
178. private:  
179.     /** map 存储所有监听器 map::key 监听器类型 */  
180.     std::unordered_map<EventListener::ListenerID, EventListenerVector*> _listeners;  
181.   
182.     /** map 存储一类监听器是否被污染。 
183.     即：按优先级分类，可以把所有监听器分为两类（Node， fixd priority）。 
184.     如果_listenner[type] 里的监听器全是Node priority， 则DirtyFlag为SCENE_GRAPH_PRIORITY； 
185.     若全为fixd priority 则为 FIXED_PRITORY；若两种都有， 则为ALL = FIXED_PRITORY | SCENE_GRAPH_PRIORITY  */  
186.     std::unordered_map<EventListener::ListenerID, DirtyFlag> _priorityDirtyFlagMap;  
187.   
188.     /** map 关联Node与监听器 */  
189.     std::unordered_map<Node*, std::vector<EventListener*>*> _nodeListenersMap;  
190.   
191.     /** 存储每个Node的优先级（即绘制顺序）； 
192.         在visitTarge中更新该值， 
193.         在sortEventListenersOfSceneGraphPriority中使用该值*/  
194.     std::unordered_map<Node*, int> _nodePriorityMap;  
195.   
196.     /** 如果注册监听器时正在dispathch event，则将该监听器加到_toAddedListeners中， 
197.         等dispatch完成后，在将其从_toAddedListeners中移到其他容器，*/  
198.     std::vector<EventListener*> _toAddedListeners;  
199.   
200.     /** 优先级发生改变的Node  
201.         此集合中的Node所对应的Listener所在的那个vector（_listeners[ID]）将会重排序*/  
202.     std::set<Node*> _dirtyNodes;  
203.   
204.     /** 判断是否正在dispatch */  
205.     int _inDispatch;  
206.   
207.     /** Whether to enable dispatching event */  
208.     bool _isEnabled;  
209.   
210.     int _nodePriorityIndex;  
211. };  
212.   
213.   
214. NS_CC_END  
215.   
216.   
217. #endif // __CC_EVENT_DISPATCHER_H__  
218.   
219. cpp  
220. #include "CCEventDispatcher.h"  
221. #include "CCEvent.h"  
222. #include "CCEventTouch.h"  
223. #include "CCEventCustom.h"  
224. #include "CCEventListenerTouch.h"  
225. #include "CCNode.h"  
226. #include "CCDirector.h"  
227.   
228. #include <algorithm>  
229.   
230.   
231. #define DUMP_LISTENER_ITEM_PRIORITY_INFO 0  
232.   
233. namespace  
234. {  
235.     /************************************************************************/  
236.     /* 用于自动处理count。 一般用于构造一个局部变量。与指针计数器原理相同。 
237.         构造时 +1， 
238.         析构时 -1. 
239.  
240.         若函数中有多处return，而每次renturn前都要处理某变量的值，则可以采用此机制优化代码； 
241.         此机制只需利用变量a构造一个局部变量， 无需在每次返回前再处理变量a。 
242.     */  
243.     class DispatchGuard  
244.     {  
245.     public:  
246.         DispatchGuard(int& count) :  
247.             _count(count)  
248.         {  
249.             ++_count;  
250.         }  
251.   
252.         ~DispatchGuard()  
253.         {  
254.             --_count;  
255.         }  
256.   
257.     private:  
258.         int& _count;  
259.     };  
260.   
261. }  
262.   
263. NS_CC_BEGIN  
264.   
265. // 根据Event 的type 确定EventListener的Type  
266. // 关于EventListener的ListenerId 与 EventListener的Type（注意这里不是Event：：Type）映射关系  
267. // 出自定制类型外，其他类型都是用枚举一一映射的，而自定制类型则是计算hash值  
268. static EventListener::ListenerID getListenerID(Event* event)  
269. {  
270.     EventListener::ListenerID ret;  
271.     switch (event->getType())  
272.     {  
273.     case Event::Type::ACCELERATION:  
274.         ret = static_cast<EventListener::ListenerID>(EventListener::Type::ACCELERATION);  
275.         break;  
276.     case Event::Type::CUSTOM:  
277.     {  
278.                                 auto customEvent = static_cast<EventCustom*>(event);  
279.                                 auto listenerID = std::hash<std::string>()(customEvent->getEventName());  
280.                                 ret = static_cast<EventListener::ListenerID>(listenerID);  
281.     }  
282.         break;  
283.     case Event::Type::KEYBOARD:  
284.         ret = static_cast<EventListener::ListenerID>(EventListener::Type::KEYBOARD);  
285.         break;  
286.     case Event::Type::MOUSE:  
287.         ret = static_cast<EventListener::ListenerID>(EventListener::Type::MOUSE);  
288.         break;  
289.     case Event::Type::TOUCH:  
290.         // Touch listener is very special, it contains two kinds of listeners, EventListenerTouchOneByOne and EventListenerTouchAllAtOnce.  
291.         // return UNKNOW instead.  
292.         ret = static_cast<EventListener::ListenerID>(EventListener::Type::UNKNOWN);  
293.         break;  
294.     default:  
295.         CCASSERT(false, "Invalid type!");  
296.         break;  
297.     }  
298.   
299.     return ret;  
300. }  
301.   
302. EventDispatcher::EventListenerVector::EventListenerVector()  
303. : _sceneGraphListeners(nullptr)  
304. , _fixedListeners(nullptr)  
305. , _gt0Index(0)  
306. {  
307. }  
308.   
309. EventDispatcher::EventListenerVector::~EventListenerVector()  
310. {  
311.     CC_SAFE_DELETE(_sceneGraphListeners);  
312.     CC_SAFE_DELETE(_fixedListeners);  
313. }  
314.   
315. size_t EventDispatcher::EventListenerVector::size() const  
316. {  
317.     size_t ret = 0;  
318.     if (_sceneGraphListeners)  
319.         ret += _sceneGraphListeners->size();  
320.     if (_fixedListeners)  
321.         ret += _fixedListeners->size();  
322.   
323.     return ret;  
324. }  
325.   
326. bool EventDispatcher::EventListenerVector::empty() const  
327. {  
328.     return (_sceneGraphListeners == nullptr || _sceneGraphListeners->empty())  
329.         && (_fixedListeners == nullptr || _fixedListeners->empty());  
330. }  
331.   
332. void EventDispatcher::EventListenerVector::push_back(EventListener* listener)  
333. {  
334.     if (listener->getFixedPriority() == 0)  
335.     {  
336.         if (_sceneGraphListeners == nullptr)  
337.         {  
338.             _sceneGraphListeners = new std::vector<EventListener*>();  
339.             _sceneGraphListeners->reserve(100);  
340.         }  
341.   
342.         _sceneGraphListeners->push_back(listener);  
343.     }  
344.     else  
345.     {  
346.         if (_fixedListeners == nullptr)  
347.         {  
348.             _fixedListeners = new std::vector<EventListener*>();  
349.             _fixedListeners->reserve(100);  
350.         }  
351.   
352.         _fixedListeners->push_back(listener);  
353.     }  
354. }  
355.   
356. void EventDispatcher::EventListenerVector::clearSceneGraphListeners()  
357. {  
358.     if (_sceneGraphListeners)  
359.     {  
360.         _sceneGraphListeners->clear();  
361.         delete _sceneGraphListeners;  
362.         _sceneGraphListeners = nullptr;  
363.     }  
364. }  
365.   
366. void EventDispatcher::EventListenerVector::clearFixedListeners()  
367. {  
368.     if (_fixedListeners)  
369.     {  
370.         _fixedListeners->clear();  
371.         delete _fixedListeners;  
372.         _fixedListeners = nullptr;  
373.     }  
374. }  
375.   
376. void EventDispatcher::EventListenerVector::clear()  
377. {  
378.     clearSceneGraphListeners();  
379.     clearFixedListeners();  
380. }  
381.   
382.   
383. EventDispatcher::EventDispatcher()  
384. : _inDispatch(0)  
385. , _isEnabled(true)  
386. , _nodePriorityIndex(0)  
387. {  
388.     _toAddedListeners.reserve(50);  
389. }  
390.   
391. EventDispatcher::~EventDispatcher()  
392. {  
393.     removeAllEventListeners();  
394. }  
395.   
396. void EventDispatcher::visitTarget(Node* node)  
397. {  
398.     int i = 0;  
399.     Array* children = node->getChildren();  
400.     int childrenCount = children ? children->count() : 0;  
401.   
402.     if (childrenCount > 0)  
403.     {  
404.   
405.         Node* child = nullptr;  
406.         // 只计算子节点中 zOrder < 0 的  
407.         for (; i < childrenCount; i++)  
408.         {  
409.             child = static_cast<Node*>(children->getObjectAtIndex(i));  
410.   
411.             if (child && child->getZOrder() < 0)  
412.                 visitTarget(child);  
413.             else  
414.                 break;  
415.         }  
416.   
417.         // 记录Node的优先级  
418.         _nodePriorityMap.insert(std::make_pair(node, ++_nodePriorityIndex));  
419.   
420.         for (; i < childrenCount; i++)  
421.         {  
422.             child = static_cast<Node*>(children->getObjectAtIndex(i));  
423.             if (child)  
424.                 visitTarget(child);  
425.         }  
426.     }  
427.     else  
428.     {  
429.         _nodePriorityMap.insert(std::make_pair(node, ++_nodePriorityIndex));  
430.     }  
431. }  
432.   
433. void EventDispatcher::pauseTarget(Node* node)  
434. {  
435.     auto listenerIter = _nodeListenersMap.find(node);  
436.     if (listenerIter != _nodeListenersMap.end())  
437.     {  
438.         auto listeners = listenerIter->second;  
439.         for (auto& l : *listeners)  
440.         {  
441.             l->setPaused(true);  
442.         }  
443.     }  
444. }  
445.   
446. void EventDispatcher::resumeTarget(Node* node)  
447. {  
448.     auto listenerIter = _nodeListenersMap.find(node);  
449.     if (listenerIter != _nodeListenersMap.end())  
450.     {  
451.         auto listeners = listenerIter->second;  
452.         for (auto& l : *listeners)  
453.         {  
454.             l->setPaused(false);  
455.         }  
456.     }  
457.     setDirtyForNode(node);  
458. }  
459.   
460. void EventDispatcher::cleanTarget(Node* node)  
461. {  
462.     auto listenerIter = _nodeListenersMap.find(node);  
463.     if (listenerIter != _nodeListenersMap.end())  
464.     {  
465.         auto listeners = listenerIter->second;  
466.         auto listenersCopy = *listeners;  
467.         for (auto& l : listenersCopy)  
468.         {  
469.             removeEventListener(l);  
470.         }  
471.     }  
472. }  
473.   
474. void EventDispatcher::associateNodeAndEventListener(Node* node, EventListener* listener)  
475. {  
476.     std::vector<EventListener*>* listeners = nullptr;  
477.     auto found = _nodeListenersMap.find(node);  
478.     if (found != _nodeListenersMap.end())  
479.     {  
480.         listeners = found->second;  
481.     }  
482.     else  
483.     {  
484.         listeners = new std::vector<EventListener*>();  
485.     }  
486.   
487.     listeners->push_back(listener);  
488.   
489.     _nodeListenersMap.insert(std::make_pair(node, listeners));  
490. }  
491.   
492. void EventDispatcher::dissociateNodeAndEventListener(Node* node, EventListener* listener)  
493. {  
494.     std::vector<EventListener*>* listeners = nullptr;  
495.     auto found = _nodeListenersMap.find(node);  
496.     if (found != _nodeListenersMap.end())  
497.     {  
498.         listeners = found->second;  
499.         auto iter = std::find(listeners->begin(), listeners->end(), listener);  
500.         if (iter != listeners->end())  
501.         {  
502.             listeners->erase(iter);  
503.         }  
504.   
505.         if (listeners->empty())  
506.         {  
507.             _nodeListenersMap.erase(found);  
508.             delete listeners;  
509.         }  
510.     }  
511. }  
512.   
513. void EventDispatcher::addEventListener(EventListener* listener)  
514. {  
515.     // 如果不是正在路由事件  
516.     if (_inDispatch == 0)  
517.     {  
518.         EventListenerVector* listenerList = nullptr;  
519.         // 根据listenerID获取相应vector  
520.         auto iter = _listeners.find(listener->getListenerID());  
521.         if (iter == _listeners.end())  
522.         {  
523.             listenerList = new EventListenerVector();  
524.             _listeners.insert(std::make_pair(listener->getListenerID(), listenerList));  
525.         }  
526.         else  
527.         {  
528.             listenerList = iter->second;  
529.         }  
530.           
531.         listenerList->push_back(listener);  
532.   
533.         if (listener->getFixedPriority() == 0)  
534.         {  
535.             // 如果优先级根据Node而定  
536.             setDirty(listener->getListenerID(), DirtyFlag::SCENE_GRAPH_PRIORITY);  
537.         }  
538.         else  
539.         {  
540.             // 如果优先级根据Fixed而定  
541.             setDirty(listener->getListenerID(), DirtyFlag::FIXED_PRITORY);  
542.         }  
543.     }  
544.     else  
545.     {  
546.         // 如果正在路由事件，则直接加入_toAddedListeners  
547.         _toAddedListeners.push_back(listener);  
548.     }  
549. }  
550.   
551. void EventDispatcher::addEventListenerWithSceneGraphPriority(EventListener* listener, Node* node)  
552. {  
553.     CCASSERT(listener && node, "Invalid parameters.");  
554.     CCASSERT(!listener->isRegistered(), "The listener has been registered.");  
555.   
556.     if (!listener->checkAvailable())  
557.         return;  
558.   
559.     listener->setSceneGraphPriority(node);  
560.     listener->setFixedPriority(0);  
561.     listener->setRegistered(true);  
562.   
563.     listener->retain();  
564.     // 存储listener，  
565.     addEventListener(listener);       
566.   
567.     // 关联node与listener  
568.     associateNodeAndEventListener(node, listener);  
569.   
570.     if (node->isRunning())  
571.     {  
572.         resumeTarget(node);  
573.     }  
574. }  
575.   
576. void EventDispatcher::addEventListenerWithFixedPriority(EventListener* listener, int fixedPriority)  
577. {  
578.     CCASSERT(listener, "Invalid parameters.");  
579.     CCASSERT(!listener->isRegistered(), "The listener has been registered.");  
580.     CCASSERT(fixedPriority != 0, "0 priority is forbidden for fixed priority since it's used for scene graph based priority.");  
581.   
582.     if (!listener->checkAvailable())  
583.         return;  
584.   
585.     listener->setSceneGraphPriority(nullptr);  
586.     listener->setFixedPriority(fixedPriority);  
587.     listener->setRegistered(true);  
588.     listener->setPaused(false);  
589.   
590.     listener->retain();  
591.   
592.     addEventListener(listener);  
593. }  
594.   
595. void EventDispatcher::removeEventListener(EventListener* listener)  
596. {  
597.     if (listener == nullptr)  
598.         return;  
599.   
600.     bool isFound = false;  
601.   
602.     auto removeListenerInVector = [&](std::vector<EventListener*>* listeners){  
603.         if (listeners == nullptr)  
604.             return;  
605.   
606.         for (auto iter = listeners->begin(); iter != listeners->end(); ++iter)  
607.         {  
608.             auto l = *iter;  
609.             if (l == listener)  
610.             {  
611.                 CC_SAFE_RETAIN(l);  
612.                 l->setRegistered(false);  
613.                 if (l->getSceneGraphPriority() != nullptr)  
614.                 {  
615.                     // 撤销node与listener的关联  
616.                     dissociateNodeAndEventListener(l->getSceneGraphPriority(), l);  
617.                 }  
618.   
619.                 if (_inDispatch == 0)  
620.                 {  
621.                     listeners->erase(iter);  
622.                     CC_SAFE_RELEASE(l);  
623.                 }  
624.   
625.                 isFound = true;  
626.                 break;  
627.             }  
628.         }  
629.     };  
630.   
631.     for (auto iter = _listeners.begin(); iter != _listeners.end();)  
632.     {  
633.         auto listeners = iter->second;  
634.         auto fixedPriorityListeners = listeners->getFixedPriorityListeners();  
635.         auto sceneGraphPriorityListeners = listeners->getSceneGraphPriorityListeners();  
636.   
637.         removeListenerInVector(sceneGraphPriorityListeners);  
638.         if (!isFound)  
639.         {  
640.             removeListenerInVector(fixedPriorityListeners);  
641.         }  
642.   
643.         if (iter->second->empty())  
644.         {  
645.             _priorityDirtyFlagMap.erase(listener->getListenerID());  
646.             auto list = iter->second;  
647.             iter = _listeners.erase(iter);  
648.             CC_SAFE_DELETE(list);  
649.         }  
650.         else  
651.         {  
652.             ++iter;  
653.         }  
654.   
655.         if (isFound)  
656.             break;  
657.     }  
658.   
659.     if (isFound)  
660.     {  
661.         CC_SAFE_RELEASE(listener);  
662.     }  
663.     else  
664.     {  
665.         // 若没有找到，则在_toAddedListeners中找  
666.         for (auto iter = _toAddedListeners.begin(); iter != _toAddedListeners.end(); ++iter)  
667.         {  
668.             if (*iter == listener)  
669.             {  
670.                 _toAddedListeners.erase(iter);  
671.                 break;  
672.             }  
673.         }  
674.     }  
675. }  
676.   
677. void EventDispatcher::setPriority(EventListener* listener, int fixedPriority)  
678. {  
679.     if (listener == nullptr)  
680.         return;  
681.   
682.     for (auto iter = _listeners.begin(); iter != _listeners.end(); ++iter)  
683.     {  
684.         auto fixedPriorityListeners = iter->second->getFixedPriorityListeners();  
685.         if (fixedPriorityListeners)  
686.         {  
687.             auto found = std::find(fixedPriorityListeners->begin(), fixedPriorityListeners->end(), listener);  
688.             if (found != fixedPriorityListeners->end())  
689.             {  
690.                 CCASSERT(listener->getSceneGraphPriority() == nullptr, "Can't set fixed priority with scene graph based listener.");  
691.   
692.                 if (listener->getFixedPriority() != fixedPriority)  
693.                 {  
694.                     listener->setFixedPriority(fixedPriority);  
695.                     setDirty(listener->getListenerID(), DirtyFlag::FIXED_PRITORY);  
696.                 }  
697.                 return;  
698.             }  
699.         }  
700.     }  
701. }  
702.   
703. void EventDispatcher::dispatchEventToListeners(EventListenerVector* listeners, std::function<bool(EventListener*)> onEvent)  
704. {  
705.     bool shouldStopPropagation = false;  
706.     auto fixedPriorityListeners = listeners->getFixedPriorityListeners();  
707.     auto sceneGraphPriorityListeners = listeners->getSceneGraphPriorityListeners();  
708.   
709.     long i = 0;  
710.     // priority < 0  
711.     if (fixedPriorityListeners)  
712.     {  
713.         for (; !fixedPriorityListeners->empty() && i < listeners->getGt0Index(); ++i)  
714.         {  
715.             auto l = fixedPriorityListeners->at(i);  
716.             if (!l->isPaused() && l->isRegistered() && onEvent(l))  
717.             {  
718.                 shouldStopPropagation = true;  
719.                 break;  
720.             }  
721.         }  
722.     }  
723.   
724.     if (sceneGraphPriorityListeners)  
725.     {  
726.         if (!shouldStopPropagation)  
727.         {  
728.             // priority == 0, scene graph priority  
729.             for (auto& l : *sceneGraphPriorityListeners)  
730.             {  
731.                 if (!l->isPaused() && l->isRegistered() && onEvent(l))  
732.                 {  
733.                     shouldStopPropagation = true;  
734.                     break;  
735.                 }  
736.             }  
737.         }  
738.     }  
739.   
740.     if (fixedPriorityListeners)  
741.     {  
742.         if (!shouldStopPropagation)  
743.         {  
744.             // priority > 0  
745.             for (; i < static_cast<long>(fixedPriorityListeners->size()); ++i)  
746.             {  
747.                 auto l = fixedPriorityListeners->at(i);  
748.   
749.                 if (!l->isPaused() && l->isRegistered() && onEvent(fixedPriorityListeners->at(i)))  
750.                 {  
751.                     shouldStopPropagation = true;  
752.                     break;  
753.                 }  
754.             }  
755.         }  
756.     }  
757. }  
758.   
759. void EventDispatcher::dispatchEvent(Event* event)  
760. {  
761.     if (!_isEnabled)  
762.         return;  
763.   
764.     updateDirtyFlagForSceneGraph();  
765.   
766.   
767.     DispatchGuard guard(_inDispatch);  
768.   
769.     if (event->getType() == Event::Type::TOUCH)  
770.     {  
771.         dispatchTouchEvent(static_cast<EventTouch*>(event));  
772.         return;  
773.     }  
774.   
775.     auto listenerID = getListenerID(event);  
776.   
777.     sortEventListeners(listenerID);  
778.   
779.     auto iter = _listeners.find(listenerID);  
780.     if (iter != _listeners.end())  
781.     {  
782.         auto listeners = iter->second;  
783.   
784.         auto onEvent = [&event](EventListener* listener) -> bool{  
785.             event->setCurrentTarget(listener->getSceneGraphPriority());  
786.             listener->_onEvent(event);  
787.             return event->isStopped();  
788.         };  
789.   
790.         dispatchEventToListeners(listeners, onEvent);  
791.     }  
792.   
793.     updateListeners(event);  
794. }  
795.   
796. void EventDispatcher::dispatchTouchEvent(EventTouch* event)  
797. {  
798.     auto touchOneByOneID = static_cast<EventListener::ListenerID>(EventListener::Type::TOUCH_ONE_BY_ONE);  
799.     auto touchAllAtOnceID = static_cast<EventListener::ListenerID>(EventListener::Type::TOUCH_ALL_AT_ONCE);  
800.   
801.     sortEventListeners(touchOneByOneID);  
802.     sortEventListeners(touchAllAtOnceID);  
803.   
804.     auto oneByOnelisteners = getListeners(touchOneByOneID);  
805.     auto allAtOncelisteners = getListeners(touchAllAtOnceID);  
806.   
807.     // If there aren't any touch listeners, return directly.  
808.     if (nullptr == oneByOnelisteners && nullptr == allAtOncelisteners)  
809.         return;  
810.   
811.     bool isNeedsMutableSet = (oneByOnelisteners && allAtOncelisteners);  
812.   
813.     std::vector<Touch*> orignalTouches = event->getTouches();  
814.     std::vector<Touch*> mutableTouches(orignalTouches.size());  
815.     std::copy(orignalTouches.begin(), orignalTouches.end(), mutableTouches.begin());  
816.   
817.     //  
818.     // process the target handlers 1st  
819.     //  
820.     if (oneByOnelisteners)  
821.     {  
822.         auto mutableTouchesIter = mutableTouches.begin();  
823.         auto touchesIter = orignalTouches.begin();  
824.   
825.         for (; touchesIter != orignalTouches.end(); ++touchesIter)  
826.         {  
827.             bool isSwallowed = false;  
828.   
829.             auto onTouchEvent = [&](EventListener* l) -> bool { // Return true to break  
830.                 EventListenerTouchOneByOne* listener = static_cast<EventListenerTouchOneByOne*>(l);  
831.   
832.                 // Skip if the listener was removed.  
833.                 if (!listener->_isRegistered)  
834.                     return false;  
835.   
836.                 event->setCurrentTarget(listener->_node);  
837.   
838.                 bool isClaimed = false;  
839.                 std::vector<Touch*>::iterator removedIter;  
840.   
841.                 EventTouch::EventCode eventCode = event->getEventCode();  
842.   
843.                 if (eventCode == EventTouch::EventCode::BEGAN)  
844.                 {  
845.                     if (listener->onTouchBegan)  
846.                     {  
847.                         isClaimed = listener->onTouchBegan(*touchesIter, event);  
848.                         if (isClaimed && listener->_isRegistered)  
849.                         {  
850.                             listener->_claimedTouches.push_back(*touchesIter);  
851.                         }  
852.                     }  
853.                 }  
854.                 else if (listener->_claimedTouches.size() > 0  
855.                     && ((removedIter = std::find(listener->_claimedTouches.begin(), listener->_claimedTouches.end(), *touchesIter)) != listener->_claimedTouches.end()))  
856.                 {  
857.                     isClaimed = true;  
858.   
859.                     switch (eventCode)  
860.                     {  
861.                     case EventTouch::EventCode::MOVED:  
862.                         if (listener->onTouchMoved)  
863.                         {  
864.                             listener->onTouchMoved(*touchesIter, event);  
865.                         }  
866.                         break;  
867.                     case EventTouch::EventCode::ENDED:  
868.                         if (listener->onTouchEnded)  
869.                         {  
870.                             listener->onTouchEnded(*touchesIter, event);  
871.                         }  
872.                         if (listener->_isRegistered)  
873.                         {  
874.                             listener->_claimedTouches.erase(removedIter);  
875.                         }  
876.                         break;  
877.                     case EventTouch::EventCode::CANCELLED:  
878.                         if (listener->onTouchCancelled)  
879.                         {  
880.                             listener->onTouchCancelled(*touchesIter, event);  
881.                         }  
882.                         if (listener->_isRegistered)  
883.                         {  
884.                             listener->_claimedTouches.erase(removedIter);  
885.                         }  
886.                         break;  
887.                     default:  
888.                         CCASSERT(false, "The eventcode is invalid.");  
889.                         break;  
890.                     }  
891.                 }  
892.   
893.                 // If the event was stopped, return directly.  
894.                 if (event->isStopped())  
895.                 {  
896.                     updateListeners(event);  
897.                     return true;  
898.                 }  
899.   
900.                 CCASSERT((*touchesIter)->getID() == (*mutableTouchesIter)->getID(), "");  
901.   
902.                 if (isClaimed && listener->_isRegistered && listener->_needSwallow)  
903.                 {  
904.                     if (isNeedsMutableSet)  
905.                     {  
906.                         mutableTouchesIter = mutableTouches.erase(mutableTouchesIter);  
907.                         isSwallowed = true;  
908.                     }  
909.                     return true;  
910.                 }  
911.   
912.                 return false;  
913.             };  
914.   
915.             //  
916.             dispatchEventToListeners(oneByOnelisteners, onTouchEvent);  
917.             if (event->isStopped())  
918.             {  
919.                 return;  
920.             }  
921.   
922.             if (!isSwallowed)  
923.                 ++mutableTouchesIter;  
924.         }  
925.     }  
926.   
927.     //  
928.     // process standard handlers 2nd  
929.     //  
930.     if (allAtOncelisteners && mutableTouches.size() > 0)  
931.     {  
932.   
933.         auto onTouchesEvent = [&](EventListener* l) -> bool{  
934.             EventListenerTouchAllAtOnce* listener = static_cast<EventListenerTouchAllAtOnce*>(l);  
935.             // Skip if the listener was removed.  
936.             if (!listener->_isRegistered)  
937.                 return false;  
938.   
939.             event->setCurrentTarget(listener->_node);  
940.   
941.             switch (event->getEventCode())  
942.             {  
943.             case EventTouch::EventCode::BEGAN:  
944.                 if (listener->onTouchesBegan)  
945.                 {  
946.                     listener->onTouchesBegan(mutableTouches, event);  
947.                 }  
948.                 break;  
949.             case EventTouch::EventCode::MOVED:  
950.                 if (listener->onTouchesMoved)  
951.                 {  
952.                     listener->onTouchesMoved(mutableTouches, event);  
953.                 }  
954.                 break;  
955.             case EventTouch::EventCode::ENDED:  
956.                 if (listener->onTouchesEnded)  
957.                 {  
958.                     listener->onTouchesEnded(mutableTouches, event);  
959.                 }  
960.                 break;  
961.             case EventTouch::EventCode::CANCELLED:  
962.                 if (listener->onTouchesCancelled)  
963.                 {  
964.                     listener->onTouchesCancelled(mutableTouches, event);  
965.                 }  
966.                 break;  
967.             default:  
968.                 CCASSERT(false, "The eventcode is invalid.");  
969.                 break;  
970.             }  
971.   
972.             // If the event was stopped, return directly.  
973.             if (event->isStopped())  
974.             {  
975.                 updateListeners(event);  
976.                 return false;  
977.             }  
978.   
979.             return false;  
980.         };  
981.   
982.         dispatchEventToListeners(allAtOncelisteners, onTouchesEvent);  
983.         if (event->isStopped())  
984.         {  
985.             return;  
986.         }  
987.     }  
988.   
989.     updateListeners(event);  
990. }  
991.   
992. void EventDispatcher::updateListeners(Event* event)  
993. {  
994.     auto onUpdateListeners = [this](EventListener::ListenerID listenerID)  
995.     {  
996.         auto listenersIter = _listeners.find(listenerID);  
997.         if (listenersIter == _listeners.end())  
998.             return;  
999.   
1000.         auto listeners = listenersIter->second;  
1001.         auto fixedPriorityListeners = listeners->getFixedPriorityListeners();  
1002.         auto sceneGraphPriorityListeners = listeners->getSceneGraphPriorityListeners();  
1003.   
1004.         if (sceneGraphPriorityListeners)  
1005.         {  
1006.             for (auto iter = sceneGraphPriorityListeners->begin(); iter != sceneGraphPriorityListeners->end();)  
1007.             {  
1008.                 auto l = *iter;  
1009.                 if (!l->isRegistered())  
1010.                 {  
1011.                     iter = sceneGraphPriorityListeners->erase(iter);  
1012.                     l->release();  
1013.                 }  
1014.                 else  
1015.                 {  
1016.                     ++iter;  
1017.                 }  
1018.             }  
1019.         }  
1020.   
1021.         if (fixedPriorityListeners)  
1022.         {  
1023.             for (auto iter = fixedPriorityListeners->begin(); iter != fixedPriorityListeners->end();)  
1024.             {  
1025.                 auto l = *iter;  
1026.                 if (!l->isRegistered())  
1027.                 {  
1028.                     iter = fixedPriorityListeners->erase(iter);  
1029.                     l->release();  
1030.                 }  
1031.                 else  
1032.                 {  
1033.                     ++iter;  
1034.                 }  
1035.             }  
1036.         }  
1037.   
1038.         if (sceneGraphPriorityListeners && sceneGraphPriorityListeners->empty())  
1039.         {  
1040.             listeners->clearSceneGraphListeners();  
1041.         }  
1042.   
1043.         if (fixedPriorityListeners && fixedPriorityListeners->empty())  
1044.         {  
1045.             listeners->clearFixedListeners();  
1046.         }  
1047.   
1048.         if (listenersIter->second->empty())  
1049.         {  
1050.             _priorityDirtyFlagMap.erase(listenersIter->first);  
1051.             delete listenersIter->second;  
1052.             listenersIter = _listeners.erase(listenersIter);  
1053.         }  
1054.         else  
1055.         {  
1056.             ++listenersIter;  
1057.         }  
1058.     };  
1059.   
1060.     if (event->getType() == Event::Type::TOUCH)  
1061.     {  
1062.         onUpdateListeners(static_cast<EventListener::ListenerID>(EventListener::Type::TOUCH_ONE_BY_ONE));  
1063.         onUpdateListeners(static_cast<EventListener::ListenerID>(EventListener::Type::TOUCH_ALL_AT_ONCE));  
1064.     }  
1065.     else  
1066.     {  
1067.         onUpdateListeners(getListenerID(event));  
1068.     }  
1069.   
1070.   
1071.     if (!_toAddedListeners.empty())  
1072.     {  
1073.         EventListenerVector* listeners = nullptr;  
1074.   
1075.         for (auto& listener : _toAddedListeners)  
1076.         {  
1077.             EventListener::ListenerID listenerID = listener->getListenerID();  
1078.             auto itr = _listeners.find(listenerID);  
1079.             if (itr == _listeners.end())  
1080.             {  
1081.   
1082.                 listeners = new EventListenerVector();  
1083.                 _listeners.insert(std::make_pair(listenerID, listeners));  
1084.             }  
1085.             else  
1086.             {  
1087.                 listeners = itr->second;  
1088.             }  
1089.   
1090.             listeners->push_back(listener);  
1091.   
1092.             if (listener->getFixedPriority() == 0)  
1093.             {  
1094.                 setDirty(listenerID, DirtyFlag::SCENE_GRAPH_PRIORITY);  
1095.             }  
1096.             else  
1097.             {  
1098.                 setDirty(listenerID, DirtyFlag::FIXED_PRITORY);  
1099.             }  
1100.         }  
1101.         _toAddedListeners.clear();  
1102.     }  
1103. }  
1104.   
1105. void EventDispatcher::updateDirtyFlagForSceneGraph()  
1106. {  
1107.     if (!_dirtyNodes.empty())  
1108.     {  
1109.         for (auto& node : _dirtyNodes)  
1110.         {  
1111.             auto iter = _nodeListenersMap.find(node);  
1112.             if (iter != _nodeListenersMap.end())  
1113.             {  
1114.                 for (auto& l : *iter->second)  
1115.                 {  
1116.                     setDirty(l->getListenerID(), DirtyFlag::SCENE_GRAPH_PRIORITY);  
1117.                 }  
1118.             }  
1119.         }  
1120.   
1121.         _dirtyNodes.clear();  
1122.     }  
1123. }  
1124.   
1125. void EventDispatcher::sortEventListeners(EventListener::ListenerID listenerID)  
1126. {  
1127.     DirtyFlag dirtyFlag = DirtyFlag::NONE;  
1128.   
1129.     auto dirtyIter = _priorityDirtyFlagMap.find(listenerID);  
1130.     if (dirtyIter != _priorityDirtyFlagMap.end())  
1131.     {  
1132.         dirtyFlag = dirtyIter->second;  
1133.     }  
1134.   
1135.     if (dirtyFlag != DirtyFlag::NONE)  
1136.     {  
1137.         if ((int)dirtyFlag & (int)DirtyFlag::FIXED_PRITORY)  
1138.         {  
1139.             sortEventListenersOfFixedPriority(listenerID);  
1140.         }  
1141.   
1142.         if ((int)dirtyFlag & (int)DirtyFlag::SCENE_GRAPH_PRIORITY)  
1143.         {  
1144.             sortEventListenersOfSceneGraphPriority(listenerID);  
1145.         }  
1146.   
1147.         dirtyIter->second = DirtyFlag::NONE;  
1148.     }  
1149. }  
1150.   
1151. void EventDispatcher::sortEventListenersOfSceneGraphPriority(EventListener::ListenerID listenerID)  
1152. {  
1153.     auto listeners = getListeners(listenerID);  
1154.   
1155.     if (listeners == nullptr)  
1156.         return;  
1157.   
1158.     Node* rootNode = (Node*)Director::getInstance()->getRunningScene();  
1159.     // Reset priority index  
1160.     _nodePriorityIndex = 0;  
1161.     _nodePriorityMap.clear();  
1162.   
1163.     visitTarget(rootNode);  
1164.   
1165.     // After sort: priority < 0, > 0  
1166.     auto sceneGraphlisteners = listeners->getSceneGraphPriorityListeners();  
1167.     std::sort(sceneGraphlisteners->begin(), sceneGraphlisteners->end(), [this](const EventListener* l1, const EventListener* l2) {  
1168.         return _nodePriorityMap[l1->getSceneGraphPriority()] > _nodePriorityMap[l2->getSceneGraphPriority()];  
1169.     });  
1170.   
1171. #if DUMP_LISTENER_ITEM_PRIORITY_INFO  
1172.     log("-----------------------------------");  
1173.     for (auto& l : *sceneGraphlisteners)  
1174.     {  
1175.         log("listener priority: node ([%s]%p), priority (%d)", typeid(*l->_node).name(), l->_node, _nodePriorityMap[l->_node]);  
1176.     }  
1177. #endif  
1178. }  
1179.   
1180. void EventDispatcher::sortEventListenersOfFixedPriority(EventListener::ListenerID listenerID)  
1181. {  
1182.     auto listeners = getListeners(listenerID);  
1183.   
1184.     if (listeners == nullptr)  
1185.         return;  
1186.   
1187.     // After sort: priority < 0, > 0  
1188.     auto fixedlisteners = listeners->getFixedPriorityListeners();  
1189.     std::sort(fixedlisteners->begin(), fixedlisteners->end(), [](const EventListener* l1, const EventListener* l2) {  
1190.         return l1->getFixedPriority() < l2->getFixedPriority();  
1191.     });  
1192.   
1193.     // FIXME: Should use binary search  
1194.     long index = 0;  
1195.     for (auto& listener : *fixedlisteners)  
1196.     {  
1197.         if (listener->getFixedPriority() >= 0)  
1198.             break;  
1199.         ++index;  
1200.     }  
1201.   
1202.     listeners->setGt0Index(index);  
1203.   
1204. #if DUMP_LISTENER_ITEM_PRIORITY_INFO  
1205.     log("-----------------------------------");  
1206.     for (auto& l : *fixedlisteners)  
1207.     {  
1208.         log("listener priority: node (%p), fixed (%d)", l->_node, l->_fixedPriority);  
1209.     }  
1210. #endif  
1211.   
1212. }  
1213.   
1214. EventDispatcher::EventListenerVector* EventDispatcher::getListeners(EventListener::ListenerID listenerID)  
1215. {  
1216.     auto iter = _listeners.find(listenerID);  
1217.     if (iter != _listeners.end())  
1218.     {  
1219.         return iter->second;  
1220.     }  
1221.   
1222.     return nullptr;  
1223. }  
1224.   
1225. void EventDispatcher::removeEventListenersForListenerID(EventListener::ListenerID listenerID)  
1226. {  
1227.     auto listenerItemIter = _listeners.find(listenerID);  
1228.     if (listenerItemIter != _listeners.end())  
1229.     {  
1230.         auto listeners = listenerItemIter->second;  
1231.         auto fixedPriorityListeners = listeners->getFixedPriorityListeners();  
1232.         auto sceneGraphPriorityListeners = listeners->getSceneGraphPriorityListeners();  
1233.   
1234.         auto removeAllListenersInVector = [&](std::vector<EventListener*>* listenerVector){  
1235.             if (listenerVector == nullptr)  
1236.                 return;  
1237.   
1238.             for (auto iter = listenerVector->begin(); iter != listenerVector->end();)  
1239.             {  
1240.                 auto l = *iter;  
1241.                 l->setRegistered(false);  
1242.                 if (l->getSceneGraphPriority() != nullptr)  
1243.                 {  
1244.                     dissociateNodeAndEventListener(l->getSceneGraphPriority(), l);  
1245.                 }  
1246.   
1247.                 if (_inDispatch == 0)  
1248.                 {  
1249.                     iter = listenerVector->erase(iter);  
1250.                     CC_SAFE_RELEASE(l);  
1251.                 }  
1252.                 else  
1253.                 {  
1254.                     ++iter;  
1255.                 }  
1256.             }  
1257.         };  
1258.   
1259.         removeAllListenersInVector(sceneGraphPriorityListeners);  
1260.         removeAllListenersInVector(fixedPriorityListeners);  
1261.   
1262.         if (!_inDispatch)  
1263.         {  
1264.             listeners->clear();  
1265.             delete listeners;  
1266.             _listeners.erase(listenerItemIter);  
1267.             _priorityDirtyFlagMap.erase(listenerID);  
1268.         }  
1269.     }  
1270.   
1271.     for (auto iter = _toAddedListeners.begin(); iter != _toAddedListeners.end();)  
1272.     {  
1273.         if ((*iter)->getListenerID() == listenerID)  
1274.         {  
1275.             iter = _toAddedListeners.erase(iter);  
1276.         }  
1277.         else  
1278.         {  
1279.             ++iter;  
1280.         }  
1281.     }  
1282. }  
1283.   
1284. void EventDispatcher::removeEventListeners(EventListener::Type listenerType)  
1285. {  
1286.     CCASSERT(listenerType != EventListener::Type::CUSTOM, "Not support custom event listener type, please use EventDispatcher::removeCustomEventListeners instead.");  
1287.   
1288.     removeEventListenersForListenerID(static_cast<EventListener::ListenerID>(listenerType));  
1289. }  
1290.   
1291. void EventDispatcher::removeCustomEventListeners(const std::string& customEventName)  
1292. {  
1293.     removeEventListenersForListenerID(std::hash<std::string>()(customEventName));  
1294. }  
1295.   
1296. void EventDispatcher::removeAllEventListeners()  
1297. {  
1298.     std::vector<int> types(_listeners.size());  
1299.   
1300.     for (auto iter = _listeners.begin(); iter != _listeners.end(); ++iter)  
1301.     {  
1302.         types.push_back(iter->first);  
1303.     }  
1304.   
1305.     for (auto& type : types)  
1306.     {  
1307.         removeEventListenersForListenerID(type);  
1308.     }  
1309.   
1310.     if (!_inDispatch)  
1311.     {  
1312.         _listeners.clear();  
1313.     }  
1314. }  
1315.   
1316. void EventDispatcher::setEnabled(bool isEnabled)  
1317. {  
1318.     _isEnabled = isEnabled;  
1319. }  
1320.   
1321.   
1322. bool EventDispatcher::isEnabled() const  
1323. {  
1324.     return _isEnabled;  
1325. }  
1326.   
1327. void EventDispatcher::setDirtyForNode(Node* node)  
1328. {  
1329.     // Mark the node dirty only when there was an eventlistener associates with it.   
1330.     if (_nodeListenersMap.find(node) != _nodeListenersMap.end())  
1331.     {  
1332.         _dirtyNodes.insert(node);  
1333.     }  
1334. }  
1335.   
1336. void EventDispatcher::setDirty(EventListener::ListenerID listenerID, DirtyFlag flag)  
1337. {  
1338.     auto iter = _priorityDirtyFlagMap.find(listenerID);  
1339.     if (iter == _priorityDirtyFlagMap.end())  
1340.     {  
1341.         _priorityDirtyFlagMap.insert(std::make_pair(listenerID, flag));  
1342.     }  
1343.     else  
1344.     {  
1345.         int ret = (int)flag | (int)iter->second;  
1346.         iter->second = (DirtyFlag)ret;  
1347.     }  
1348. }  
1349.   
1350. NS_CC_END  
1351. </pre><br>  
1352. <br>  
1353. <pre></pre>  
1354. <pre></pre>  
1355. <pre></pre>  
1356. <pre></pre>  
1357. <pre></pre>  
1358. <pre></pre>  
1359. <pre></pre>  
1360. <pre></pre>  
1361. <pre></pre>  
1362. <pre></pre>  
1363. <pre></pre>  
1364. <pre></pre>  
1365. <pre></pre>  
1366. <pre></pre>  
1367. <pre></pre>  
1368. <pre></pre>  
1369. <pre></pre>  
1370. <pre></pre>  
1371. <pre></pre>  
1372. <pre></pre>  
1373. <pre></pre>  
1374. <pre></pre>  
1375. </pre></pre></pre></pre></pre>