首页 > itarticle > c++事件分发器 EventListener EventDispatcher Factory test

c++事件分发器 EventListener EventDispatcher Factory test

admin 11月 13, 2020 0

xevent.h

1
2
3
4
5
6
 
class 
{
public:
	virtual void dump() = 0;
	virtual void free() = 0;
};

EventListener

xeventlistener.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
class ;
class XEventListener {
public:
	virtual int onEvent(XEvent *evt) = 0;
};
template<class Handler, class filter = >
class ClassEventListener : virtual public XEventListener
{
public:
	typedef int (Handler::*__XHandlerFunc)(XEvent *evt);
	ClassEventListener(Handler *ptr, __XHandlerFunc func) :
		handler(ptr),
		func_(func){
	}
	virtual int onEvent(XEvent *evt)
	{
		if (dynamic_cast<filter*>(evt)){
			if (handler && func_)
				return (handler->*func_)(evt);
		}
		return 0;
	}
	~ClassEventListener(){};
private:
	Handler *handler;
	__XHandlerFunc func_;
};

EventDispatcher

xeventdispatcher.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
class ;
class XEventListener;
class XEventDispatcher
{
public:
	
	virtual void addEventListener(XEventListener* listener, int fixedPriority = -1) ;
	//删除指定监听器
	virtual void removeEventListener(XEventListener* listener);
	//启用事件分发器
	virtual void setEnabled(bool isEnabled) ;
	virtual bool isEnabled() const ;
	//手动派发自定义事件
	virtual void dispatchEvent(XEvent* event) ;
};

xeventdispatcher.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
#include "xeventdispatcher.h"
#include "xevent.h"
#include "xeventlistener.h"
XEventDispatcher::XEventDispatcher():
mEnable(false)
{
}
XEventDispatcher::~XEventDispatcher()
{
}
void XEventDispatcher::addEventListener(XEventListener* listener, int fixedPriority){
	mls.push_back(listener);
}
//删除指定监听器
void XEventDispatcher::removeEventListener(XEventListener* listener){
	mls.remove(listener);
}
//启用事件分发器
void XEventDispatcher::setEnabled(bool isEnabled){
	mEnable = isEnabled;
}
bool XEventDispatcher::isEnabled() const{
	return mEnable;
}
//手动派发自定义事件
void XEventDispatcher::dispatchEvent(XEvent* event){
	if (mEnable){
		T_ListenerList::iterator it;
		for (it = mls.begin(); it != mls.end(); ++it){
			(*it)->onEvent(event);
		}
	}
}

Factory

factory.h

1
2
3
4
5
6
7
8
9
 
#pragma once
class XEventDispatcher;
class Factory
{
public:
	static XEventDispatcher * getEventDispatcher();
private:
	static XEventDispatcher * mXEventDispatcher;
};

factory.cpp

1
2
3
4
5
6
7
8
9
10
 
#include "factory.h"
#include "xeventdispatcher.h"
XEventDispatcher * Factory::mXEventDispatcher = NULL;
XEventDispatcher * Factory::getEventDispatcher(){
	if (!mXEventDispatcher){
		mXEventDispatcher = new XEventDispatcher;
	}
	return mXEventDispatcher;
}

test

main.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
 
#include <iostream>
#include "xevent.h"
#include "xeventlistener.h"
#include "xeventdispatcher.h"
#include "factory.h"
class Mouse :virtual public XEvent{
	virtual void dump(){
		printf("Mouse event rn");
	}
};
class Keyboard :virtual public XEvent{
	virtual void dump(){
		printf("Keyboard event rn");
	}
};
class HandlerClass
{
public:
	int OnEvent(XEvent *evt)
	{
		evt->dump();
		return 0;
	}
};
int main(int argc, _TCHAR* argv[])
{
	HandlerClass h;
	Keyboard k1;
	Keyboard k2;
	Mouse m1;
	Mouse m2;
	{
		ClassEventListener<HandlerClass, Keyboard> mouseEvthandler(&h, &HandlerClass::OnEvent);
		ClassEventListener<HandlerClass, Mouse> keyboardEvthandler(&h, &HandlerClass::OnEvent);
		XEventDispatcher * dispatcher = Factory::getEventDispatcher();
		dispatcher->addEventListener(&mouseEvthandler);
		dispatcher->addEventListener(&keyboardEvthandler);
		dispatcher->dispatchEvent(&m1);
		dispatcher->dispatchEvent(&m2);
		dispatcher->dispatchEvent(&k1);
		dispatcher->dispatchEvent(&k2);
		dispatcher->setEnabled(true);
		dispatcher->dispatchEvent(&m1);
		dispatcher->dispatchEvent(&m2);
		dispatcher->dispatchEvent(&k1);
		dispatcher->dispatchEvent(&k2);
		dispatcher->removeEventListener(&mouseEvthandler);
		dispatcher->removeEventListener(&keyboardEvthandler);
	}
	printf("===================================================== rn");
	{
		ClassEventListener<HandlerClass> mouseEvthandler1(&h, &HandlerClass::OnEvent);
		ClassEventListener<HandlerClass> keyboardEvthandler1(&h, &HandlerClass::OnEvent);
		XEventDispatcher * dispatcher = Factory::getEventDispatcher();
		dispatcher->addEventListener(&mouseEvthandler1);
		dispatcher->addEventListener(&keyboardEvthandler1);
		dispatcher->dispatchEvent(&m1);
		dispatcher->dispatchEvent(&m2);
		dispatcher->dispatchEvent(&k1);
		dispatcher->dispatchEvent(&k2);
		dispatcher->removeEventListener(&mouseEvthandler1);
		dispatcher->removeEventListener(&keyboardEvthandler1);
	}
	getchar();
	return 0;
}

微海报分享

近期文章

近期评论

标签

热门

文章归档

分类目录

功能