1 files changed, 138 insertions, 0 deletions
diff --git a/common/callback.h b/common/callback.h
new file mode 100644
index 0000000000..c6c249a511
--- /dev/null
+++ b/common/callback.h
@@ -0,0 +1,138 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef COMMON_CALLBACK_H
+#define COMMON_CALLBACK_H
+
+namespace Common {
+
+/**
+ * BaseCallback<S> is a simple base class for object-oriented callbacks.
+ *
+ * Object-oriented callbacks are such callbacks that know exact instance
+ * which method must be called.
+ *
+ * For backwards compatibility purposes, there is a GlobalFunctionCallback,
+ * which is BaseCallback<void *>, so it can be used with global C-like
+ * functions too.
+ *
+ * <S> is the type, which is passed to operator() of this callback.
+ * This allows you to specify that you accept a callback, which wants
+ * to receive an <S> object.
+ */
+template<typename S = void *> class BaseCallback {
+public:
+	BaseCallback() {}
+	virtual ~BaseCallback() {}
+	virtual void operator()(S data) = 0;
+};
+
+/**
+ * GlobalFunctionCallback<T> is a simple wrapper for global C functions.
+ *
+ * If there is a method, which accepts BaseCallback<T>, you can
+ * easily pass your C function by passing
+ *     new GlobalFunctionCallback<T>(yourFunction)
+ */
+template<typename T> class GlobalFunctionCallback: public BaseCallback<T> {
+	typedef void(*GlobalFunction)(T result);
+	GlobalFunction _callback;
+
+public:
+	GlobalFunctionCallback(GlobalFunction cb): _callback(cb) {}
+	virtual ~GlobalFunctionCallback() {}
+	virtual void operator()(T data) {
+		if (_callback) _callback(data);
+	}
+};
+
+/**
+ * Callback<T, S> implements an object-oriented callback.
+ *
+ * <T> stands for a class which method you want to call.
+ * <S>, again, is the type of an object passed to operator().
+ *
+ * So, if you have void MyClass::myMethod(AnotherClass) method,
+ * the corresponding callback is Callback<MyClass, AnotherClass>.
+ * You create it similarly to this:
+ *     new Callback<MyClass, AnotherClass>(
+ *         pointerToMyClassObject,
+ *         &MyClass::myMethod
+ *     )
+ */
+template<class T, typename S = void *> class Callback: public BaseCallback<S> {
+protected:
+	typedef void(T::*TMethod)(S);
+	T *_object;
+	TMethod _method;
+public:
+	Callback(T *object, TMethod method): _object(object), _method(method) {}
+	virtual ~Callback() {}
+	void operator()(S data) { (_object->*_method)(data); }
+};
+
+/**
+ * CallbackBridge<T, OS, S> helps you to chain callbacks.
+ *
+ * CallbackBridge keeps a pointer to BaseCallback<OS>.
+ * When its operator() is called, it passes this pointer
+ * along with the actual data (of type <S>) to the method
+ * of <T> class.
+ *
+ * This is needed when you have to call a callback only
+ * when your own callback is called. So, your callback
+ * is "inner" and the other one is "outer".
+ *
+ * CallbackBridge implements the "inner" one and calls
+ * the method you wanted. It passes the "outer", so you
+ * can call it from your method. You can ignore it, but
+ * probably there is no point in using CallbackBridge then.
+ *
+ * So, if you receive a BaseCallback<SomeClass> callback
+ * and you want to call it from your MyClass::myMethod method,
+ * you should create CallbackBridge<MyClass, SomeClass, S>,
+ * where <S> is data type you want to receive in MyClass::myMethod.
+ *
+ * You create it similarly to this:
+ *     new Callback<MyClass, SomeClass, AnotherClass>(
+ *         pointerToMyClassObject,
+ *         &MyClass::myMethod,
+ *         outerCallback
+ *     )
+ * where `outerCallback` is BaseCallback<SomeClass> and `myMethod` is:
+ * void MyClass::myMethod(BaseCallback<SomeClass>  *, AnotherClass)
+ */
+template<class T, typename OS, typename S = void *> class CallbackBridge: public BaseCallback<S> {
+	typedef void(T::*TCallbackMethod)(BaseCallback<OS> *, S);
+	T *_object;
+	TCallbackMethod _method;
+	BaseCallback<OS> *_outerCallback;
+public:
+	CallbackBridge(T *object, TCallbackMethod method, BaseCallback<OS> *outerCallback):
+		_object(object), _method(method), _outerCallback(outerCallback) {}
+	virtual ~CallbackBridge() {}
+	void operator()(S data) { (_object->*_method)(_outerCallback, data); }
+};
+
+} // End of namespace Common
+
+#endif