cocos2dx-3.0 ： EventDispatcher

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

1. <prename="code"class="cpp"></pre><prename="code"class="cpp"><prename="code"class="cpp">.h
2. #ifndef__CC_EVENT_disPATCHER_H__
3. #define__CC_EVENT_disPATCHER_H__
5. #include"CCPlatformMacros.h"
6. #include"CCEventListener.h"
7. #include"CCEvent.h"
8. #include<functional>
9. #include<string>
10. #include<unordered_map>
11. #include<list>
12. #include<vector>
13. NS_CC_BEGIN
14. classEvent;
15. classEventTouch;
16. classNode;
17. /**
18. 管理eventlistener服务以及事件分发（eventdispatching）.
20. TheEventListenerlistismanagedinsuchawaythat
21. eventlistenerscanbeaddedandremovedeven
22. fromwithinanEventListener,whileeventsarebeing
23. dispatched.
24. */
25. classEventdispatcher:publicObject
26. {
27. public:
28. /**注册监听事件（优先级基于Node绘制顺序）
29. *在消息路由时，先处理优先级<0的，在处理优先级=0（按Node绘制顺序），最后处理优先级>0的
30. *@paramlistener监听器
31. *@paramnode监听的node
32. *@notefixedProprity必须是0
33. */
34. voidaddEventListenerWithSceneGraPHPriority(EventListener*listener,Node*node);
36. /**注册监听事件（指定优先级）
37. *@paramlistenerThelistenerofaspecifiedevent.
38. *@paramfixedPriorityThefixedpriorityofthelistener.
39. *@notealowerprioritywillbecalledbeforetheonesthathaveahighervalue.
40. *0priorityisforbiddenforfixedprioritysinceit'susedforscenegraphbasedpriority.
41. voidaddEventListenerWithFixedPriority(EventListener*listener,intfixedPriority);
42. /**删除某一个监听器
43. *@paramlistenerThespecifiedeventlistenerwhichneedstoberemoved.
44. voidremoveEventListener(EventListener*listener);
45. /**删除某一类监听器*/
46. voidremoveEventListeners(EventListener::TypelistenerType);
47. /**Removesallcustomlistenerswiththesameeventname*/
48. voidremoveCustomEventListeners(conststd::string&customEventName);
49. /**删除所有监听器*/
50. voidremoveAllEventListeners();
51. /**修改某监听器的优先级*/
52. voidsetPriority(EventListener*listener,87); background-color:inherit; font-weight:bold">intfixedPriority);
53. /**设置事件分发器是否可用*/
54. voidsetEnabled(boolisEnabled);
55. /**Checkswhetherdispatchingeventsisenabled*/
56. boolisEnabled()const;
57. /**分发事件
58. *同时从dispatcherlist中删除标记为deletion的监听器
59. voiddispatchEvent(Event*event);
60. /**ConstructorofEventdispatcher*/
61. Eventdispatcher();
62. /**DestructorofEventdispatcher*/
63. ~Eventdispatcher();
64. private:
65. friendclassNode;
66. /**将Node记为Dirty
67. 即将Node加入_dirtyNodes*/
68. voidsetDirtyForNode(Node*node);
69. /**跟node相关联的所有listener都暂停*/
70. voidpauseTarget(Node*node);
71. /**跟node相关联的所有listener都唤醒*/
72. voidresuMetarget(Node*node);
73. /**删除所有跟node相关联的listener*/
74. voidcleanTarget(Node*node);
75. *Thevectortostoreeventlistenerswithscenegraphbasedpriorityandfixedpriority.
76. classEventListenerVector
77. {
78. public:
79. EventListenerVector();
80. ~EventListenerVector();
81. size_tsize() boolempty()const;
82. voidpush_back(EventListener*item);
83. voidclearSceneGraphListeners();
84. voidclearFixedListeners();
85. voidclear();
86. inlinestd::vector<EventListener*>*getFixedPriorityListeners()const{return_fixedListeners;};
87. inlinestd::vector<EventListener*>*getSceneGraPHPriorityListeners()return_sceneGraphListeners;};
88. inlinelonggetGt0Index()return_gt0Index;};
89. inlinevoidsetGt0Index(longindex){_gt0Index=index;};
90. std::vector<EventListener*>*_fixedListeners;
91. std::vector<EventListener*>*_sceneGraphListeners;
92. long_gt0Index;
93. };
94. /**Addseventlistenerwithitem*/
95. voidaddEventListener(EventListener*listener);
96. /**Getseventthelistenerlistfortheeventlistenertype.*/
97. EventListenerVector*getListeners(EventListener::ListenerIDlistenerID);
98. /**Updatedirtyflag*/
99. voidupdateDirtyFlagForSceneGraph();
100. /**RemovesalllistenerswiththesameeventlistenerID*/
101. voidremoveEventListenersForListenerID(EventListener::ListenerIDlistenerID);
102. /**排序*/
103. voidsortEventListeners(EventListener::ListenerIDlistenerID);
104. /**根据node优先级排序*/
105. voidsortEventListenersOfSceneGraPHPriority(EventListener::ListenerIDlistenerID);
106. /**根据优先级排序*/
107. voidsortEventListenersOfFixedPriority(EventListener::ListenerIDlistenerID);
108. /**Updatesalllisteners
109. *1)删除所有标记为deleted的监听器.
110. *2)添加_toAddedListeners中的监听器.
111. voidupdateListeners(Event*event);
112. /**ToucheventneedstobeprocesseddifferentwithothereventssinceitneedssupportALL_AT_ONCEandONE_BY_NONEmode.*/
113. voiddispatchTouchEvent(EventTouch*event);
114. /**Associatesnodewitheventlistener*/
115. voidassociateNodeAndEventListener(Node*node,EventListener*listener);
116. /**dissociatesnodewitheventlistener*/
117. voiddissociateNodeAndEventListener(Node*node,EventListener*listener);
118. /**dispatcheseventtolistenerswithaspecifiedlistenertype*/
119. voiddispatchEventToListeners(EventListenerVector*listeners,std::function<bool(EventListener*)>onEvent);
120. ///Prioritydirtyflag
121. enumclassDirtyFlag
122. NONE=0,
123. FIXED_PRITORY=1<<0,
124. SCENE_GRAPH_PRIORITY=1<<1,248); line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important"> ALL=FIXED_PRITORY|SCENE_GRAPH_PRIORITY
125. /**SetsthedirtyflagforaspecifiedlistenerID*/
126. voidsetDirty(EventListener::ListenerIDlistenerID,DirtyFlagflag);
127. /**遍历场景，获取每个Node的绘制顺序；
128. 此函数在sortEventListenersOfSceneGraPHPriority之前调用*/
129. voidvisitTarget(Node*node);
130. private:
131. /**map存储所有监听器map::key监听器类型*/
132. std::unordered_map<EventListener::ListenerID,EventListenerVector*>_listeners;
133. /**map存储一类监听器是否被污染。
134. 即：按优先级分类，可以把所有监听器分为两类（Node，fixdpriority）。
135. 如果_listenner[type]里的监听器全是Nodepriority，则DirtyFlag为SCENE_GRAPH_PRIORITY；
136. 若全为fixdpriority则为FIXED_PRITORY；若两种都有，则为ALL=FIXED_PRITORY|SCENE_GRAPH_PRIORITY*/
137. /**map关联Node与监听器*/
138. std::unordered_map<Node*,std::vector<EventListener*>*>_nodeListenersMap;
139. /**存储每个Node的优先级（即绘制顺序）；
140. 在visitTarge中更新该值，
141. 在sortEventListenersOfSceneGraPHPriority中使用该值*/
142. std::unordered_map<Node*,int>_nodePriorityMap;
143. /**如果注册监听器时正在dispathchevent，则将该监听器加到_toAddedListeners中，
144. 等dispatch完成后，在将其从_toAddedListeners中移到其他容器，*/
145. std::vector<EventListener*>_toAddedListeners;
146. /**优先级发生改变的Node
147. 此集合中的Node所对应的Listener所在的那个vector（_listeners[ID]）将会重排序*/
148. std::set<Node*>_dirtyNodes;
149. /**判断是否正在dispatch*/
150. int_indispatch;
151. /**Whethertoenabledispatchingevent*/
152. bool_isEnabled;
153. int_nodePriorityIndex;
154. NS_CC_END
155. #endif//__CC_EVENT_disPATCHER_H__
156. cpp
157. #include"CCEventdispatcher.h"
158. #include"CCEventTouch.h"
159. #include"CCEventCustom.h"
160. #include"CCEventListenerTouch.h"
161. #include"CCNode.h"
162. #include"CCDirector.h"
163. #include<algorithm>
164. #defineDUMP_LISTENER_ITEM_PRIORITY_INFO0
165. namespace
166. /************************************************************************/
167. /*用于自动处理count。一般用于构造一个局部变量。与指针计数器原理相同。
168. 构造时+1，
169. 析构时-1.
170. 若函数中有多处return，而每次renturn前都要处理某变量的值，则可以采用此机制优化代码；
171. 此机制只需利用变量a构造一个局部变量，无需在每次返回前再处理变量a。
172. classdispatchGuard
173. dispatchGuard(int&count):
174. _count(count)
175. ++_count;
176. }
177. ~dispatchGuard()
178. --_count;
179. }
180. int&_count;
181. //根据Event的type确定EventListener的Type
182. //关于EventListener的ListenerId与EventListener的Type（注意这里不是Event：：Type）映射关系
183. //出自定制类型外，其他类型都是用枚举一一映射的，而自定制类型则是计算hash值
184. staticEventListener::ListenerIDgetListenerID(Event*event)
185. EventListener::ListenerIDret;
186. switch(event->getType())
187. caseEvent::Type::acceleration:
188. ret=static_cast<EventListener::ListenerID>(EventListener::Type::acceleration);
189. break;
190. caseEvent::Type::CUSTOM:
191. autocustomEvent=static_cast<EventCustom*>(event);
192. autolistenerID=std::hash<std::string>()(customEvent->getEventName());
193. static_cast<EventListener::ListenerID>(listenerID);
194. break;
195. caseEvent::Type::KEYBOARD:
196. static_cast<EventListener::ListenerID>(EventListener::Type::KEYBOARD);
197. caseEvent::Type::MOUSE:
198. ret=static_cast<EventListener::ListenerID>(EventListener::Type::MOUSE);
199. caseEvent::Type::TOUCH:
200. //Touchlistenerisveryspecial,itcontainstwokindsoflisteners,EventListenerTouchOneByOneandEventListenerTouchAllAtOnce.
201. //returnUNKNowinstead.
202. static_cast<EventListener::ListenerID>(EventListener::Type::UNKNowN);
203. default:
204. CCASSERT(false,"Invalidtype!");
205. returnret;
206. Eventdispatcher::EventListenerVector::EventListenerVector()
207. :_sceneGraphListeners(nullptr)
208. ,_fixedListeners(nullptr)
209. ,_gt0Index(0)
210. Eventdispatcher::EventListenerVector::~EventListenerVector()
211. CC_SAFE_DELETE(_sceneGraphListeners);
212. CC_SAFE_DELETE(_fixedListeners);
213. size_tEventdispatcher::EventListenerVector::size()const
214. size_tret=0;
215. if(_sceneGraphListeners)
216. ret+=_sceneGraphListeners->size();
217. if(_fixedListeners)
218. ret+=_fixedListeners->size();
219. boolEventdispatcher::EventListenerVector::empty()const
220. return(_sceneGraphListeners==nullptr||_sceneGraphListeners->empty())
221. &&(_fixedListeners==nullptr||_fixedListeners->empty());
222. voidEventdispatcher::EventListenerVector::push_back(EventListener*listener)
223. if(listener->getFixedPriority()==0)
224. if(_sceneGraphListeners==nullptr)
225. _sceneGraphListeners=newstd::vector<EventListener*>();
226. _sceneGraphListeners->reserve(100);
227. _sceneGraphListeners->push_back(listener);
228. else
229. if(_fixedListeners==nullptr)
230. _fixedListeners= _fixedListeners->reserve(100);
231. _fixedListeners->push_back(listener);
232. voidEventdispatcher::EventListenerVector::clearSceneGraphListeners()
233. _sceneGraphListeners->clear();
234. delete_sceneGraphListeners;
235. _sceneGraphListeners=nullptr;
236. voidEventdispatcher::EventListenerVector::clearFixedListeners()
237. _fixedListeners->clear();
238. delete_fixedListeners;
239. _fixedListeners=nullptr;
240. voidEventdispatcher::EventListenerVector::clear()
241. clearSceneGraphListeners();
242. clearFixedListeners();
243. Eventdispatcher::Eventdispatcher()
244. :_indispatch(0)
245. true)
246. _toAddedListeners.reserve(50);
247. Eventdispatcher::~Eventdispatcher()
248. removeAllEventListeners();
249. voidEventdispatcher::visitTarget(Node*node)
250. inti=0;
251. Array*children=node->getChildren();
252. intchildrenCount=children?children->count():0;
253. if(childrenCount>0)
254. Node*child=nullptr;
255. //只计算子节点中zOrder<0的
256. for(;i<childrenCount;i++)
257. child=static_cast<Node*>(children->getobjectAtIndex(i));
258. if(child&&child->getZOrder()<0)
259. visitTarget(child);
260. else
261. //记录Node的优先级
262. _nodePriorityMap.insert(std::make_pair(node,++_nodePriorityIndex));
263. for(;i<childrenCount;i++)
264. child=static_cast<Node*>(children->getobjectAtIndex(i));
265. if(child)
266. _nodePriorityMap.insert(std::make_pair(node,++_nodePriorityIndex));
267. voidEventdispatcher::pauseTarget(Node*node)
268. autolistenerIter=_nodeListenersMap.find(node);
269. if(listenerIter!=_nodeListenersMap.end())
270. autolisteners=listenerIter->second;
271. for(auto&l:*listeners)
272. l->setPaused(true);
273. voidEventdispatcher::resuMetarget(Node*node)
274. autolistenerIter=_nodeListenersMap.find(node);
275. if(listenerIter!=_nodeListenersMap.end())
276. autolisteners=listenerIter->second;
277. for(auto&l:*listeners)
278. l->setPaused(false);
279. setDirtyForNode(node);
280. voidEventdispatcher::cleanTarget(Node*node)
281. autolistenerscopy=*listeners;
282. for(auto&l:listenerscopy)
283. removeEventListener(l);
284. voidEventdispatcher::associateNodeAndEventListener(Node*node,EventListener*listener)
285. std::vector<EventListener*>*listeners=nullptr;
286. autofound=_nodeListenersMap.find(node);
287. if(found!=_nodeListenersMap.end())
288. listeners=found->second;
289. listeners= listeners->push_back(listener);
290. _nodeListenersMap.insert(std::make_pair(node,listeners));
291. voidEventdispatcher::dissociateNodeAndEventListener(Node*node,108); list-style:decimal-leading-zero outside; color:inherit; line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important"> autoiter=std::find(listeners->begin(),listeners->end(),listener);
292. if(iter!=listeners->end())
293. listeners->erase(iter);
294. if(listeners->empty())
295. _nodeListenersMap.erase(found);
296. deletelisteners;
297. voidEventdispatcher::addEventListener(EventListener*listener)
298. //如果不是正在路由事件
299. if(_indispatch==0)
300. EventListenerVector*listenerList=nullptr;
301. //根据listenerID获取相应vector
302. autoiter=_listeners.find(listener->getListenerID());
303. if(iter==_listeners.end())
304. listenerList=newEventListenerVector();
305. _listeners.insert(std::make_pair(listener->getListenerID(),listenerList));
306. listenerList=iter->second;
307. listenerList->push_back(listener);
308. if(listener->getFixedPriority()==0)
309. //如果优先级根据Node而定
310. setDirty(listener->getListenerID(),DirtyFlag::SCENE_GRAPH_PRIORITY);
311. //如果优先级根据Fixed而定
312. setDirty(listener->getListenerID(),DirtyFlag::FIXED_PRITORY);
313. //如果正在路由事件，则直接加入_toAddedListeners
314. _toAddedListeners.push_back(listener);
315. voidEventdispatcher::addEventListenerWithSceneGraPHPriority(EventListener*listener,Node*node)
316. CCASSERT(listener&&node,"Invalidparameters.");
317. CCASSERT(!listener->isRegistered(),"Thelistenerhasbeenregistered.");
318. if(!listener->checkAvailable())
319. return;
320. listener->setSceneGraPHPriority(node);
321. listener->setFixedPriority(0);
322. listener->setRegistered( listener->retain();
323. //存储listener，
324. addEventListener(listener);
325. //关联node与listener
326. associateNodeAndEventListener(node,listener);
327. if(node->isRunning())
328. resuMetarget(node);
329. voidEventdispatcher::addEventListenerWithFixedPriority(EventListener*listener,87); background-color:inherit; font-weight:bold">intfixedPriority)
330. CCASSERT(listener,"Invalidparameters.");
331. CCASSERT(!listener->isRegistered(),"Thelistenerhasbeenregistered.");
332. CCASSERT(fixedPriority!=0,"0priorityisforbiddenforfixedprioritysinceit'susedforscenegraphbasedpriority.");
333. listener->setSceneGraPHPriority(nullptr);
334. listener->setFixedPriority(fixedPriority);
335. listener->setPaused( listener->retain();
336. addEventListener(listener);
337. voidEventdispatcher::removeEventListener(EventListener*listener)
338. if(listener==nullptr)
339. return;
340. boolisFound=false;
341. autoremoveListenerInVector=[&](std::vector<EventListener*>*listeners){
342. if(listeners==nullptr)
343. for(autoiter=listeners->begin();iter!=listeners->end();++iter)
344. autol=*iter;
345. if(l==listener)
346. CC_SAFE_RETAIN(l);
347. l->setRegistered(if(l->getSceneGraPHPriority()!=nullptr)
348. //撤销node与listener的关联
349. dissociateNodeAndEventListener(l->getSceneGraPHPriority(),l);
350. if(_indispatch==0)
351. listeners->erase(iter);
352. CC_SAFE_RELEASE(l);
353. isFound=true;
354. for(autoiter=_listeners.begin();iter!=_listeners.end();)
355. autolisteners=iter->second;
356. autofixedPriorityListeners=listeners->getFixedPriorityListeners();
357. autosceneGraPHPriorityListeners=listeners->getSceneGraPHPriorityListeners();
358. removeListenerInVector(sceneGraPHPriorityListeners);
359. if(!isFound)
360. removeListenerInVector(fixedPriorityListeners);
361. if(iter->second->empty())
362. _priorityDirtyFlagMap.erase(listener->getListenerID());
363. autolist=iter->second;
364. iter=_listeners.erase(iter);
365. CC_SAFE_DELETE(list);
366. ++iter;
367. if(isFound)
368. CC_SAFE_RELEASE(listener);
369. //若没有找到，则在_toAddedListeners中找
370. for(autoiter=_toAddedListeners.begin();iter!=_toAddedListeners.end();++iter)
371. if(*iter==listener)
372. _toAddedListeners.erase(iter);
373. voidEventdispatcher::setPriority(EventListener*listener,87); background-color:inherit; font-weight:bold">intfixedPriority)
374. for(autoiter=_listeners.begin();iter!=_listeners.end();++iter)
375. autofixedPriorityListeners=iter->second->getFixedPriorityListeners();
376. if(fixedPriorityListeners)
377. autofound=std::find(fixedPriorityListeners->begin(),fixedPriorityListeners->end(),153); background-color:inherit; font-weight:bold">if(found!=fixedPriorityListeners->end())
378. CCASSERT(listener->getSceneGraPHPriority()==nullptr,"Can'tsetfixedprioritywithscenegraphbasedlistener.");
379. if(listener->getFixedPriority()!=fixedPriority)
380. voidEventdispatcher::dispatchEventToListeners(EventListenerVector*listeners,87); background-color:inherit; font-weight:bold">bool(EventListener*)>onEvent)
381. boolshouldStopPropagation=false;
382. longi=0;
383. //priority<0
384. for(;!fixedPriorityListeners->empty()&&i<listeners->getGt0Index();++i)
385. autol=fixedPriorityListeners->at(i);
386. if(!l->isPaused()&&l->isRegistered()&&onEvent(l))
387. shouldStopPropagation=true;
388. if(sceneGraPHPriorityListeners)
389. if(!shouldStopPropagation)
390. //priority==0,scenegraPHPriority
391. for(auto&l:*sceneGraPHPriorityListeners)
392. if(!l->isPaused()&&l->isRegistered()&&onEvent(l))
393. shouldStopPropagation=if(fixedPriorityListeners)
394. //priority>0
395. for(;i<static_cast<long>(fixedPriorityListeners->size());++i)
396. if(!l->isPaused()&&l->isRegistered()&&onEvent(fixedPriorityListeners->at(i)))
397. voidEventdispatcher::dispatchEvent(Event*event)
398. if(!_isEnabled)
399. updateDirtyFlagForSceneGraph();
400. dispatchGuardguard(_indispatch);
401. if(event->getType()==Event::Type::TOUCH)
402. dispatchTouchEvent(static_cast<EventTouch*>(event));
403. autolistenerID=getListenerID(event);
404. sortEventListeners(listenerID);
405. autoiter=_listeners.find(listenerID);
406. if(iter!=_listeners.end())
407. autolisteners=iter->second;
408. autoonEvent=[&event](EventListener*listener)->bool{
409. event->setCurrentTarget(listener->getSceneGraPHPriority());
410. listener->_onEvent(event);
411. returnevent->isstopped();
412. };
413. dispatchEventToListeners(listeners,onEvent);
414. updateListeners(event);
415. voidEventdispatcher::dispatchTouchEvent(EventTouch*event)
416. autotouchOneByOneID=static_cast<EventListener::ListenerID>(EventListener::Type::TOUCH_ONE_BY_ONE);
417. autotouchAllAtOnceID=static_cast<EventListener::ListenerID>(EventListener::Type::TOUCH_ALL_AT_ONCE);
418. sortEventListeners(touchOneByOneID);
419. sortEventListeners(touchAllAtOnceID);
420. autooneByOnelisteners=getListeners(touchOneByOneID);
421. autoallAtOncelisteners=getListeners(touchAllAtOnceID);
422. //Iftherearen'tanytouchlisteners,returndirectly.
423. if(nullptr==oneByOnelisteners&&nullptr==allAtOncelisteners)
424. boolisNeedsMutableSet=(oneByOnelisteners&&allAtOncelisteners);
425. std::vector<Touch*>orignaltouches=event->gettouches();
426. std::vector<Touch*>mutabletouches(orignaltouches.size());
427. std::copy(orignaltouches.begin(),orignaltouches.end(),mutabletouches.begin());
428. //
429. //processthetargethandlers1st
430. if(oneByOnelisteners)
431. automutabletouchesIter=mutabletouches.begin();
432. autotouchesIter=orignaltouches.begin();
433. for(;touchesIter!=orignaltouches.end();++touchesIter)
434. boolisSwallowed= autoonTouchEvent=[&](EventListener*l)->bool{//Returntruetobreak
435. EventListenerTouchOneByOne*listener=static_cast<EventListenerTouchOneByOne*>(l);
436. //Skipifthelistenerwasremoved.
437. if(!listener->_isRegistered)
438. return event->setCurrentTarget(listener->_node);
439. boolisClaimed= std::vector<Touch*>::iteratorremovedIter;
440. EventTouch::EventCodeeventCode=event->getEventCode();
441. if(eventCode==EventTouch::EventCode::BEGAN)
442. if(listener->onTouchBegan)
443. isClaimed=listener->onTouchBegan(*touchesIter,event);
444. if(isClaimed&&listener->_isRegistered)
445. listener->_claimedtouches.push_back(*touchesIter);
446. elseif(listener->_claimedtouches.size()>0
447. &&((removedIter=std::find(listener->_claimedtouches.begin(),listener->_claimedtouches.end(),*touchesIter))!=listener->_claimedtouches.end()))
448. isClaimed=switch(eventCode)
449. caseEventTouch::EventCode::MOVED:
450. if(listener->onTouchMoved)
451. listener->onTouchMoved(*touchesIter,event);
452. caseEventTouch::EventCode::ENDED:
453. if(listener->onTouchEnded)
454. listener->onTouchEnded(*touchesIter,153); background-color:inherit; font-weight:bold">if(listener->_isRegistered)
455. listener->_claimedtouches.erase(removedIter);
456. caseEventTouch::EventCode::CANCELLED:
457. if(listener->onTouchCancelled)
458. listener->onTouchCancelled(*touchesIter,153); background-color:inherit; font-weight:bold">default:
459. CCASSERT("Theeventcodeisinvalid.");
460. //Iftheeventwasstopped,153); background-color:inherit; font-weight:bold">if(event->isstopped())
461. updateListeners(event);
462. CCASSERT((*touchesIter)->getID()==(*mutabletouchesIter)->getID(),"");
463. if(isClaimed&&listener->_isRegistered&&listener->_needSwallow)
464. if(isNeedsMutableSet)
465. mutabletouchesIter=mutabletouches.erase(mutabletouchesIter);
466. isSwallowed= dispatchEventToListeners(oneByOnelisteners,onTouchEvent);
467. if(event->isstopped())
468. if(!isSwallowed)
469. ++mutabletouchesIter;
470. //processstandardhandlers2nd
471. if(allAtOncelisteners&&mutabletouches.size()>0)
472. autoontouchesEvent=[&](EventListener*l)->bool{
473. EventListenerTouchAllAtOnce*listener=static_cast<EventListenerTouchAllAtOnce*>(l);
474. //Skipifthelistenerwasremoved.
475. if(!listener->_isRegistered)
476. event->setCurrentTarget(listener->_node);
477. switch(event->getEventCode())
478. caseEventTouch::EventCode::BEGAN:
479. if(listener->ontouchesBegan)
480. listener->ontouchesBegan(mutabletouches,153); background-color:inherit; font-weight:bold">if(listener->ontouchesMoved)
481. listener->ontouchesMoved(mutabletouches,153); background-color:inherit; font-weight:bold">if(listener->ontouchesEnded)
482. listener->ontouchesEnded(mutabletouches,153); background-color:inherit; font-weight:bold">if(listener->ontouchesCancelled)
483. listener->ontouchesCancelled(mutabletouches,returndirectly.
484. dispatchEventToListeners(allAtOncelisteners,ontouchesEvent);
485. voidEventdispatcher::updateListeners(Event*event)
486. autoonUpdateListeners=[this](EventListener::ListenerIDlistenerID)
487. autolistenersIter=_listeners.find(listenerID);
488. if(listenersIter==_listeners.end())
489. autolisteners=listenersIter->second;
490. autofixedPriorityListeners=listeners->getFixedPriorityListeners();
491. autosceneGraPHPriorityListeners=listeners->getSceneGraPHPriorityListeners();
492. for(autoiter=sceneGraPHPriorityListeners->begin();iter!=sceneGraPHPriorityListeners->end();)
493. if(!l->isRegistered())
494. iter=sceneGraPHPriorityListeners->erase(iter);
495. l->release();
496. for(autoiter=fixedPriorityListeners->begin();iter!=fixedPriorityListeners->end();)
497. autol=*iter;
498. if(!l->isRegistered())
499. iter=fixedPriorityListeners->erase(iter);
500. l->release();
501. ++iter;
502. if(sceneGraPHPriorityListeners&&sceneGraPHPriorityListeners->empty())
503. listeners->clearSceneGraphListeners();
504. if(fixedPriorityListeners&&fixedPriorityListeners->empty())
505. listeners->clearFixedListeners();
506. if(listenersIter->second->empty())
507. _priorityDirtyFlagMap.erase(listenersIter->first);
508. deletelistenersIter->second;
509. listenersIter=_listeners.erase(listenersIter);
510. ++listenersIter;
511. if(event->getType()==Event::Type::TOUCH)
512. onUpdateListeners(static_cast<EventListener::ListenerID>(EventListener::Type::TOUCH_ONE_BY_ONE));
513. onUpdateListeners(static_cast<EventListener::ListenerID>(EventListener::Type::TOUCH_ALL_AT_ONCE));
514. onUpdateListeners(getListenerID(event));
515. if(!_toAddedListeners.empty())
516. EventListenerVector*listeners=nullptr;
517. for(auto&listener:_toAddedListeners)
518. EventListener::ListenerIDlistenerID=listener->getListenerID();
519. autoitr=_listeners.find(listenerID);
520. if(itr==_listeners.end())
521. newEventListenerVector();
522. _listeners.insert(std::make_pair(listenerID,108); list-style:decimal-leading-zero outside; color:inherit; line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important"> listeners=itr->second;
523. listeners->push_back(listener);
524. setDirty(listenerID,DirtyFlag::FIXED_PRITORY);
525. _toAddedListeners.clear();
526. voidEventdispatcher::updateDirtyFlagForSceneGraph()
527. if(!_dirtyNodes.empty())
528. for(auto&node:_dirtyNodes)
529. autoiter=_nodeListenersMap.find(node);
530. if(iter!=_nodeListenersMap.end())
531. for(auto&l:*iter->second)
532. setDirty(l->getListenerID(),108); list-style:decimal-leading-zero outside; color:inherit; line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important"> _dirtyNodes.clear();
533. voidEventdispatcher::sortEventListeners(EventListener::ListenerIDlistenerID)
534. DirtyFlagdirtyFlag=DirtyFlag::NONE;
535. autodirtyIter=_priorityDirtyFlagMap.find(listenerID);
536. if(dirtyIter!=_priorityDirtyFlagMap.end())
537. dirtyFlag=dirtyIter->second;
538. if(dirtyFlag!=DirtyFlag::NONE)
539. if((int)dirtyFlag&(int)DirtyFlag::FIXED_PRITORY)
540. sortEventListenersOfFixedPriority(listenerID);
541. int)DirtyFlag::SCENE_GRAPH_PRIORITY)
542. sortEventListenersOfSceneGraPHPriority(listenerID);
543. dirtyIter->second=DirtyFlag::NONE;
544. voidEventdispatcher::sortEventListenersOfSceneGraPHPriority(EventListener::ListenerIDlistenerID)
545. autolisteners=getListeners(listenerID);
546. Node*rootNode=(Node*)Director::getInstance()->getRunningScene();
547. //Resetpriorityindex
548. _nodePriorityIndex=0;
549. _nodePriorityMap.clear();
550. visitTarget(rootNode);
551. //Aftersort:priority<0,>0
552. autosceneGraphlisteners=listeners->getSceneGraPHPriorityListeners();
553. std::sort(sceneGraphlisteners->begin(),sceneGraphlisteners->end(),[this](constEventListener*l1,constEventListener*l2){
554. return_nodePriorityMap[l1->getSceneGraPHPriority()]>_nodePriorityMap[l2->getSceneGraPHPriority()];
555. });
556. #ifDUMP_LISTENER_ITEM_PRIORITY_INFO
557. log("-----------------------------------");
558. for(auto&l:*sceneGraphlisteners)
559. log("listenerpriority:node([%s]%p),priority(%d)",153); background-color:inherit; font-weight:bold">typeid(*l->_node).name(),l->_node,_nodePriorityMap[l->_node]);
560. #endif
561. voidEventdispatcher::sortEventListenersOfFixedPriority(EventListener::ListenerIDlistenerID)
562. autolisteners=getListeners(listenerID);
563. if(listeners==nullptr)
564. autofixedlisteners=listeners->getFixedPriorityListeners();
565. std::sort(fixedlisteners->begin(),fixedlisteners->end(),[](returnl1->getFixedPriority()<l2->getFixedPriority();
566. //FIXME:Shouldusebinarysearch
567. longindex=0;
568. for(auto&listener:*fixedlisteners)
569. if(listener->getFixedPriority()>=0)
570. ++index;
571. listeners->setGt0Index(index);
572. #ifDUMP_LISTENER_ITEM_PRIORITY_INFO
573. log("-----------------------------------");
574. for(auto&l:*fixedlisteners)
575. log("listenerpriority:node(%p),fixed(%d)",l->_fixedPriority);
576. #endif
577. Eventdispatcher::EventListenerVector*Eventdispatcher::getListeners(EventListener::ListenerIDlistenerID)
578. autoiter=_listeners.find(listenerID);
579. if(iter!=_listeners.end())
580. returniter->second;
581. returnnullptr;
582. voidEventdispatcher::removeEventListenersForListenerID(EventListener::ListenerIDlistenerID)
583. autolistenerItemIter=_listeners.find(listenerID);
584. if(listenerItemIter!=_listeners.end())
585. autolisteners=listenerItemIter->second;
586. autoremoveAllListenersInVector=[&](std::vector<EventListener*>*listenerVector){
587. if(listenerVector==nullptr)
588. for(autoiter=listenerVector->begin();iter!=listenerVector->end();)
589. l->setRegistered(false);
590. if(l->getSceneGraPHPriority()!=nullptr)
591. iter=listenerVector->erase(iter);
592. removeAllListenersInVector(sceneGraPHPriorityListeners);
593. removeAllListenersInVector(fixedPriorityListeners);
594. if(!_indispatch)
595. listeners->clear();
596. deletelisteners;
597. _listeners.erase(listenerItemIter);
598. _priorityDirtyFlagMap.erase(listenerID);
599. for(autoiter=_toAddedListeners.begin();iter!=_toAddedListeners.end();)
600. if((*iter)->getListenerID()==listenerID)
601. iter=_toAddedListeners.erase(iter);
602. voidEventdispatcher::removeEventListeners(EventListener::TypelistenerType)
603. CCASSERT(listenerType!=EventListener::Type::CUSTOM,"Notsupportcustomeventlistenertype,pleaseuseEventdispatcher::removeCustomEventListenersinstead.");
604. removeEventListenersForListenerID(static_cast<EventListener::ListenerID>(listenerType));
605. voidEventdispatcher::removeCustomEventListeners(conststd::string&customEventName)
606. removeEventListenersForListenerID(std::hash<std::string>()(customEventName));
607. voidEventdispatcher::removeAllEventListeners()
608. std::vector<int>types(_listeners.size());
609. types.push_back(iter->first);
610. for(auto&type:types)
611. removeEventListenersForListenerID(type);
612. _listeners.clear();
613. voidEventdispatcher::setEnabled(boolisEnabled)
614. _isEnabled=isEnabled;
615. boolEventdispatcher::isEnabled()return_isEnabled;
616. voidEventdispatcher::setDirtyForNode(Node*node)
617. //Markthenodedirtyonlywhentherewasaneventlistenerassociateswithit.
618. if(_nodeListenersMap.find(node)!=_nodeListenersMap.end())
619. _dirtyNodes.insert(node);
620. voidEventdispatcher::setDirty(EventListener::ListenerIDlistenerID,DirtyFlagflag)
621. autoiter=_priorityDirtyFlagMap.find(listenerID);
622. if(iter==_priorityDirtyFlagMap.end())
623. _priorityDirtyFlagMap.insert(std::make_pair(listenerID,flag));
624. intret=(int)flag|(int)iter->second;
625. iter->second=(DirtyFlag)ret;
626. </pre><br>
627. <br>
628. <pre></pre>
629. <pre></pre>
630. </pre></pre></pre></pre></pre>