Replaced GEventQueue with eventpp::EventQueue

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "thirdparty/eventpp"]
+	path = thirdparty/eventpp
+	url = https://github.com/wqking/eventpp.git

build/desktop/build.txt

@@ -140,6 +140,7 @@ include_directories(
 	${TESTS_PATH}/application
 	${CPGF_PATH}/include
 	${ROOT_PATH}/thirdparty
+	${ROOT_PATH}/thirdparty/eventpp/include
 	${PYTHON_INC}
 )
 

build/desktop/config.txt

@@ -11,12 +11,12 @@ set(CPGF_LIB ${CPGF_PATH}/lib/libcpgf.a)
 endif()
 
 set(ENABLE_SFML 1)
-set(SFML_PATH /source/SFML-2.4.1)
+set(SFML_PATH /source/multimedia/SFML-2.4.1)
 set(SFML_INCLUDE_PATH ${SFML_PATH}/include)
 set(SFML_LIB_PATH ${SFML_PATH}/lib)
 
 set(ENABLE_ALLEGRO 0)
-set(ALLEGRO_PATH E:/source/allegro)
+set(ALLEGRO_PATH /source/multimedia/allegro)
 set(ALLEGRO_INCLUDE_PATH
 	${ALLEGRO_PATH}/include
 	${ALLEGRO_PATH}/addons/image/

build/metagen/gincu.doxyfile

@@ -791,7 +791,7 @@ WARN_LOGFILE           =
 # Note: If this tag is empty the current directory is searched.
 
 INPUT                  = ../../include/ \
-                         ../../../cpgf/include/cpgf/tween
+                         ../../../cpgf/include/cpgf/tween/
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses

include/gincu/geventqueue.h

@@ -4,35 +4,27 @@
 #include "gincu/gevent.h"
 
 #include "cpgf/gcallback.h"
-#include "cpgf/gcallbacklist.h"
 
-#include <deque>
-#include <map>
-#include <mutex>
+#include "eventpp/eventqueue.h"
 
 namespace gincu {
 
-class GEventQueue
+struct GEventQueuePolicies
 {
-public:
-	typedef cpgf::GCallback<void (const GEvent &)> EventListener;
-	typedef cpgf::GCallbackList<void (const GEvent &)> EventListenerList;
+	static GEventType getEvent(const GEvent & e) {
+		return e.getType();
+	}
 
-	typedef std::recursive_mutex MutexType;
-	typedef std::lock_guard<MutexType> LockType;
+	using Callback = cpgf::GCallback<void (const GEvent &)>;
+};
 
+class GEventQueue : public eventpp::EventQueue<GEventType, void (const GEvent &), GEventQueuePolicies>
+{
 private:
-	struct TaggedListener
-	{
-		EventListener listener;
-		GEvent::TagType tag;
-	};
-
-	struct ListenerItem
-	{
-		EventListenerList nonTagListenerList;
-		std::deque<TaggedListener> taggedListenerList;
-	};
+	using super = eventpp::EventQueue<GEventType, void (const GEvent &), GEventQueuePolicies>;
+
+public:
+	using EventListener = Callback;
 
 public:
 	static void dispatchAll();
@@ -41,54 +33,31 @@ class GEventQueue
 	GEventQueue();
 	~GEventQueue();
 
-	void addListener(const GEventType type, const EventListener & listener, const GEvent::TagType tag = nullptr);
-
-	// add a "catch all" listener, be careful to use it, it may hit performance.
-	void addListener(const EventListener & listener, const GEvent::TagType tag = nullptr);
-
 	template <typename Iterator>
-	void addListeners(Iterator begin, const Iterator end, const EventListener & listener, const GEvent::TagType tag = nullptr) {
+	void addListeners(Iterator begin, const Iterator end, const EventListener & listener) {
 		while(begin != end) {
-			this->addListener(*begin, listener, tag);
+			this->appendListener(*begin, listener);
 			++begin;
 		}
 	}
 
-	void removeListener(const GEventType type, const EventListener & listener, const GEvent::TagType tag = nullptr);
+	using super::removeListener;
 
-	// remove a "catch all" listener
-	void removeListener(const EventListener & listener, const GEvent::TagType tag = nullptr);
+	void removeListener(const GEventType type, const EventListener & listener) {
+		forEach(type, [this, type, &listener](const Handle & handle, const EventListener & foundListener) {
+			if(foundListener == listener) {
+				super::removeListener(type, handle);
+			}
+		});
+	}
 
 	template <typename Iterator>
-	void removeListeners(Iterator begin, const Iterator end, const EventListener & listener, const GEvent::TagType tag = nullptr) {
+	void removeListeners(Iterator begin, const Iterator end, const EventListener & listener) {
 		while(begin != end) {
-			this->removeListener(*begin, listener, tag);
+			this->removeListener(*begin, listener);
 			++begin;
 		}
 	}
-
-	void send(const GEvent & event);
-	void post(const GEvent & event);
-
-	void dispatch();
-
-private:
-	void doDispatch();
-	void doDispatchEvent(const GEvent & event);
-	void doDispatchEventByType(const GEvent & event, const GEventType type);
-
-	void doRemoveFromTaggedList(std::deque<TaggedListener> * taggedList, const EventListener & listener, const GEvent::TagType tag);
-	void doRemoveFromTaggedList(std::deque<TaggedListener> * taggedList, const EventListener & listener);
-
-private:
-	MutexType eventMutex;
-	std::deque<GEvent> eventQueue;
-	MutexType listenerMutex;
-	std::map<GEventType, ListenerItem> listenerMap;
-
-private:
-	static std::deque<GEventQueue *> eventQueueList;
-	static MutexType eventQueueListMutex;
 };
 
 

metagen/meta_gincugeventqueue.cpp

@@ -19,7 +19,21 @@ GDefineMetaInfo createMetaClass_GEventQueue()
 {
     GDefineMetaGlobalDangle _d = GDefineMetaGlobalDangle::dangle();
     {
-        GDefineMetaClass<gincu::GEventQueue> _nd = GDefineMetaClass<gincu::GEventQueue>::lazyDeclare("GEventQueue", &buildMetaClass_GEventQueue);
+        GDefineMetaClass<gincu::GEventQueue, eventpp::EventQueue< GEventType, void(const GEvent &), GEventQueuePolicies >> _nd = GDefineMetaClass<gincu::GEventQueue, eventpp::EventQueue< GEventType, void(const GEvent &), GEventQueuePolicies >>::lazyDeclare("GEventQueue", &buildMetaClass_GEventQueue);
+        _d._class(_nd);
+    }
+    return _d.getMetaInfo();
+}
+
+
+#ifdef CPGF_METAGEN_LINKAGE_SPEC
+CPGF_METAGEN_LINKAGE_SPEC
+#endif
+GDefineMetaInfo createMetaClass_GEventQueuePolicies()
+{
+    GDefineMetaGlobalDangle _d = GDefineMetaGlobalDangle::dangle();
+    {
+        GDefineMetaClass<gincu::GEventQueuePolicies> _nd = GDefineMetaClass<gincu::GEventQueuePolicies>::lazyDeclare("GEventQueuePolicies", &buildMetaClass_GEventQueuePolicies);
         _d._class(_nd);
     }
     return _d.getMetaInfo();

metagen/meta_gincugeventqueue.h

@@ -24,21 +24,17 @@ void buildMetaClass_GEventQueue(D _d)
 
     _d.CPGF_MD_TEMPLATE _constructor<void * ()>();
     _d.CPGF_MD_TEMPLATE _method("dispatchAll", &D::ClassType::dispatchAll);
-    _d.CPGF_MD_TEMPLATE _method("addListener", (void (D::ClassType::*) (const GEventType, const GEventQueue::EventListener&, const GEvent::TagType))&D::ClassType::addListener)
-        ._default(copyVariantFromCopyable<const GEvent::TagType>((const GEvent::TagType)nullptr))
-    ;
-    _d.CPGF_MD_TEMPLATE _method("addListener", (void (D::ClassType::*) (const GEventQueue::EventListener&, const GEvent::TagType))&D::ClassType::addListener)
-        ._default(copyVariantFromCopyable<const GEvent::TagType>((const GEvent::TagType)nullptr))
-    ;
-    _d.CPGF_MD_TEMPLATE _method("removeListener", (void (D::ClassType::*) (const GEventType, const GEventQueue::EventListener&, const GEvent::TagType))&D::ClassType::removeListener)
-        ._default(copyVariantFromCopyable<const GEvent::TagType>((const GEvent::TagType)nullptr))
-    ;
-    _d.CPGF_MD_TEMPLATE _method("removeListener", (void (D::ClassType::*) (const GEventQueue::EventListener&, const GEvent::TagType))&D::ClassType::removeListener)
-        ._default(copyVariantFromCopyable<const GEvent::TagType>((const GEvent::TagType)nullptr))
-    ;
-    _d.CPGF_MD_TEMPLATE _method("send", &D::ClassType::send);
-    _d.CPGF_MD_TEMPLATE _method("post", &D::ClassType::post);
-    _d.CPGF_MD_TEMPLATE _method("dispatch", &D::ClassType::dispatch);
+    _d.CPGF_MD_TEMPLATE _method("removeListener", &D::ClassType::removeListener);
+}
+
+
+template <typename D>
+void buildMetaClass_GEventQueuePolicies(D _d)
+{
+    (void)_d;
+    using namespace cpgf;
+
+    _d.CPGF_MD_TEMPLATE _method("getEvent", &D::ClassType::getEvent);
 }
 
 

metagen/register_meta_gincu.h

@@ -48,6 +48,7 @@ GDefineMetaInfo createMetaClass_GDeviceContextRegister();
 GDefineMetaInfo createMetaClass_GEntity();
 GDefineMetaInfo createMetaClass_GEvent();
 GDefineMetaInfo createMetaClass_GEventQueue();
+GDefineMetaInfo createMetaClass_GEventQueuePolicies();
 GDefineMetaInfo createMetaClass_GFileInputStream();
 GDefineMetaInfo createMetaClass_GFileInputStreamData();
 GDefineMetaInfo createMetaClass_GFont();
@@ -161,6 +162,7 @@ void registerMain_gincu(Meta _d)
     _d._class(createMetaClass_GEntity());
     _d._class(createMetaClass_GEvent());
     _d._class(createMetaClass_GEventQueue());
+    _d._class(createMetaClass_GEventQueuePolicies());
     _d._class(createMetaClass_GFileInputStream());
     _d._class(createMetaClass_GFileInputStreamData());
     _d._class(createMetaClass_GFont());

readme.md

@@ -29,7 +29,8 @@ Now there is a match-three game in the project. In the future we may add more ga
  * [SFML 2.4.1](http://www.sfml-dev.org/) or later.
  * [Allegro 5.2](http://www.liballeg.org/) or later. Note, Gincu only need one render engine, SFML or Allegro, it doesn't need both.
  * My [cpgf library](https://github.com/cpgf/cpgf)
- * CMake 3.6 or later
+ * CMake 3.6 or later.
+ * Need to `clone --recursive`.
 
 ## License
 

src/gapplication.cpp

@@ -140,7 +140,7 @@ void GApplication::processMainLoop()
 
 		cpgf::GTweenList::getInstance()->tick((cpgf::GTweenNumber)this->frameMilliseconds);
 
-		this->eventQueue->send(updateEvent);
+		this->eventQueue->dispatch(updateEvent);
 
 		if(this->configInfo.renderFramesPerSecond <= 0
 			|| getMilliseconds() - lastRenderTime >= millisecondsPerRenderFrame) {
@@ -180,7 +180,7 @@ void GApplication::processEvents()
 {
 	GEvent event;
 	while(this->deviceContext->getEvent(&event)) {
-		this->eventQueue->post(event);
+		this->eventQueue->enqueue(event);
 	}
 
 	GEventQueue::dispatchAll();
@@ -221,7 +221,7 @@ void GApplication::onEvent(const GEvent & event)
 
 void GApplication::doRender(GRenderContext * renderContext)
 {
-	this->eventQueue->send(GEvent(GEventType::render, renderContext));
+	this->eventQueue->dispatch(GEvent(GEventType::render, renderContext));
 }
 
 void GApplication::doInitialize()