diff --git a/uppsrc/Core/Callback.cpp b/uppsrc/Core/Callback.cpp
index 16d2bf2f9..c016beac3 100644
--- a/uppsrc/Core/Callback.cpp
+++ b/uppsrc/Core/Callback.cpp
@@ -2,18 +2,82 @@
 
 NAMESPACE_UPP
 
-//#BLITZ_APPROVE
-#define CPP_PART__
-#include "Cbgen.h"
-
 void Callback::Execute() const
 {
 	if(action) action->Execute();
 }
 
+Callback& Callback::operator=(const Callback& c)
+{
+	c.Retain();
+	Release();
+	action = c.action;
+	return *this;
+}
+
+Callback::Callback(const Callback& c)
+{
+	action = c.action;
+	Retain();
+}
+
+Callback::~Callback()
+{
+	Release();
+}
+
+Callback callback(Callback cb1, Callback cb2)
+{
+	return Callback(new CallbackForkAction (cb1, cb2));
+}
+
+Callback& operator<<(Callback& a, Callback b)
+{
+	if(a)
+		a = callback(a, b);
+	else
+		a = b;
+	return a;
+}
+
+//
+
 bool Gate::Execute() const
 {
 	return (void *)action == (void *)1 ? true : action ? action->Execute() : false;
 }
 
+Gate& Gate::operator=(const Gate& c)
+{
+	c.Retain();
+	Release();
+	action = c.action;
+	return *this;
+}
+
+Gate::Gate(const Gate& c)
+{
+	action = c.action;
+	Retain();
+}
+
+Gate::~Gate()
+{
+	Release();
+}
+
+Gate callback(Gate cb1, Gate cb2)
+{
+	return Gate(new GateForkAction (cb1, cb2));
+}
+
+Gate& operator<<(Gate& a, Gate b)
+{
+	if(a)
+		a = callback(a, b);
+	else
+		a = b;
+	return a;
+}
+
 END_UPP_NAMESPACE
diff --git a/uppsrc/Core/Callback.h b/uppsrc/Core/Callback.h
index 4a2906777..0ab88efc8 100644
--- a/uppsrc/Core/Callback.h
+++ b/uppsrc/Core/Callback.h
@@ -4,740 +4,11 @@ template <class D, class S>
 inline D brutal_cast(const S& source) { return *(D *)&source; }
 
 #include "Cbgen.h"
-
-template <class OBJECT_, class METHOD_, class T>
-struct CallbackMethodActionArgPte : public CallbackAction {
-	Ptr<OBJECT_>  object;
-	METHOD_       method;
-	T             arg;
-
-	void    Execute() { if(object) (object->*method)(arg); }
-
-	CallbackMethodActionArgPte(OBJECT_ *object, METHOD_ method, T arg)
-	: object(object), method(method), arg(arg) {}
-};
-
-template <class Object, class M, class P, class T>
-Callback pteback1(Object *object, void (M::*method)(P), T arg) {
-	return Callback(new CallbackMethodActionArgPte<Object, void (M::*)(P), T>(object, method, arg));
-}
-
-template <class OBJECT_, class METHOD_, class T>
-struct CallbackMethodActionArg : public CallbackAction {
-	OBJECT_  *object;
-	METHOD_   method;
-	T         arg;
-
-	void    Execute() { (object->*method)(arg); }
-
-	CallbackMethodActionArg(OBJECT_ *object, METHOD_ method, T arg)
-	: object(object), method(method), arg(arg) {}
-};
-
-template <class Object, class M, class P, class T>
-Callback callback1(Object *object, void (M::*method)(P), T arg) {
-	return Callback(new CallbackMethodActionArg<Object, void (M::*)(P), T>
-	                    (object, method, arg));
-}
-
-template <class Object, class M, class P, class T>
-Callback callback1(const Object *object, void (M::*method)(P) const, T arg) {
-	return Callback(new CallbackMethodActionArg<const Object, void (M::*)(P) const, T>
-	                    (object, method, arg));
-}
-
-template <class F, class T, class HC = F>
-struct CallbackActionCallArg : public CallbackAction {
-	F         fn;
-	T         arg;
-	void    Execute() { fn(arg); }
-
-	CallbackActionCallArg(F fn, T arg) : fn(fn), arg(arg) {}
-};
-
-template <class T, class P>
-Callback callback1(void (*fn)(P), T arg)
-{
-	return Callback(new CallbackActionCallArg<void (*)(P), T, uintptr_t>(fn, arg));
-}
-
-template <class OBJECT_, class METHOD_, class P1, class T>
-struct CallbackMethodActionArg1Pte : public Callback1Action<P1> {
-	Ptr<OBJECT_>  object;
-	METHOD_       method;
-	T             arg;
-	void    Execute(P1 p1) { if(object) (object->*method)(p1, arg); }
-
-	CallbackMethodActionArg1Pte(OBJECT_ *object, METHOD_ method, T arg)
-	: object(object), method(method), arg(arg) {}
-};
-
-template <class Object, class M, class P1, class P, class T>
-Callback1<P1> pteback1(Object *object, void (M::*method)(P1, P), T arg) {
-	return Callback1<P1>(new CallbackMethodActionArg1Pte<Object, void (M::*)(P1, P), P1, T> (object, method, arg));
-}
-
-template <class OBJECT_, class METHOD_, class P1, class T>
-struct CallbackMethodActionArg1 : public Callback1Action<P1> {
-	OBJECT_  *object;
-	METHOD_   method;
-	T         arg;
-	void    Execute(P1 p1) { (object->*method)(p1, arg); }
-
-	CallbackMethodActionArg1(OBJECT_ *object, METHOD_ method, T arg)
-	: object(object), method(method), arg(arg) {}
-};
-
-template <class Object, class M, class P1, class P, class T>
-Callback1<P1> callback1(Object *object, void (M::*method)(P1, P), T arg) {
-	return Callback1<P1>(new CallbackMethodActionArg1<Object, void (M::*)(P1, P), P1, T>
-	                         (object, method, arg));
-}
-
-template <class Object, class M, class P1, class P, class T>
-Callback1<P1> callback1(const Object *object, void (M::*method)(P1, P) const, T arg) {
-	return Callback1<P1>(new CallbackMethodActionArg1<const Object, void (M::*)(P1, P) const, P1, T>
-	                         (object, method, arg));
-}
-
-template <class OBJECT_, class METHOD_, class P1, class P2, class T1>
-struct CallbackMethodActionArg1_2 : public Callback2Action<P1, P2> {
-	OBJECT_  *object;
-	METHOD_   method;
-	T1        arg1;
-	void    Execute(P1 p1, P2 p2) { (object->*method)(p1, p2, arg1);}
-
-	CallbackMethodActionArg1_2(OBJECT_ *object, METHOD_ method, T1 arg1)
-	: object(object), method(method), arg1(arg1) {}
-};
-
-template <class Object, class M, class P1, class P2, class T1>
-Callback2<P1, P2> callback1(Object *object, void (M::*method)(P1, P2, T1), T1 arg1) {
-	return Callback2<P1, P2>(new CallbackMethodActionArg1_2<Object, void (M::*)(P1, P2, T1), P1, P2, T1>
-	                         (object, method, arg1));
-}
-
-template <class Object, class M, class P1, class P2, class T1>
-Callback2<P1, P2> callback1(const Object *object, void (M::*method)(P1, P2, T1) const, T1 arg1) {
-	return Callback2<P1, P2>(new CallbackMethodActionArg1_2<const Object, void (M::*)(P1, P2, T1) const, P1, P2, T1>
-	                         (object, method, arg1));
-}
-
-template <class OBJECT_, class METHOD_, class P1, class P2, class P3, class T1>
-struct CallbackMethodActionArg1_3 : public Callback3Action<P1, P2, P3> {
-	OBJECT_  *object;
-	METHOD_   method;
-	T1        arg1;
-	void    Execute(P1 p1, P2 p2, P3 p3) { (object->*method)(p1, p2, p3, arg1);}
-
-	CallbackMethodActionArg1_3(OBJECT_ *object, METHOD_ method, T1 arg1)
-	: object(object), method(method), arg1(arg1) {}
-};
-
-template <class Object, class M, class P1, class P2, class P3, class T1>
-Callback3<P1, P2, P3> callback1(Object *object, void (M::*method)(P1, P2, P3, T1), T1 arg1) {
-	return Callback3<P1, P2, P3>(new CallbackMethodActionArg1_3<Object, void (M::*)(P1, P2, P3, T1), P1, P2, P3, T1>
-	                         (object, method, arg1));
-}
-
-template <class Object, class M, class P1, class P2, class P3, class T1>
-Callback3<P1, P2, P3> callback1(const Object *object, void (M::*method)(P1, P2, P3, T1) const, T1 arg1) {
-	return Callback3<P1, P2, P3>(new CallbackMethodActionArg1_3<const Object, void (M::*)(P1, P2, P3, T1) const, P1, P2, P3, T1>
-	                         (object, method, arg1));
-}
-
-template <class OBJECT_, class METHOD_, class P1, class P2, class P3, class P4, class T1>
-struct CallbackMethodActionArg1_4 : public Callback4Action<P1, P2, P3, P4> {
-	OBJECT_  *object;
-	METHOD_   method;
-	T1        arg1;
-	void    Execute(P1 p1, P2 p2, P3 p3, P4 p4) { (object->*method)(p1, p2, p3, p4, arg1);}
-
-	CallbackMethodActionArg1_4(OBJECT_ *object, METHOD_ method, T1 arg1)
-	: object(object), method(method), arg1(arg1) {}
-};
-
-template <class Object, class M, class P1, class P2, class P3, class P4, class T1>
-Callback4<P1, P2, P3, P4> callback1(Object *object, void (M::*method)(P1, P2, P3, P4, T1), T1 arg1) {
-	return Callback4<P1, P2, P3, P4>(new CallbackMethodActionArg1_4<Object, void (M::*)(P1, P2, P3, P4, T1), P1, P2, P3, P4, T1>
-	                         (object, method, arg1));
-}
-
-template <class Object, class M, class P1, class P2, class P3, class P4, class T1>
-Callback4<P1, P2, P3, P4> callback1(const Object *object, void (M::*method)(P1, P2, P3, P4, T1) const, T1 arg1) {
-	return Callback4<P1, P2, P3, P4>(new CallbackMethodActionArg1_4<const Object, void (M::*)(P1, P2, P3, P4, T1) const, P1, P2, P3, P4, T1>
-	                         (object, method, arg1));
-}
-
-template <class OBJECT_, class METHOD_, class P1, class T>
-struct GateMethodActionArg1 : public Gate1Action<P1> {
-	OBJECT_  *object;
-	METHOD_   method;
-	T         arg;
-	bool      Execute(P1 p1) { return (object->*method)(p1, arg); }
-
-	GateMethodActionArg1(OBJECT_ *object, METHOD_ method, T arg)
-	: object(object), method(method), arg(arg) {}
-};
-
-template <class Object, class M, class P1, class P, class T>
-Gate1<P1> callback1(Object *object, bool (M::*method)(P1, P), T arg) {
-	return Gate1<P1>(new GateMethodActionArg1<Object, bool (M::*)(P1, P), P1, T>
-	                         (object, method, arg));
-}
-
-template <class F, class P1, class T, class HC = F>
-struct CallbackActionCallArg1 : Callback1Action<P1> {
-	F         fn;
-	T         arg;
-	void    Execute(P1 p1) { fn(p1, arg); }
-
-	CallbackActionCallArg1(F fn, T arg) : fn(fn), arg(arg) {}
-};
-
-template <class T, class P1, class P>
-Callback1<P1> callback1(void (*fn)(P1, P), T arg)
-{
-	return Callback1<P1>(new CallbackActionCallArg1<void (*)(P1, P), P1, T, uintptr_t>(fn, arg));
-}
-
-template <class T, class P>
-Callback callback1(Callback1<P> cb, T arg)
-{
-	return Callback(new CallbackActionCallArg<Callback1<P>, T>(cb, arg));
-}
-
-template <class T, class P1, class P>
-Callback1<P1> callback1(Callback2<P1, P> cb, T arg) {
-	return Callback1<P1>(new CallbackActionCallArg1<Callback2<P1, P>, P1, T>(cb, arg));
-}
-
-template <class P1>
-bool Gate1<P1>::Execute(P1 p1) const {
-	return (void *)action == (void *)1 ? true : action ? action->Execute(p1) : false;
-}
-
-template <class P1, class P2>
-bool Gate2<P1, P2>::Execute(P1 p1, P2 p2) const {
-	return (void *)action == (void *)1 ? true : action ? action->Execute(p1, p2) : false;
-}
-
-template <class P1, class P2, class P3>
-bool Gate3<P1, P2, P3>::Execute(P1 p1, P2 p2, P3 p3) const {
-	return (void *)action == (void *)1 ? true : action ? action->Execute(p1, p2, p3) : false;
-}
-
-template <class P1, class P2, class P3, class P4>
-bool Gate4<P1, P2, P3, P4>::Execute(P1 p1, P2 p2, P3 p3, P4 p4) const {
-	return (void *)action == (void *)1 ? true : action ? action->Execute(p1, p2, p3, p4) : false;
-}
-
-template <class OBJECT_, class METHOD_, class T1, class T2>
-struct CallbackMethodActionArg2Pte : public CallbackAction {
-	Ptr<OBJECT_>  object;
-	METHOD_       method;
-	T1            arg1;
-	T2            arg2;
-	void    Execute() { if(object) (object->*method)(arg1, arg2); }
-
-	CallbackMethodActionArg2Pte(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2)
-	: object(object), method(method), arg1(arg1), arg2(arg2) {}
-};
-
-template <class Object, class R, class O, class A, class B, class T1, class T2>
-Callback pteback2(Object *object, R (O::*method)(A, B), T1 arg1, T2 arg2) {
-	return Callback(new CallbackMethodActionArg2Pte<Object, R (O::*)(A, B), T1, T2>
-	                    (object, method, arg1, arg2));
-}
-
-template <class OBJECT_, class METHOD_, class T1, class T2>
-struct CallbackMethodActionArg2 : public CallbackAction {
-	OBJECT_  *object;
-	METHOD_   method;
-	T1        arg1;
-	T2        arg2;
-	void    Execute() { (object->*method)(arg1, arg2); }
-
-	CallbackMethodActionArg2(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2)
-	: object(object), method(method), arg1(arg1), arg2(arg2) {}
-};
-
-template <class Object, class R, class O, class A, class B, class T1, class T2>
-Callback callback2(Object *object, R (O::*method)(A, B), T1 arg1, T2 arg2) {
-	return Callback(new CallbackMethodActionArg2<Object, R (O::*)(A, B), T1, T2>
-	                    (object, method, arg1, arg2));
-}
-
-template <class Object, class R, class O, class A, class B, class T1, class T2>
-Callback callback2(const Object *object, R (O::*method)(A, B) const, T1 arg1, T2 arg2) {
-	return Callback(new CallbackMethodActionArg2<const Object, R (O::*)(A, B) const, T1, T2>
-	                    (object, method, arg1, arg2));
-}
-
-template <class OBJECT_, class METHOD_, class P1, class T1, class T2>
-struct CallbackMethodActionArg2_1 : public Callback1Action<P1> {
-	OBJECT_  *object;
-	METHOD_   method;
-	T1        arg1;
-	T2        arg2;
-	void    Execute(P1 p1) { (object->*method)(p1, arg1, arg2); }
-
-	CallbackMethodActionArg2_1(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2)
-	: object(object), method(method), arg1(arg1), arg2(arg2) {}
-};
-
-template <class Object, class M, class P1, class T1, class T2>
-Callback1<P1> callback2(Object *object, void (M::*method)(P1, T1, T2), T1 arg1, T2 arg2) {
-	return Callback1<P1>(new CallbackMethodActionArg2_1<Object, void (M::*)(P1, T1, T2), P1, T1, T2>
-	                         (object, method, arg1, arg2));
-}
-
-template <class Object, class M, class P1, class T1, class T2>
-Callback1<P1> callback2(const Object *object, void (M::*method)(P1, T1, T2) const, T1 arg1, T2 arg2) {
-	return Callback1<P1>(new CallbackMethodActionArg2_1<const Object, void (M::*)(P1, T1, T2) const, P1, T1, T2>
-	                         (object, method, arg1, arg2));
-}
-
-template <class OBJECT_, class METHOD_, class P1, class P2, class T1, class T2>
-struct CallbackMethodActionArg2_2 : public Callback2Action<P1, P2> {
-	OBJECT_  *object;
-	METHOD_   method;
-	T1        arg1;
-	T2        arg2;
-	void    Execute(P1 p1, P2 p2) { (object->*method)(p1, p2, arg1, arg2);}
-
-	CallbackMethodActionArg2_2(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2)
-	: object(object), method(method), arg1(arg1), arg2(arg2) {}
-};
-
-template <class Object, class M, class P1, class P2, class T1, class T2>
-Callback2<P1, P2> callback2(Object *object, void (M::*method)(P1, P2, T1, T2), T1 arg1, T2 arg2) {
-	return Callback2<P1, P2>(new CallbackMethodActionArg2_2<Object, void (M::*)(P1, P2, T1, T2), P1, P2, T1, T2>
-	                         (object, method, arg1, arg2));
-}
-
-template <class Object, class M, class P1, class P2, class T1, class T2>
-Callback2<P1, P2> callback2(const Object *object, void (M::*method)(P1, P2, T1, T2) const, T1 arg1, T2 arg2) {
-	return Callback2<P1, P2>(new CallbackMethodActionArg2_2<const Object, void (M::*)(P1, P2, T1, T2) const, P1, P2, T1, T2>
-	                         (object, method, arg1, arg2));
-}
-
-template <class OBJECT_, class METHOD_, class P1, class P2, class P3, class T1, class T2>
-struct CallbackMethodActionArg2_3 : public Callback3Action<P1, P2, P3> {
-	OBJECT_  *object;
-	METHOD_   method;
-	T1        arg1;
-	T2        arg2;
-	void    Execute(P1 p1, P2 p2, P3 p3) { (object->*method)(p1, p2, p3, arg1, arg2);}
-
-	CallbackMethodActionArg2_3(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2)
-	: object(object), method(method), arg1(arg1), arg2(arg2) {}
-};
-
-template <class Object, class M, class P1, class P2, class P3, class T1, class T2>
-Callback3<P1, P2, P3> callback2(Object *object, void (M::*method)(P1, P2, P3, T1, T2), T1 arg1, T2 arg2) {
-	return Callback3<P1, P2, P3>(new CallbackMethodActionArg2_3<Object, void (M::*)(P1, P2, P3, T1, T2), P1, P2, P3, T1, T2>
-	                         (object, method, arg1, arg2));
-}
-
-template <class Object, class M, class P1, class P2, class P3, class T1, class T2>
-Callback3<P1, P2, P3> callback2(const Object *object, void (M::*method)(P1, P2, P3, T1, T2) const, T1 arg1, T2 arg2) {
-	return Callback3<P1, P2, P3>(new CallbackMethodActionArg2_3<const Object, void (M::*)(P1, P2, P3, T1, T2) const, P1, P2, P3, T1, T2>
-	                         (object, method, arg1, arg2));
-}
-
-template <class OBJECT_, class METHOD_, class P1, class P2, class P3, class P4, class T1, class T2>
-struct CallbackMethodActionArg2_4 : public Callback4Action<P1, P2, P3, P4> {
-	OBJECT_  *object;
-	METHOD_   method;
-	T1        arg1;
-	T2        arg2;
-	void    Execute(P1 p1, P2 p2, P3 p3, P4 p4) { (object->*method)(p1, p2, p3, p4, arg1, arg2);}
-
-	CallbackMethodActionArg2_4(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2)
-	: object(object), method(method), arg1(arg1), arg2(arg2) {}
-};
-
-template <class Object, class M, class P1, class P2, class P3, class P4, class T1, class T2>
-Callback4<P1, P2, P3, P4> callback2(Object *object, void (M::*method)(P1, P2, P3, P4, T1, T2), T1 arg1, T2 arg2) {
-	return Callback4<P1, P2, P3, P4>(new CallbackMethodActionArg2_4<Object, void (M::*)(P1, P2, P3, P4, T1, T2), P1, P2, P3, P4, T1, T2>
-	                         (object, method, arg1, arg2));
-}
-
-template <class Object, class M, class P1, class P2, class P3, class P4, class T1, class T2>
-Callback4<P1, P2, P3, P4> callback2(const Object *object, void (M::*method)(P1, P2, P3, P4, T1, T2) const, T1 arg1, T2 arg2) {
-	return Callback4<P1, P2, P3, P4>(new CallbackMethodActionArg2_4<const Object, void (M::*)(P1, P2, P3, P4, T1, T2) const, P1, P2, P3, P4, T1, T2>
-	                         (object, method, arg1, arg2));
-}
-
-template <class X, class T1, class T2, class HC = X>
-struct CallbackActionCallArg2 : public CallbackAction {
-	X         x;
-	T1        arg1;
-	T2        arg2;
-	void    Execute() { x(arg1, arg2); }
-
-	CallbackActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(arg1), arg2(arg2) {}
-};
-
-template <class R, class A, class B, class T1, class T2>
-Callback callback2(R (*fn)(A, B), T1 arg1, T2 arg2) {
-	return Callback(new CallbackActionCallArg2<R (*)(A, B), T1, T2, uintptr_t>(fn, arg1, arg2));
-}
-
-template <class A, class B, class T1, class T2>
-Callback callback2(Callback2<A, B> cb, T1 arg1, T2 arg2) {
-	return Callback(new CallbackActionCallArg2<Callback2<A, B>, T1, T2>(cb, arg1, arg2));
-}
-
-template <class OBJECT_, class METHOD_, class T1, class T2, class T3>
-struct CallbackMethodActionArg3Pte : public CallbackAction {
-	Ptr<OBJECT_>  object;
-	METHOD_       method;
-	T1            arg1;
-	T2            arg2;
-	T3            arg3;
-	void    Execute() { if(object) (object->*method)(arg1, arg2, arg3); }
-
-	CallbackMethodActionArg3Pte(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2, T3 arg3)
-	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {}
-};
-
-template <class Object, class R, class O, class A, class B,class C, class T1, class T2, class T3>
-Callback pteback3(Object *object, R (O::*method)(A, B, C), T1 arg1, T2 arg2, T3 arg3) {
-	return Callback(new CallbackMethodActionArg3Pte<Object, R (O::*)(A,B,C), T1, T2, T3>
-	                    (object, method, arg1, arg2, arg3));
-}
-
-template <class OBJECT_, class METHOD_, class T1, class T2, class T3>
-struct CallbackMethodActionArg3 : public CallbackAction 
-{
-	OBJECT_  *object;
-	METHOD_   method;
-	T1        arg1;
-	T2        arg2;
-	T3        arg3;
-	
-	void    Execute() { (object->*method)(arg1, arg2, arg3); }
-
-	CallbackMethodActionArg3(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2, T3 arg3)
-	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {}
-};
-
-template <class Object, class R, class O, class A, class B, class C, class T1, class T2, class T3> 
-Callback callback3(Object *object, R (O::*method)(A, B, C), T1 arg1, T2 arg2, T3 arg3) 
-{
-	return Callback(
-		new CallbackMethodActionArg3<Object, R (O::*)(A, B, C), T1, T2, T3>(object, method, arg1, arg2, arg3));
-}
-
-template <class Object, class R, class O, class A, class B, class C, class T1, class T2, class T3> 
-Callback callback3(const Object *object, R (O::*method)(A, B, C) const, T1 arg1, T2 arg2, T3 arg3) {
-	return Callback(new CallbackMethodActionArg3<const Object, R (O::*)(A, B, C) const, T1, T2, T3>
-	                    (object, method, arg1, arg2, arg3));
-}
-
-template <class OBJECT_, class METHOD_, class P1, class T1, class T2, class T3>
-struct CallbackMethodActionArg3_1 : public Callback1Action<P1> {
-	OBJECT_  *object;
-	METHOD_   method;
-	T1        arg1;
-	T2        arg2;
-	T3        arg3;
-	void    Execute(P1 p1) { (object->*method)(p1, arg1, arg2, arg3); }
-
-	CallbackMethodActionArg3_1(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2, T3 arg3)
-	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {}
-};
-
-template <class Object, class M, class P1, class T1, class T2, class T3>
-Callback1<P1> callback3(Object *object, void (M::*method)(P1, T1, T2, T3), T1 arg1, T2 arg2, T3 arg3) {
-	return Callback1<P1>(new CallbackMethodActionArg3_1<Object, void (M::*)(P1, T1, T2, T3), P1, T1, T2, T3>
-	                         (object, method, arg1, arg2, arg3));
-}
-
-template <class Object, class M, class P1, class T1, class T2, class T3>
-Callback1<P1> callback3(const Object *object, void (M::*method)(P1, T1, T2, T3) const, T1 arg1, T2 arg2, T3 arg3) {
-	return Callback1<P1>(new CallbackMethodActionArg3_1<const Object, void (M::*)(P1, T1, T2, T3) const, P1, T1, T2, T3>
-	                         (object, method, arg1, arg2, arg3));
-}
-
-template <class OBJECT_, class METHOD_, class P1, class P2, class T1, class T2, class T3>
-struct CallbackMethodActionArg3_2 : public Callback2Action<P1, P2> {
-	OBJECT_  *object;
-	METHOD_   method;
-	T1        arg1;
-	T2        arg2;
-	T3        arg3;
-	void    Execute(P1 p1, P2 p2) { (object->*method)(p1, p2, arg1, arg2, arg3);}
-
-	CallbackMethodActionArg3_2(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2, T3 arg3)
-	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {}
-};
-
-template <class Object, class M, class P1, class P2, class T1, class T2, class T3>
-Callback2<P1, P2> callback3(Object *object, void (M::*method)(P1, P2, T1, T2, T3), T1 arg1, T2 arg2, T3 arg3) {
-	return Callback2<P1, P2>(new CallbackMethodActionArg3_2<Object, void (M::*)(P1, P2, T1, T2, T3), P1, P2, T1, T2, T3>
-	                         (object, method, arg1, arg2, arg3));
-}
-
-template <class Object, class M, class P1, class P2, class T1, class T2, class T3>
-Callback2<P1, P2> callback3(const Object *object, void (M::*method)(P1, P2, T1, T2, T3) const, T1 arg1, T2 arg2, T3 arg3) {
-	return Callback2<P1, P2>(new CallbackMethodActionArg3_2<const Object, void (M::*)(P1, P2, T1, T2, T3) const, P1, P2, T1, T2, T3>
-	                         (object, method, arg1, arg2, arg3));
-}
-
-template <class OBJECT_, class METHOD_, class P1, class P2, class P3, class T1, class T2, class T3>
-struct CallbackMethodActionArg3_3 : public Callback3Action<P1, P2, P3> {
-	OBJECT_  *object;
-	METHOD_   method;
-	T1        arg1;
-	T2        arg2;
-	T3        arg3;
-	void    Execute(P1 p1, P2 p2, P3 p3) { (object->*method)(p1, p2, p3, arg1, arg2, arg3);}
-
-	CallbackMethodActionArg3_3(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2, T3 arg3)
-	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {}
-};
-
-template <class Object, class M, class P1, class P2, class P3, class T1, class T2, class T3>
-Callback3<P1, P2, P3> callback3(Object *object, void (M::*method)(P1, P2, P3, T1, T2, T3), T1 arg1, T2 arg2, T3 arg3) {
-	return Callback3<P1, P2, P3>(new CallbackMethodActionArg3_3<Object, void (M::*)(P1, P2, P3, T1, T2, T3), P1, P2, P3, T1, T2, T3>
-	                         (object, method, arg1, arg2, arg3));
-}
-
-template <class Object, class M, class P1, class P2, class P3, class T1, class T2, class T3>
-Callback3<P1, P2, P3> callback3(const Object *object, void (M::*method)(P1, P2, P3, T1, T2, T3) const, T1 arg1, T2 arg2, T3 arg3) {
-	return Callback3<P1, P2, P3>(new CallbackMethodActionArg3_3<const Object, void (M::*)(P1, P2, P3, T1, T2, T3) const, P1, P2, P3, T1, T2, T3>
-	                         (object, method, arg1, arg2, arg3));
-}
-
-template <class OBJECT_, class METHOD_, class P1, class P2, class P3, class P4, class T1, class T2, class T3>
-struct CallbackMethodActionArg3_4 : public Callback4Action<P1, P2, P3, P4> {
-	OBJECT_  *object;
-	METHOD_   method;
-	T1        arg1;
-	T2        arg2;
-	T3        arg3;
-	void    Execute(P1 p1, P2 p2, P3 p3, P4 p4) { (object->*method)(p1, p2, p3, p4, arg1, arg2, arg3);}
-
-	CallbackMethodActionArg3_4(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2, T3 arg3)
-	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {}
-};
-
-template <class Object, class M, class P1, class P2, class P3, class P4, class T1, class T2, class T3>
-Callback4<P1, P2, P3, P4> callback3(Object *object, void (M::*method)(P1, P2, P3, P4, T1, T2, T3), T1 arg1, T2 arg2, T3 arg3) {
-	return Callback4<P1, P2, P3, P4>(new CallbackMethodActionArg3_4<Object, void (M::*)(P1, P2, P3, P4, T1, T2, T3), P1, P2, P3, P4, T1, T2, T3>
-	                         (object, method, arg1, arg2, arg3));
-}
-
-template <class Object, class M, class P1, class P2, class P3, class P4, class T1, class T2, class T3>
-Callback4<P1, P2, P3, P4> callback3(const Object *object, void (M::*method)(P1, P2, P3, P4, T1, T2, T3) const, T1 arg1, T2 arg2, T3 arg3) {
-	return Callback4<P1, P2, P3, P4>(new CallbackMethodActionArg3_4<const Object, void (M::*)(P1, P2, P3, P4, T1, T2, T3) const, P1, P2, P3, P4, T1, T2, T3>
-	                         (object, method, arg1, arg2, arg3));
-}
-
-template <class X, class T1, class T2, class T3, class HC = X>
-struct CallbackActionCallArg3 : public CallbackAction {
-	X         x;
-	T1        arg1;
-	T2        arg2;
-	T3        arg3;
-	void    Execute() { x(arg1, arg2, arg3); }
-
-	CallbackActionCallArg3(X x, T1 arg1, T2 arg2, T3 arg3) 
-		: x(x), arg1(arg1), arg2(arg2), arg3(arg3) {}
-};
-
-template <class R, class A, class B, class C, class T1, class T2, class T3>
-Callback callback3(R (*fn)(A, B, C), T1 arg1, T2 arg2, T3 arg3) {
-	return Callback(
-		new CallbackActionCallArg3<R (*)(A, B, C), T1, T2, T3, uintptr_t>(fn, arg1, arg2, arg3));
-}
-
-template <class A, class B, class C, class T1, class T2, class T3>
-Callback callback3(Callback3<A, B, C> cb, T1 arg1, T2 arg2, T3 arg3) {
-	return Callback(
-		new CallbackActionCallArg3<Callback3<A, B, C>, T1, T2, T3>(cb, arg1, arg2, arg3));
-}
-
-template <class OBJECT_, class METHOD_, class T1, class T2, class T3, class T4>
-struct CallbackMethodActionArg4Pte : public CallbackAction {
-	Ptr<OBJECT_>  object;
-	METHOD_       method;
-	T1            arg1;
-	T2            arg2;
-	T3            arg3;
-	T4            arg4;
-	void    Execute() { if(object) (object->*method)(arg1, arg2, arg3, arg4); }
-
-	CallbackMethodActionArg4Pte(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
-	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {}
-};
-
-template <class Object, class R, class O, class A, class B,class C, class D, class T1, class T2, class T3, class T4>
-Callback pteback4(Object *object, R (O::*method)(A, B,C,D), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
-	return Callback(new CallbackMethodActionArg4Pte<Object, R (O::*)(A, B,C,D), T1, T2, T3, T4>
-	                    (object, method, arg1, arg2, arg3, arg4));
-}
-
-template <class OBJECT_, class METHOD_, class T1, class T2, class T3, class T4>
-struct CallbackMethodActionArg4 : public CallbackAction 
-{
-	OBJECT_  *object;
-	METHOD_   method;
-	T1        arg1;
-	T2        arg2;
-	T3        arg3;
-	T4        arg4;
-	
-	void    Execute() { (object->*method)(arg1, arg2, arg3, arg4); }
-
-	CallbackMethodActionArg4(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
-	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {}
-};
-
-template <class Object, class R, class O, class A, class B, class C, class D, class T1, class T2, class T3, class T4> 
-Callback callback4(Object *object, R (O::*method)(A, B, C, D), T1 arg1, T2 arg2, T3 arg3, T4 arg4) 
-{
-	return Callback(
-		new CallbackMethodActionArg4<Object, R (O::*)(A, B, C, D), T1, T2, T3, T4>(object, method, arg1, arg2, arg3, arg4));
-}
-
-template <class Object, class R, class O, class A, class B, class C, class D, class T1, class T2, class T3, class T4> 
-Callback callback4(const Object *object, R (O::*method)(A, B, C, D) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
-	return Callback(new CallbackMethodActionArg4<const Object, R (O::*)(A, B,C,D) const, T1, T2, T3, T4>
-	                    (object, method, arg1, arg2, arg3, arg4));
-}
-
-template <class OBJECT_, class METHOD_, class P1, class T1, class T2, class T3, class T4>
-struct CallbackMethodActionArg4_1 : public Callback1Action<P1> {
-	OBJECT_  *object;
-	METHOD_   method;
-	T1        arg1;
-	T2        arg2;
-	T3        arg3;
-	T4        arg4;
-	void    Execute(P1 p1) { (object->*method)(p1, arg1, arg2, arg3, arg4); }
-
-	CallbackMethodActionArg4_1(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
-	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {}
-};
-
-template <class Object, class M, class P1, class T1, class T2, class T3, class T4>
-Callback1<P1> callback4(Object *object, void (M::*method)(P1, T1, T2, T3, T4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
-	return Callback1<P1>(new CallbackMethodActionArg4_1<Object, void (M::*)(P1, T1, T2, T3, T4), P1, T1, T2, T3, T4>
-	                         (object, method, arg1, arg2, arg3, arg4));
-}
-
-template <class Object, class M, class P1, class T1, class T2, class T3, class T4>
-Callback1<P1> callback4(const Object *object, void (M::*method)(P1, T1, T2, T3, T4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
-	return Callback1<P1>(new CallbackMethodActionArg4_1<const Object, void (M::*)(P1, T1, T2, T3, T4) const, P1, T1, T2, T3, T4>
-	                         (object, method, arg1, arg2, arg3, arg4));
-}
-
-template <class OBJECT_, class METHOD_, class P1, class P2, class T1, class T2, class T3, class T4>
-struct CallbackMethodActionArg4_2 : public Callback2Action<P1, P2> {
-	OBJECT_  *object;
-	METHOD_   method;
-	T1        arg1;
-	T2        arg2;
-	T3        arg3;
-	T4        arg4;
-	void    Execute(P1 p1, P2 p2) { (object->*method)(p1, p2, arg1, arg2, arg3, arg4);}
-
-	CallbackMethodActionArg4_2(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
-	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {}
-};
-
-template <class Object, class M, class P1, class P2, class T1, class T2, class T3, class T4>
-Callback2<P1, P2> callback4(Object *object, void (M::*method)(P1, P2, T1, T2, T3, T4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
-	return Callback2<P1, P2>(new CallbackMethodActionArg4_2<Object, void (M::*)(P1, P2, T1, T2, T3, T4), P1, P2, T1, T2, T3, T4>
-	                         (object, method, arg1, arg2, arg3, arg4));
-}
-
-template <class Object, class M, class P1, class P2, class T1, class T2, class T3, class T4>
-Callback2<P1, P2> callback4(const Object *object, void (M::*method)(P1, P2, T1, T2, T3, T4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
-	return Callback2<P1, P2>(new CallbackMethodActionArg4_2<const Object, void (M::*)(P1, P2, T1, T2, T3, T4) const, P1, P2, T1, T2, T3, T4>
-	                         (object, method, arg1, arg2, arg3, arg4));
-}
-
-template <class OBJECT_, class METHOD_, class P1, class P2, class P3, class T1, class T2, class T3, class T4>
-struct CallbackMethodActionArg4_3 : public Callback3Action<P1, P2, P3> {
-	OBJECT_  *object;
-	METHOD_   method;
-	T1        arg1;
-	T2        arg2;
-	T3        arg3;
-	T3        arg4;
-	void    Execute(P1 p1, P2 p2, P3 p3) { (object->*method)(p1, p2, p3, arg1, arg2, arg3, arg4);}
-
-	CallbackMethodActionArg4_3(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
-	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {}
-};
-
-template <class Object, class M, class P1, class P2, class P3, class T1, class T2, class T3, class T4>
-Callback3<P1, P2, P3> callback4(Object *object, void (M::*method)(P1, P2, P3, T1, T2, T3, T4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
-	return Callback3<P1, P2, P3>(new CallbackMethodActionArg4_3<Object, void (M::*)(P1, P2, P3, T1, T2, T3, T4), P1, P2, P3, T1, T2, T3, T4>
-	                         (object, method, arg1, arg2, arg3, arg4));
-}
-
-template <class Object, class M, class P1, class P2, class P3, class T1, class T2, class T3, class T4>
-Callback3<P1, P2, P3> callback4(const Object *object, void (M::*method)(P1, P2, P3, T1, T2, T3, T4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
-	return Callback3<P1, P2, P3>(new CallbackMethodActionArg4_3<const Object, void (M::*)(P1, P2, P3, T1, T2, T3, T4) const, P1, P2, P3, T1, T2, T3, T4>
-	                         (object, method, arg1, arg2, arg3, arg4));
-}
-
-template <class OBJECT_, class METHOD_, class P1, class P2, class P3, class P4, class T1, class T2, class T3, class T4>
-struct CallbackMethodActionArg4_4 : public Callback4Action<P1, P2, P3, P4> {
-	OBJECT_  *object;
-	METHOD_   method;
-	T1        arg1;
-	T2        arg2;
-	T3        arg3;
-	T4        arg4;
-	void    Execute(P1 p1, P2 p2, P3 p3, P4 p4) { (object->*method)(p1, p2, p3, p4, arg1, arg2, arg3, arg4);}
-
-	CallbackMethodActionArg4_4(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
-	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {}
-};
-
-template <class Object, class M, class P1, class P2, class P3, class P4, class T1, class T2, class T3, class T4>
-Callback4<P1, P2, P3, P4> callback4(Object *object, void (M::*method)(P1, P2, P3, P4, T1, T2, T3, T4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
-	return Callback4<P1, P2, P3, P4>(new CallbackMethodActionArg4_4<Object, void (M::*)(P1, P2, P3, P4, T1, T2, T3, T4), P1, P2, P3, P4, T1, T2, T3, T4>
-	                         (object, method, arg1, arg2, arg3, arg4));
-}
-
-template <class Object, class M, class P1, class P2, class P3, class P4, class T1, class T2, class T3, class T4>
-Callback4<P1, P2, P3, P4> callback4(const Object *object, void (M::*method)(P1, P2, P3, P4, T1, T2, T3, T4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
-	return Callback4<P1, P2, P3, P4>(new CallbackMethodActionArg4_4<const Object, void (M::*)(P1, P2, P3, P4, T1, T2, T3, T4) const, P1, P2, P3, P4, T1, T2, T3, T4>
-	                         (object, method, arg1, arg2, arg3, arg4));
-}
-
-template <class X, class T1, class T2, class T3, class T4, class HC = X>
-struct CallbackActionCallArg4 : public CallbackAction {
-	X         x;
-	T1        arg1;
-	T2        arg2;
-	T3        arg3;
-	T4        arg4;
-	void    Execute() { x(arg1, arg2, arg3, arg4); }
-
-	CallbackActionCallArg4(X x, T1 arg1, T2 arg2, T3 arg3, T4 arg4) 
-		: x(x), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {}
-};
-
-template <class R, class A, class B,class C, class D, class T1, class T2, class T3, class T4>
-Callback callback4(R (*fn)(A, B, C, D), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
-	return Callback(
-		new CallbackActionCallArg4<R (*)(A, B,C,D), T1, T2, T3, T4, uintptr_t>(fn, arg1, arg2, arg3, arg4));
-}
-
-template <class A, class B, class C, class D, class T1, class T2, class T3, class T4>
-Callback callback4(Callback4<A, B, C, D> cb, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
-	return Callback(
-		new CallbackActionCallArg4<Callback4<A, B,C,D>, T1, T2, T3, T4>(cb, arg1, arg2, arg3, arg4));
-}
+#include "Callback0.h"
+#include "Callback1.h"
+#include "Callback2.h"
+#include "Callback3.h"
+#include "Callback4.h"
 
 #define THISBACK(x)               callback(this, &CLASSNAME::x)
 #define THISBACK1(x, arg)         callback1(this, &CLASSNAME::x, arg)
@@ -751,6 +22,12 @@ Callback callback4(Callback4<A, B, C, D> cb, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
 #define PTEBACK3(m, a, b, c)      pteback3(this, &CLASSNAME::m, a, b, c)
 #define PTEBACK4(m, a, b, c, d)   pteback4(this, &CLASSNAME::m, a, b, c, d)
 
+#define STDBACK(x)                callback(&x)
+#define STDBACK1(x, arg)          callback1(&x, arg)
+#define STDBACK2(m, a, b)         callback2(&m, a, b)
+#define STDBACK3(m, a, b, c)      callback3(&m, a, b, c)
+#define STDBACK4(m, a, b, c, d)   callback4(&m, a, b, c, d)
+
 template <class T>
 class CallbackArgTarget
 {
diff --git a/uppsrc/Core/Callback0.h b/uppsrc/Core/Callback0.h
new file mode 100644
index 000000000..49bd86300
--- /dev/null
+++ b/uppsrc/Core/Callback0.h
@@ -0,0 +1,808 @@
+//0 args to Callback
+
+template <class O, class M>
+struct CallbackMethodActionPte : public CallbackAction {
+	Ptr<O>  object;
+	M       method;
+
+	void Execute() { if(object) (object->*method)(); }
+	bool IsValid() const { return object; }
+
+	CallbackMethodActionPte(O *object, M method) : object(object), method(method) {}
+};
+
+template <class O, class M>
+Callback pteback(O *object, void (M::*method)()) {
+	return Callback(new CallbackMethodActionPte<O, void (M::*)()>(object, method));
+}
+
+template <class O, class M>
+struct CallbackMethodAction : public CallbackAction {
+	O  *object;
+	M   method;
+
+	void Execute() { (object->*method)(); }
+
+	CallbackMethodAction(O *object, M method) : object(object), method(method) {}
+};
+
+template <class O, class M>
+Callback callback(O *object, void (M::*method)()) {
+	return Callback(new CallbackMethodAction<O, void (M::*)()>(object, method));
+}
+
+template <class O, class M>
+Callback callback(const O *object, void (M::*method)() const) {
+	return Callback(new CallbackMethodAction<const O, void (M::*)() const>(object, method));
+}
+
+struct CallbackFnAction : public CallbackAction {
+	void (*fn)();
+
+	void Execute() { (*fn)(); }
+
+	CallbackFnAction(void (*fn)()) : fn(fn) {}
+};
+
+inline Callback callback(void (*fn)()) {
+	return Callback(new CallbackFnAction (fn));
+}
+
+struct CallbackForkAction : public CallbackAction {
+	Callback cb1, cb2;
+
+	void Execute() { cb1(); cb2(); }
+
+	CallbackForkAction(Callback cb1, Callback cb2)
+		 : cb1(cb1), cb2(cb2) {}
+};
+
+inline Callback Proxy(Callback& cb)
+{
+	return callback(&cb, &Callback::Execute);
+}
+
+Callback callback(Callback cb1, Callback cb2);
+Callback& operator<<(Callback& a, Callback b);
+
+//0 args to Callback1
+
+template <class O, class M, class P1>
+struct Callback1MethodActionPte : public Callback1Action<P1> {
+	Ptr<O>  object;
+	M       method;
+
+	void Execute(P1 p1) { if(object) (object->*method)(p1); }
+	bool IsValid() const { return object; }
+
+	Callback1MethodActionPte(O *object, M method) : object(object), method(method) {}
+};
+
+template <class O, class M, class P1>
+Callback1<P1> pteback(O *object, void (M::*method)(P1 p1)) {
+	return Callback1<P1>(new Callback1MethodActionPte<O, void (M::*)(P1 p1), P1>(object, method));
+}
+
+template <class O, class M, class P1>
+struct Callback1MethodAction : public Callback1Action<P1> {
+	O  *object;
+	M   method;
+
+	void Execute(P1 p1) { (object->*method)(p1); }
+
+	Callback1MethodAction(O *object, M method) : object(object), method(method) {}
+};
+
+template <class O, class M, class P1>
+Callback1<P1> callback(O *object, void (M::*method)(P1 p1)) {
+	return Callback1<P1>(new Callback1MethodAction<O, void (M::*)(P1 p1), P1>(object, method));
+}
+
+template <class O, class M, class P1>
+Callback1<P1> callback(const O *object, void (M::*method)(P1 p1) const) {
+	return Callback1<P1>(new Callback1MethodAction<const O, void (M::*)(P1 p1) const, P1>(object, method));
+}
+
+template <class P1>
+struct Callback1FnAction : public Callback1Action<P1> {
+	void (*fn)(P1 p1);
+
+	void Execute(P1 p1) { (*fn)(p1); }
+
+	Callback1FnAction(void (*fn)(P1 p1)) : fn(fn) {}
+};
+
+template <class P1>
+inline Callback1<P1> callback(void (*fn)(P1 p1)) {
+	return Callback1<P1>(new Callback1FnAction <P1>(fn));
+}
+
+template <class P1>
+struct Callback1ForkAction : public Callback1Action<P1> {
+	Callback1<P1> cb1, cb2;
+
+	void Execute(P1 p1) { cb1(p1); cb2(p1); }
+
+	Callback1ForkAction(Callback1<P1> cb1, Callback1<P1> cb2)
+		 : cb1(cb1), cb2(cb2) {}
+};
+
+template <class P1>
+inline Callback1<P1> Proxy(Callback1<P1>& cb)
+{
+	return callback(&cb, &Callback1<P1>::Execute);
+}
+
+template <class P1>
+Callback1<P1> callback(Callback1<P1> cb1, Callback1<P1> cb2)
+{
+	return Callback1<P1>(new Callback1ForkAction <P1>(cb1, cb2));
+}
+
+template <class P1>
+Callback1<P1>& operator<<(Callback1<P1>& a, Callback1<P1> b)
+{
+	if(a)
+		a = callback(a, b);
+	else
+		a = b;
+	return a;
+}
+
+//0 args to Callback2
+
+template <class O, class M, class P1, class P2>
+struct Callback2MethodActionPte : public Callback2Action<P1, P2> {
+	Ptr<O>  object;
+	M       method;
+
+	void Execute(P1 p1, P2 p2) { if(object) (object->*method)(p1, p2); }
+	bool IsValid() const { return object; }
+
+	Callback2MethodActionPte(O *object, M method) : object(object), method(method) {}
+};
+
+template <class O, class M, class P1, class P2>
+Callback2<P1, P2> pteback(O *object, void (M::*method)(P1 p1, P2 p2)) {
+	return Callback2<P1, P2>(new Callback2MethodActionPte<O, void (M::*)(P1 p1, P2 p2), P1, P2>(object, method));
+}
+
+template <class O, class M, class P1, class P2>
+struct Callback2MethodAction : public Callback2Action<P1, P2> {
+	O  *object;
+	M   method;
+
+	void Execute(P1 p1, P2 p2) { (object->*method)(p1, p2); }
+
+	Callback2MethodAction(O *object, M method) : object(object), method(method) {}
+};
+
+template <class O, class M, class P1, class P2>
+Callback2<P1, P2> callback(O *object, void (M::*method)(P1 p1, P2 p2)) {
+	return Callback2<P1, P2>(new Callback2MethodAction<O, void (M::*)(P1 p1, P2 p2), P1, P2>(object, method));
+}
+
+template <class O, class M, class P1, class P2>
+Callback2<P1, P2> callback(const O *object, void (M::*method)(P1 p1, P2 p2) const) {
+	return Callback2<P1, P2>(new Callback2MethodAction<const O, void (M::*)(P1 p1, P2 p2) const, P1, P2>(object, method));
+}
+
+template <class P1, class P2>
+struct Callback2FnAction : public Callback2Action<P1, P2> {
+	void (*fn)(P1 p1, P2 p2);
+
+	void Execute(P1 p1, P2 p2) { (*fn)(p1, p2); }
+
+	Callback2FnAction(void (*fn)(P1 p1, P2 p2)) : fn(fn) {}
+};
+
+template <class P1, class P2>
+inline Callback2<P1, P2> callback(void (*fn)(P1 p1, P2 p2)) {
+	return Callback2<P1, P2>(new Callback2FnAction <P1, P2>(fn));
+}
+
+template <class P1, class P2>
+struct Callback2ForkAction : public Callback2Action<P1, P2> {
+	Callback2<P1, P2> cb1, cb2;
+
+	void Execute(P1 p1, P2 p2) { cb1(p1, p2); cb2(p1, p2); }
+
+	Callback2ForkAction(Callback2<P1, P2> cb1, Callback2<P1, P2> cb2)
+		 : cb1(cb1), cb2(cb2) {}
+};
+
+template <class P1, class P2>
+inline Callback2<P1, P2> Proxy(Callback2<P1, P2>& cb)
+{
+	return callback(&cb, &Callback2<P1, P2>::Execute);
+}
+
+template <class P1, class P2>
+Callback2<P1, P2> callback(Callback2<P1, P2> cb1, Callback2<P1, P2> cb2)
+{
+	return Callback2<P1, P2>(new Callback2ForkAction <P1, P2>(cb1, cb2));
+}
+
+template <class P1, class P2>
+Callback2<P1, P2>& operator<<(Callback2<P1, P2>& a, Callback2<P1, P2> b)
+{
+	if(a)
+		a = callback(a, b);
+	else
+		a = b;
+	return a;
+}
+
+//0 args to Callback3
+
+template <class O, class M, class P1, class P2, class P3>
+struct Callback3MethodActionPte : public Callback3Action<P1, P2, P3> {
+	Ptr<O>  object;
+	M       method;
+
+	void Execute(P1 p1, P2 p2, P3 p3) { if(object) (object->*method)(p1, p2, p3); }
+	bool IsValid() const { return object; }
+
+	Callback3MethodActionPte(O *object, M method) : object(object), method(method) {}
+};
+
+template <class O, class M, class P1, class P2, class P3>
+Callback3<P1, P2, P3> pteback(O *object, void (M::*method)(P1 p1, P2 p2, P3 p3)) {
+	return Callback3<P1, P2, P3>(new Callback3MethodActionPte<O, void (M::*)(P1 p1, P2 p2, P3 p3), P1, P2, P3>(object, method));
+}
+
+template <class O, class M, class P1, class P2, class P3>
+struct Callback3MethodAction : public Callback3Action<P1, P2, P3> {
+	O  *object;
+	M   method;
+
+	void Execute(P1 p1, P2 p2, P3 p3) { (object->*method)(p1, p2, p3); }
+
+	Callback3MethodAction(O *object, M method) : object(object), method(method) {}
+};
+
+template <class O, class M, class P1, class P2, class P3>
+Callback3<P1, P2, P3> callback(O *object, void (M::*method)(P1 p1, P2 p2, P3 p3)) {
+	return Callback3<P1, P2, P3>(new Callback3MethodAction<O, void (M::*)(P1 p1, P2 p2, P3 p3), P1, P2, P3>(object, method));
+}
+
+template <class O, class M, class P1, class P2, class P3>
+Callback3<P1, P2, P3> callback(const O *object, void (M::*method)(P1 p1, P2 p2, P3 p3) const) {
+	return Callback3<P1, P2, P3>(new Callback3MethodAction<const O, void (M::*)(P1 p1, P2 p2, P3 p3) const, P1, P2, P3>(object, method));
+}
+
+template <class P1, class P2, class P3>
+struct Callback3FnAction : public Callback3Action<P1, P2, P3> {
+	void (*fn)(P1 p1, P2 p2, P3 p3);
+
+	void Execute(P1 p1, P2 p2, P3 p3) { (*fn)(p1, p2, p3); }
+
+	Callback3FnAction(void (*fn)(P1 p1, P2 p2, P3 p3)) : fn(fn) {}
+};
+
+template <class P1, class P2, class P3>
+inline Callback3<P1, P2, P3> callback(void (*fn)(P1 p1, P2 p2, P3 p3)) {
+	return Callback3<P1, P2, P3>(new Callback3FnAction <P1, P2, P3>(fn));
+}
+
+template <class P1, class P2, class P3>
+struct Callback3ForkAction : public Callback3Action<P1, P2, P3> {
+	Callback3<P1, P2, P3> cb1, cb2;
+
+	void Execute(P1 p1, P2 p2, P3 p3) { cb1(p1, p2, p3); cb2(p1, p2, p3); }
+
+	Callback3ForkAction(Callback3<P1, P2, P3> cb1, Callback3<P1, P2, P3> cb2)
+		 : cb1(cb1), cb2(cb2) {}
+};
+
+template <class P1, class P2, class P3>
+inline Callback3<P1, P2, P3> Proxy(Callback3<P1, P2, P3>& cb)
+{
+	return callback(&cb, &Callback3<P1, P2, P3>::Execute);
+}
+
+template <class P1, class P2, class P3>
+Callback3<P1, P2, P3> callback(Callback3<P1, P2, P3> cb1, Callback3<P1, P2, P3> cb2)
+{
+	return Callback3<P1, P2, P3>(new Callback3ForkAction <P1, P2, P3>(cb1, cb2));
+}
+
+template <class P1, class P2, class P3>
+Callback3<P1, P2, P3>& operator<<(Callback3<P1, P2, P3>& a, Callback3<P1, P2, P3> b)
+{
+	if(a)
+		a = callback(a, b);
+	else
+		a = b;
+	return a;
+}
+
+//0 args to Callback4
+
+template <class O, class M, class P1, class P2, class P3, class P4>
+struct Callback4MethodActionPte : public Callback4Action<P1, P2, P3, P4> {
+	Ptr<O>  object;
+	M       method;
+
+	void Execute(P1 p1, P2 p2, P3 p3, P4 p4) { if(object) (object->*method)(p1, p2, p3, p4); }
+	bool IsValid() const { return object; }
+
+	Callback4MethodActionPte(O *object, M method) : object(object), method(method) {}
+};
+
+template <class O, class M, class P1, class P2, class P3, class P4>
+Callback4<P1, P2, P3, P4> pteback(O *object, void (M::*method)(P1 p1, P2 p2, P3 p3, P4 p4)) {
+	return Callback4<P1, P2, P3, P4>(new Callback4MethodActionPte<O, void (M::*)(P1 p1, P2 p2, P3 p3, P4 p4), P1, P2, P3, P4>(object, method));
+}
+
+template <class O, class M, class P1, class P2, class P3, class P4>
+struct Callback4MethodAction : public Callback4Action<P1, P2, P3, P4> {
+	O  *object;
+	M   method;
+
+	void Execute(P1 p1, P2 p2, P3 p3, P4 p4) { (object->*method)(p1, p2, p3, p4); }
+
+	Callback4MethodAction(O *object, M method) : object(object), method(method) {}
+};
+
+template <class O, class M, class P1, class P2, class P3, class P4>
+Callback4<P1, P2, P3, P4> callback(O *object, void (M::*method)(P1 p1, P2 p2, P3 p3, P4 p4)) {
+	return Callback4<P1, P2, P3, P4>(new Callback4MethodAction<O, void (M::*)(P1 p1, P2 p2, P3 p3, P4 p4), P1, P2, P3, P4>(object, method));
+}
+
+template <class O, class M, class P1, class P2, class P3, class P4>
+Callback4<P1, P2, P3, P4> callback(const O *object, void (M::*method)(P1 p1, P2 p2, P3 p3, P4 p4) const) {
+	return Callback4<P1, P2, P3, P4>(new Callback4MethodAction<const O, void (M::*)(P1 p1, P2 p2, P3 p3, P4 p4) const, P1, P2, P3, P4>(object, method));
+}
+
+template <class P1, class P2, class P3, class P4>
+struct Callback4FnAction : public Callback4Action<P1, P2, P3, P4> {
+	void (*fn)(P1 p1, P2 p2, P3 p3, P4 p4);
+
+	void Execute(P1 p1, P2 p2, P3 p3, P4 p4) { (*fn)(p1, p2, p3, p4); }
+
+	Callback4FnAction(void (*fn)(P1 p1, P2 p2, P3 p3, P4 p4)) : fn(fn) {}
+};
+
+template <class P1, class P2, class P3, class P4>
+inline Callback4<P1, P2, P3, P4> callback(void (*fn)(P1 p1, P2 p2, P3 p3, P4 p4)) {
+	return Callback4<P1, P2, P3, P4>(new Callback4FnAction <P1, P2, P3, P4>(fn));
+}
+
+template <class P1, class P2, class P3, class P4>
+struct Callback4ForkAction : public Callback4Action<P1, P2, P3, P4> {
+	Callback4<P1, P2, P3, P4> cb1, cb2;
+
+	void Execute(P1 p1, P2 p2, P3 p3, P4 p4) { cb1(p1, p2, p3, p4); cb2(p1, p2, p3, p4); }
+
+	Callback4ForkAction(Callback4<P1, P2, P3, P4> cb1, Callback4<P1, P2, P3, P4> cb2)
+		 : cb1(cb1), cb2(cb2) {}
+};
+
+template <class P1, class P2, class P3, class P4>
+inline Callback4<P1, P2, P3, P4> Proxy(Callback4<P1, P2, P3, P4>& cb)
+{
+	return callback(&cb, &Callback4<P1, P2, P3, P4>::Execute);
+}
+
+template <class P1, class P2, class P3, class P4>
+Callback4<P1, P2, P3, P4> callback(Callback4<P1, P2, P3, P4> cb1, Callback4<P1, P2, P3, P4> cb2)
+{
+	return Callback4<P1, P2, P3, P4>(new Callback4ForkAction <P1, P2, P3, P4>(cb1, cb2));
+}
+
+template <class P1, class P2, class P3, class P4>
+Callback4<P1, P2, P3, P4>& operator<<(Callback4<P1, P2, P3, P4>& a, Callback4<P1, P2, P3, P4> b)
+{
+	if(a)
+		a = callback(a, b);
+	else
+		a = b;
+	return a;
+}
+
+// -----------------------------------------------------------
+
+//0 args to Gate
+
+template <class O, class M>
+struct GateMethodActionPte : public GateAction {
+	Ptr<O>  object;
+	M       method;
+
+	bool Execute() { return object ? (object->*method)() : false; }
+	bool IsValid() const { return object; }
+
+	GateMethodActionPte(O *object, M method) : object(object), method(method) {}
+};
+
+template <class O, class M>
+struct GateMethodAction : public GateAction {
+	O  *object;
+	M   method;
+
+	bool Execute() { return (object->*method)(); }
+
+	GateMethodAction(O *object, M method) : object(object), method(method) {}
+};
+
+struct GateFnAction : public GateAction {
+	bool (*fn)();
+
+	bool Execute() { return (*fn)(); }
+
+	GateFnAction(bool (*fn)()) : fn(fn) {}
+};
+
+
+template <class O, class M>
+Gate pteback(O *object, bool (M::*method)()) {
+	return Gate(new GateMethodActionPte<O, bool (M::*)()>(object, method));
+}
+
+template <class O, class M>
+Gate callback(O *object, bool (M::*method)()) {
+	return Gate(new GateMethodAction<O, bool (M::*)()>(object, method));
+}
+
+template <class O, class M>
+Gate callback(const O *object, bool (M::*method)() const) {
+	return Gate(new GateMethodAction<const O, bool (M::*)() const>(object, method));
+}
+
+inline Gate callback(bool (*fn)()) {
+	return Gate(new GateFnAction (fn));
+}
+
+struct GateForkAction : public GateAction {
+	Gate cb1, cb2;
+
+	bool Execute() { cb1(); return cb2(); }
+
+	GateForkAction(Gate cb1, Gate cb2)
+		 : cb1(cb1), cb2(cb2) {}
+};
+
+inline Gate Proxy(Gate& cb)
+{
+	return callback(&cb, &Gate::Execute);
+}
+
+Gate callback(Gate cb1, Gate cb2);
+Gate& operator<<(Gate& a, Gate b);
+
+//0 args to Gate1
+
+template <class O, class M, class P1>
+struct Gate1MethodActionPte : public Gate1Action<P1> {
+	Ptr<O>  object;
+	M       method;
+
+	bool Execute(P1 p1) { return object ? (object->*method)(p1) : false; }
+	bool IsValid() const { return object; }
+
+	Gate1MethodActionPte(O *object, M method) : object(object), method(method) {}
+};
+
+template <class O, class M, class P1>
+Gate1<P1> pteback(O *object, bool (M::*method)(P1 p1)) {
+	return Gate1<P1>(new Gate1MethodActionPte<O, bool (M::*)(P1 p1), P1>(object, method));
+}
+
+template <class O, class M, class P1>
+struct Gate1MethodAction : public Gate1Action<P1> {
+	O  *object;
+	M   method;
+
+	bool Execute(P1 p1) { return (object->*method)(p1); }
+
+	Gate1MethodAction(O *object, M method) : object(object), method(method) {}
+};
+
+template <class O, class M, class P1>
+Gate1<P1> callback(O *object, bool (M::*method)(P1 p1)) {
+	return Gate1<P1>(new Gate1MethodAction<O, bool (M::*)(P1 p1), P1>(object, method));
+}
+
+template <class O, class M, class P1>
+Gate1<P1> callback(const O *object, bool (M::*method)(P1 p1) const) {
+	return Gate1<P1>(new Gate1MethodAction<const O, bool (M::*)(P1 p1) const, P1>(object, method));
+}
+
+template <class P1>
+struct Gate1FnAction : public Gate1Action<P1> {
+	bool (*fn)(P1 p1);
+
+	bool Execute(P1 p1) { return (*fn)(p1); }
+
+	Gate1FnAction(bool (*fn)(P1 p1)) : fn(fn) {}
+};
+
+template <class P1>
+inline Gate1<P1> callback(bool (*fn)(P1 p1)) {
+	return Gate1<P1>(new Gate1FnAction <P1>(fn));
+}
+
+template <class P1>
+struct Gate1ForkAction : public Gate1Action<P1> {
+	Gate1<P1> cb1, cb2;
+
+	bool Execute(P1 p1) { cb1(p1); return cb2(p1); }
+
+	Gate1ForkAction(Gate1<P1> cb1, Gate1<P1> cb2)
+		 : cb1(cb1), cb2(cb2) {}
+};
+
+template <class P1>
+inline Gate1<P1> Proxy(Gate1<P1>& cb)
+{
+	return callback(&cb, &Gate1<P1>::Execute);
+}
+
+template <class P1>
+Gate1<P1> callback(Gate1<P1> cb1, Gate1<P1> cb2)
+{
+	return Gate1<P1>(new Gate1ForkAction <P1>(cb1, cb2));
+}
+
+template <class P1>
+Gate1<P1>& operator<<(Gate1<P1>& a, Gate1<P1> b)
+{
+	if(a)
+		a = callback(a, b);
+	else
+		a = b;
+	return a;
+}
+
+//0 args to Gate2
+
+template <class O, class M, class P1, class P2>
+struct Gate2MethodActionPte : public Gate2Action<P1, P2> {
+	Ptr<O>  object;
+	M       method;
+
+	bool Execute(P1 p1, P2 p2) { return object ? (object->*method)(p1, p2) : false; }
+	bool IsValid() const { return object; }
+
+	Gate2MethodActionPte(O *object, M method) : object(object), method(method) {}
+};
+
+template <class O, class M, class P1, class P2>
+Gate2<P1, P2> pteback(O *object, bool (M::*method)(P1 p1, P2 p2)) {
+	return Gate2<P1, P2>(new Gate2MethodActionPte<O, bool (M::*)(P1 p1, P2 p2), P1, P2>(object, method));
+}
+
+template <class O, class M, class P1, class P2>
+struct Gate2MethodAction : public Gate2Action<P1, P2> {
+	O  *object;
+	M   method;
+
+	bool Execute(P1 p1, P2 p2) { return (object->*method)(p1, p2); }
+
+	Gate2MethodAction(O *object, M method) : object(object), method(method) {}
+};
+
+template <class O, class M, class P1, class P2>
+Gate2<P1, P2> callback(O *object, bool (M::*method)(P1 p1, P2 p2)) {
+	return Gate2<P1, P2>(new Gate2MethodAction<O, bool (M::*)(P1 p1, P2 p2), P1, P2>(object, method));
+}
+
+template <class O, class M, class P1, class P2>
+Gate2<P1, P2> callback(const O *object, bool (M::*method)(P1 p1, P2 p2) const) {
+	return Gate2<P1, P2>(new Gate2MethodAction<const O, bool (M::*)(P1 p1, P2 p2) const, P1, P2>(object, method));
+}
+
+template <class P1, class P2>
+struct Gate2FnAction : public Gate2Action<P1, P2> {
+	bool (*fn)(P1 p1, P2 p2);
+
+	bool Execute(P1 p1, P2 p2) { return (*fn)(p1, p2); }
+
+	Gate2FnAction(bool (*fn)(P1 p1, P2 p2)) : fn(fn) {}
+};
+
+template <class P1, class P2>
+inline Gate2<P1, P2> callback(bool (*fn)(P1 p1, P2 p2)) {
+	return Gate2<P1, P2>(new Gate2FnAction <P1, P2>(fn));
+}
+
+template <class P1, class P2>
+struct Gate2ForkAction : public Gate2Action<P1, P2> {
+	Gate2<P1, P2> cb1, cb2;
+
+	bool Execute(P1 p1, P2 p2) { cb1(p1, p2); return cb2(p1, p2); }
+
+	Gate2ForkAction(Gate2<P1, P2> cb1, Gate2<P1, P2> cb2)
+		 : cb1(cb1), cb2(cb2) {}
+};
+
+template <class P1, class P2>
+inline Gate2<P1, P2> Proxy(Gate2<P1, P2>& cb)
+{
+	return callback(&cb, &Gate2<P1, P2>::Execute);
+}
+
+template <class P1, class P2>
+Gate2<P1, P2> callback(Gate2<P1, P2> cb1, Gate2<P1, P2> cb2)
+{
+	return Gate2<P1, P2>(new Gate2ForkAction <P1, P2>(cb1, cb2));
+}
+
+template <class P1, class P2>
+Gate2<P1, P2>& operator<<(Gate2<P1, P2>& a, Gate2<P1, P2> b)
+{
+	if(a)
+		a = callback(a, b);
+	else
+		a = b;
+	return a;
+}
+
+//0 args to Gate3
+
+template <class O, class M, class P1, class P2, class P3>
+struct Gate3MethodActionPte : public Gate3Action<P1, P2, P3> {
+	Ptr<O>  object;
+	M       method;
+
+	bool Execute(P1 p1, P2 p2, P3 p3) { return object ? (object->*method)(p1, p2, p3) : false; }
+	bool IsValid() const { return object; }
+
+	Gate3MethodActionPte(O *object, M method) : object(object), method(method) {}
+};
+
+template <class O, class M, class P1, class P2, class P3>
+Gate3<P1, P2, P3> pteback(O *object, bool (M::*method)(P1 p1, P2 p2, P3 p3)) {
+	return Gate3<P1, P2, P3>(new Gate3MethodActionPte<O, bool (M::*)(P1 p1, P2 p2, P3 p3), P1, P2, P3>(object, method));
+}
+
+template <class O, class M, class P1, class P2, class P3>
+struct Gate3MethodAction : public Gate3Action<P1, P2, P3> {
+	O  *object;
+	M   method;
+
+	bool Execute(P1 p1, P2 p2, P3 p3) { return (object->*method)(p1, p2, p3); }
+
+	Gate3MethodAction(O *object, M method) : object(object), method(method) {}
+};
+
+template <class O, class M, class P1, class P2, class P3>
+Gate3<P1, P2, P3> callback(O *object, bool (M::*method)(P1 p1, P2 p2, P3 p3)) {
+	return Gate3<P1, P2, P3>(new Gate3MethodAction<O, bool (M::*)(P1 p1, P2 p2, P3 p3), P1, P2, P3>(object, method));
+}
+
+template <class O, class M, class P1, class P2, class P3>
+Gate3<P1, P2, P3> callback(const O *object, bool (M::*method)(P1 p1, P2 p2, P3 p3) const) {
+	return Gate3<P1, P2, P3>(new Gate3MethodAction<const O, bool (M::*)(P1 p1, P2 p2, P3 p3) const, P1, P2, P3>(object, method));
+}
+
+template <class P1, class P2, class P3>
+struct Gate3FnAction : public Gate3Action<P1, P2, P3> {
+	bool (*fn)(P1 p1, P2 p2, P3 p3);
+
+	bool Execute(P1 p1, P2 p2, P3 p3) { return (*fn)(p1, p2, p3); }
+
+	Gate3FnAction(bool (*fn)(P1 p1, P2 p2, P3 p3)) : fn(fn) {}
+};
+
+template <class P1, class P2, class P3>
+inline Gate3<P1, P2, P3> callback(bool (*fn)(P1 p1, P2 p2, P3 p3)) {
+	return Gate3<P1, P2, P3>(new Gate3FnAction <P1, P2, P3>(fn));
+}
+
+template <class P1, class P2, class P3>
+struct Gate3ForkAction : public Gate3Action<P1, P2, P3> {
+	Gate3<P1, P2, P3> cb1, cb2;
+
+	bool Execute(P1 p1, P2 p2, P3 p3) { cb1(p1, p2, p3); return cb2(p1, p2, p3); }
+
+	Gate3ForkAction(Gate3<P1, P2, P3> cb1, Gate3<P1, P2, P3> cb2)
+		 : cb1(cb1), cb2(cb2) {}
+};
+
+template <class P1, class P2, class P3>
+inline Gate3<P1, P2, P3> Proxy(Gate3<P1, P2, P3>& cb)
+{
+	return callback(&cb, &Gate3<P1, P2, P3>::Execute);
+}
+
+template <class P1, class P2, class P3>
+Gate3<P1, P2, P3> callback(Gate3<P1, P2, P3> cb1, Gate3<P1, P2, P3> cb2)
+{
+	return Gate3<P1, P2, P3>(new Gate3ForkAction <P1, P2, P3>(cb1, cb2));
+}
+
+template <class P1, class P2, class P3>
+Gate3<P1, P2, P3>& operator<<(Gate3<P1, P2, P3>& a, Gate3<P1, P2, P3> b)
+{
+	if(a)
+		a = callback(a, b);
+	else
+		a = b;
+	return a;
+}
+
+//0 args to Gate4
+
+template <class O, class M, class P1, class P2, class P3, class P4>
+struct Gate4MethodActionPte : public Gate4Action<P1, P2, P3, P4> {
+	Ptr<O>  object;
+	M       method;
+
+	bool Execute(P1 p1, P2 p2, P3 p3, P4 p4) { return object ? (object->*method)(p1, p2, p3, p4) : false; }
+	bool IsValid() const { return object; }
+
+	Gate4MethodActionPte(O *object, M method) : object(object), method(method) {}
+};
+
+template <class O, class M, class P1, class P2, class P3, class P4>
+Gate4<P1, P2, P3, P4> pteback(O *object, bool (M::*method)(P1 p1, P2 p2, P3 p3, P4 p4)) {
+	return Gate4<P1, P2, P3, P4>(new Gate4MethodActionPte<O, bool (M::*)(P1 p1, P2 p2, P3 p3, P4 p4), P1, P2, P3, P4>(object, method));
+}
+
+template <class O, class M, class P1, class P2, class P3, class P4>
+struct Gate4MethodAction : public Gate4Action<P1, P2, P3, P4> {
+	O  *object;
+	M   method;
+
+	bool Execute(P1 p1, P2 p2, P3 p3, P4 p4) { return (object->*method)(p1, p2, p3, p4); }
+
+	Gate4MethodAction(O *object, M method) : object(object), method(method) {}
+};
+
+template <class O, class M, class P1, class P2, class P3, class P4>
+Gate4<P1, P2, P3, P4> callback(O *object, bool (M::*method)(P1 p1, P2 p2, P3 p3, P4 p4)) {
+	return Gate4<P1, P2, P3, P4>(new Gate4MethodAction<O, bool (M::*)(P1 p1, P2 p2, P3 p3, P4 p4), P1, P2, P3, P4>(object, method));
+}
+
+template <class O, class M, class P1, class P2, class P3, class P4>
+Gate4<P1, P2, P3, P4> callback(const O *object, bool (M::*method)(P1 p1, P2 p2, P3 p3, P4 p4) const) {
+	return Gate4<P1, P2, P3, P4>(new Gate4MethodAction<const O, bool (M::*)(P1 p1, P2 p2, P3 p3, P4 p4) const, P1, P2, P3, P4>(object, method));
+}
+
+template <class P1, class P2, class P3, class P4>
+struct Gate4FnAction : public Gate4Action<P1, P2, P3, P4> {
+	bool (*fn)(P1 p1, P2 p2, P3 p3, P4 p4);
+
+	bool Execute(P1 p1, P2 p2, P3 p3, P4 p4) { return (*fn)(p1, p2, p3, p4); }
+
+	Gate4FnAction(bool (*fn)(P1 p1, P2 p2, P3 p3, P4 p4)) : fn(fn) {}
+};
+
+template <class P1, class P2, class P3, class P4>
+inline Gate4<P1, P2, P3, P4> callback(bool (*fn)(P1 p1, P2 p2, P3 p3, P4 p4)) {
+	return Gate4<P1, P2, P3, P4>(new Gate4FnAction <P1, P2, P3, P4>(fn));
+}
+
+template <class P1, class P2, class P3, class P4>
+struct Gate4ForkAction : public Gate4Action<P1, P2, P3, P4> {
+	Gate4<P1, P2, P3, P4> cb1, cb2;
+
+	bool Execute(P1 p1, P2 p2, P3 p3, P4 p4) { cb1(p1, p2, p3, p4); return cb2(p1, p2, p3, p4); }
+
+	Gate4ForkAction(Gate4<P1, P2, P3, P4> cb1, Gate4<P1, P2, P3, P4> cb2)
+		 : cb1(cb1), cb2(cb2) {}
+};
+
+template <class P1, class P2, class P3, class P4>
+inline Gate4<P1, P2, P3, P4> Proxy(Gate4<P1, P2, P3, P4>& cb)
+{
+	return callback(&cb, &Gate4<P1, P2, P3, P4>::Execute);
+}
+
+template <class P1, class P2, class P3, class P4>
+Gate4<P1, P2, P3, P4> callback(Gate4<P1, P2, P3, P4> cb1, Gate4<P1, P2, P3, P4> cb2)
+{
+	return Gate4<P1, P2, P3, P4>(new Gate4ForkAction <P1, P2, P3, P4>(cb1, cb2));
+}
+
+template <class P1, class P2, class P3, class P4>
+Gate4<P1, P2, P3, P4>& operator<<(Gate4<P1, P2, P3, P4>& a, Gate4<P1, P2, P3, P4> b)
+{
+	if(a)
+		a = callback(a, b);
+	else
+		a = b;
+	return a;
+}
diff --git a/uppsrc/Core/Callback1.h b/uppsrc/Core/Callback1.h
new file mode 100644
index 000000000..2f024478a
--- /dev/null
+++ b/uppsrc/Core/Callback1.h
@@ -0,0 +1,518 @@
+//1 arg to Callback
+
+template <class O, class M, class T>
+struct CallbackMethodActionArgPte : public CallbackAction {
+	Ptr<O>  object;
+	M       method;
+	T             arg;
+
+	void    Execute() { if(object) (object->*method)(arg); }
+
+	CallbackMethodActionArgPte(O *object, M method, T arg)
+	: object(object), method(method), arg(arg) {}
+};
+
+template <class O, class M, class Q, class T>
+Callback pteback1(O *object, void (M::*method)(Q), T arg) {
+	return Callback(new CallbackMethodActionArgPte<O, void (M::*)(Q), T>(object, method, arg));
+}
+
+template <class O, class M, class T>
+struct CallbackMethodActionArg : public CallbackAction {
+	O  *object;
+	M   method;
+	T         arg;
+
+	void    Execute() { (object->*method)(arg); }
+
+	CallbackMethodActionArg(O *object, M method, T arg)
+	: object(object), method(method), arg(arg) {}
+};
+
+template <class O, class M, class Q, class T>
+Callback callback1(O *object, void (M::*method)(Q), T arg) {
+	return Callback(new CallbackMethodActionArg<O, void (M::*)(Q), T>
+	                    (object, method, arg));
+}
+
+template <class O, class M, class Q, class T>
+Callback callback1(const O *object, void (M::*method)(Q) const, T arg) {
+	return Callback(new CallbackMethodActionArg<const O, void (M::*)(Q) const, T>
+	                    (object, method, arg));
+}
+
+template <class F, class T, class HC = F>
+struct CallbackActionCallArg : public CallbackAction {
+	F         fn;
+	T         arg;
+	void    Execute() { fn(arg); }
+
+	CallbackActionCallArg(F fn, T arg) : fn(fn), arg(arg) {}
+};
+
+template <class Q, class T>
+Callback callback1(void (*fn)(Q), T arg)
+{
+	return Callback(new CallbackActionCallArg<void (*)(Q), T, uintptr_t>(fn, arg));
+}
+
+//reduct
+template <class Q, class T>
+Callback callback1(Callback1<Q> cb, T arg)
+{
+	return Callback(new CallbackActionCallArg<Callback1<Q>, T>(cb, arg));
+}
+
+//1 arg to Callback1
+
+template <class O, class M, class P1, class T>
+struct Callback1MethodActionArgPte : public Callback1Action<P1> {
+	Ptr<O>  object;
+	M       method;
+	T             arg;
+	void    Execute(P1 p1) { if(object) (object->*method)(p1, arg); }
+
+	Callback1MethodActionArgPte(O *object, M method, T arg)
+	: object(object), method(method), arg(arg) {}
+};
+
+template <class O, class M, class P1, class Q, class T>
+Callback1<P1> pteback1(O *object, void (M::*method)(P1, Q), T arg) {
+	return Callback1<P1>(new Callback1MethodActionArgPte<O, void (M::*)(P1, Q), P1, T> (object, method, arg));
+}
+
+template <class O, class M, class P1, class T>
+struct Callback1MethodActionArg : public Callback1Action<P1> {
+	O  *object;
+	M   method;
+	T         arg;
+	void    Execute(P1 p1) { (object->*method)(p1, arg); }
+
+	Callback1MethodActionArg(O *object, M method, T arg)
+	: object(object), method(method), arg(arg) {}
+};
+
+template <class O, class M, class P1, class Q, class T>
+Callback1<P1> callback1(O *object, void (M::*method)(P1, Q), T arg) {
+	return Callback1<P1>(new Callback1MethodActionArg<O, void (M::*)(P1, Q), P1, T>
+	                         (object, method, arg));
+}
+
+template <class O, class M, class P1, class Q, class T>
+Callback1<P1> callback1(const O *object, void (M::*method)(P1, Q) const, T arg) {
+	return Callback1<P1>(new Callback1MethodActionArg<const O, void (M::*)(P1, Q) const, P1, T>
+	                         (object, method, arg));
+}
+
+template <class F, class P1, class T, class HC = F>
+struct Callback1ActionCallArg : public Callback1Action<P1> {
+	F         fn;
+	T         arg;
+	void    Execute(P1 p1) { fn(p1, arg); }
+
+	Callback1ActionCallArg(F fn, T arg) : fn(fn), arg(arg) {}
+};
+
+template <class P1, class Q, class T>
+Callback1<P1> callback1(void (*fn)(P1, Q), T arg)
+{
+	return Callback1<P1>(new Callback1ActionCallArg<void (*)(P1, Q), P1, T, uintptr_t>(fn, arg));
+}
+
+//reduct
+template <class P1, class Q, class T>
+Callback1<P1> callback1(Callback2<P1, Q> cb, T arg) {
+	return Callback1<P1>(new Callback1ActionCallArg<Callback2<P1, Q>, P1, T>(cb, arg));
+}
+
+//1 arg to Callback2
+
+template <class O, class M, class P1, class P2, class T>
+struct Callback2MethodActionArg : public Callback2Action<P1, P2> {
+	O  *object;
+	M   method;
+	T         arg;
+	void    Execute(P1 p1, P2 p2) { (object->*method)(p1, p2, arg); }
+
+	Callback2MethodActionArg(O *object, M method, T arg)
+	: object(object), method(method), arg(arg) {}
+};
+
+template <class O, class M, class P1, class P2, class Q, class T>
+Callback2<P1, P2> callback1(O *object, void (M::*method)(P1, P2, Q), T arg) {
+	return Callback2<P1, P2>(new Callback2MethodActionArg<O, void (M::*)(P1, P2, Q), P1, P2, T>
+	                         (object, method, arg));
+}
+
+template <class O, class M, class P1, class P2, class Q, class T>
+Callback2<P1, P2> callback1(const O *object, void (M::*method)(P1, P2, Q) const, T arg) {
+	return Callback2<P1, P2>(new Callback2MethodActionArg<const O, void (M::*)(P1, P2, Q) const, P1, P2, T>
+	                         (object, method, arg));
+}
+
+template <class F, class P1, class P2, class T, class HC = F>
+struct Callback2ActionCallArg : Callback2Action<P1, P2> {
+	F         fn;
+	T         arg;
+	void    Execute(P1 p1, P2 p2) { fn(p1, p2, arg); }
+
+	Callback2ActionCallArg(F fn, T arg) : fn(fn), arg(arg) {}
+};
+
+template <class P1, class P2, class Q, class T>
+Callback2<P1, P2> callback1(void (*fn)(P1, P2, Q), T arg)
+{
+	return Callback2<P1, P2>(new Callback2ActionCallArg<void (*)(P1, P2, Q), P1, P2, T, uintptr_t>(fn, arg));
+}
+
+//reduct
+template <class P1, class P2, class Q, class T>
+Callback2<P1, P2> callback1(Callback3<P1, P2, Q> cb, T arg) {
+	return Callback2<P1, P2>(new Callback2ActionCallArg<Callback3<P1, P2, Q>, P1, P2, T>(cb, arg));
+}
+
+//1 arg to Callback3
+
+template <class O, class M, class P1, class P2, class P3, class T>
+struct Callback3MethodActionArg : public Callback3Action<P1, P2, P3> {
+	O  *object;
+	M   method;
+	T         arg;
+	void    Execute(P1 p1, P2 p2, P3 p3) { (object->*method)(p1, p2, p3, arg); }
+
+	Callback3MethodActionArg(O *object, M method, T arg)
+	: object(object), method(method), arg(arg) {}
+};
+
+template <class O, class M, class P1, class P2, class P3, class Q, class T>
+Callback3<P1, P2, P3> callback1(O *object, void (M::*method)(P1, P2, P3, Q), T arg) {
+	return Callback3<P1, P2, P3>(new Callback3MethodActionArg<O, void (M::*)(P1, P2, P3, Q), P1, P2, P3, T>
+	                         (object, method, arg));
+}
+
+template <class O, class M, class P1, class P2, class P3, class Q, class T>
+Callback3<P1, P2, P3> callback1(const O *object, void (M::*method)(P1, P2, P3, Q) const, T arg) {
+	return Callback3<P1, P2, P3>(new Callback3MethodActionArg<const O, void (M::*)(P1, P2, P3, Q) const, P1, P2, P3, T>
+	                         (object, method, arg));
+}
+
+template <class F, class P1, class P2, class P3, class T, class HC = F>
+struct Callback3ActionCallArg : Callback3Action<P1, P2, P3> {
+	F         fn;
+	T         arg;
+	void    Execute(P1 p1, P2 p2, P3 p3) { fn(p1, p2, p3, arg); }
+
+	Callback3ActionCallArg(F fn, T arg) : fn(fn), arg(arg) {}
+};
+
+template <class P1, class P2, class P3, class Q, class T>
+Callback3<P1, P2, P3> callback1(void (*fn)(P1, P2, P3, Q), T arg)
+{
+	return Callback3<P1, P2, P3>(new Callback3ActionCallArg<void (*)(P1, P2, P3, Q), P1, P2, P3, T, uintptr_t>(fn, arg));
+}
+
+//reduct
+template <class P1, class P2, class P3, class Q, class T>
+Callback3<P1, P2, P3> callback1(Callback4<P1, P2, P3, Q> cb, T arg) {
+	return Callback3<P1, P2, P3>(new Callback3ActionCallArg<Callback4<P1, P2, P3, Q>, P1, P2, P3, T>(cb, arg));
+}
+
+//1 arg to Callback4
+
+template <class O, class M, class P1, class P2, class P3, class P4, class T>
+struct Callback4MethodActionArg : public Callback4Action<P1, P2, P3, P4> {
+	O  *object;
+	M   method;
+	T         arg;
+	void    Execute(P1 p1, P2 p2, P3 p3, P4 p4) { (object->*method)(p1, p2, p3, p4, arg); }
+
+	Callback4MethodActionArg(O *object, M method, T arg)
+	: object(object), method(method), arg(arg) {}
+};
+
+template <class O, class M, class P1, class P2, class P3, class P4, class Q, class T>
+Callback4<P1, P2, P3, P4> callback1(O *object, void (M::*method)(P1, P2, P3, P4, Q), T arg) {
+	return Callback4<P1, P2, P3, P4>(new Callback4MethodActionArg<O, void (M::*)(P1, P2, P3, P4, Q), P1, P2, P3, P4, T>
+	                         (object, method, arg));
+}
+
+template <class O, class M, class P1, class P2, class P3, class P4, class Q, class T>
+Callback4<P1, P2, P3, P4> callback1(const O *object, void (M::*method)(P1, P2, P3, P4, Q) const, T arg) {
+	return Callback4<P1, P2, P3, P4>(new Callback4MethodActionArg<const O, void (M::*)(P1, P2, P3, P4, Q) const, P1, P2, P3, P4, T>
+	                         (object, method, arg));
+}
+
+template <class F, class P1, class P2, class P3, class P4, class T, class HC = F>
+struct Callback4ActionCallArg : Callback4Action<P1, P2, P3, P4> {
+	F         fn;
+	T         arg;
+	void    Execute(P1 p1, P2 p2, P3 p3, P4 p4) { fn(p1, p2, p3, p4, arg); }
+
+	Callback4ActionCallArg(F fn, T arg) : fn(fn), arg(arg) {}
+};
+
+template <class P1, class P2, class P3, class P4, class Q, class T>
+Callback4<P1, P2, P3, P4> callback1(void (*fn)(P1, P2, P3, P4, Q), T arg)
+{
+	return Callback4<P1, P2, P3, P4>(new Callback4ActionCallArg<void (*)(P1, P2, P3, P4, Q), P1, P2, P3, P4, T, uintptr_t>(fn, arg));
+}
+
+// -------------------------------------------------------
+
+//1 arg to Gate
+
+template <class O, class M, class T>
+struct GateMethodActionArgPte : public GateAction {
+	Ptr<O>  object;
+	M       method;
+	T             arg;
+
+	bool    Execute() { return object? (object->*method)(arg) : false; }
+
+	GateMethodActionArgPte(O *object, M method, T arg)
+	: object(object), method(method), arg(arg) {}
+};
+
+template <class O, class M, class Q, class T>
+Gate pteback1(O *object, bool (M::*method)(Q), T arg) {
+	return Gate(new GateMethodActionArgPte<O, bool (M::*)(Q), T>(object, method, arg));
+}
+
+template <class O, class M, class T>
+struct GateMethodActionArg : public GateAction {
+	O  *object;
+	M   method;
+	T         arg;
+	bool      Execute() { return object ? (object->*method)(arg) : false; }
+
+	GateMethodActionArg(O *object, M method, T arg)
+	: object(object), method(method), arg(arg) {}
+};
+
+template <class O, class M, class Q, class T>
+Gate callback1(O *object, bool (M::*method)(Q), T arg) {
+	return Gate(new GateMethodActionArg<O, bool (M::*)(Q), T>
+	                         (object, method, arg));
+}
+
+template <class O, class M, class Q, class T>
+Gate callback1(const O *object, bool (M::*method)(Q) const, T arg) {
+	return Gate(new GateMethodActionArg<const O, bool (M::*)(Q) const, T>
+	                         (object, method, arg));
+}
+
+template <class F, class T, class HC = F>
+struct GateActionCallArg : public GateAction {
+	F         fn;
+	T         arg;
+	bool    Execute() { return fn(arg); }
+
+	GateActionCallArg(F fn, T arg) : fn(fn), arg(arg) {}
+};
+
+template <class Q, class T>
+Gate callback1(bool (*fn)(Q), T arg)
+{
+	return Gate(new GateActionCallArg<bool (*)(Q), T, uintptr_t>(fn, arg));
+}
+
+//reduct
+template <class Q, class T>
+Gate callback1(Gate1<Q> cb, T arg)
+{
+	return Gate(new GateActionCallArg<Gate1<Q>, T>(cb, arg));
+}
+
+//1 arg to Gate1
+
+template <class O, class M, class P1, class T>
+struct Gate1MethodActionArgPte : public Gate1Action<P1> {
+	Ptr<O>  object;
+	M       method;
+	T             arg;
+	bool    Execute(P1 p1) { return object ? (object->*method)(p1, arg) : false; }
+
+	Gate1MethodActionArgPte(O *object, M method, T arg)
+	: object(object), method(method), arg(arg) {}
+};
+
+template <class O, class M, class P1, class Q, class T>
+Gate1<P1> pteback1(O *object, bool (M::*method)(P1, Q), T arg) {
+	return Gate1<P1>(new Gate1MethodActionArgPte<O, bool (M::*)(P1, Q), P1, T> (object, method, arg));
+}
+
+template <class O, class M, class P1, class T>
+struct Gate1MethodActionArg : public Gate1Action<P1> {
+	O  *object;
+	M   method;
+	T         arg;
+	bool      Execute(P1 p1) { return object ? (object->*method)(p1, arg) : false; }
+
+	Gate1MethodActionArg(O *object, M method, T arg)
+	: object(object), method(method), arg(arg) {}
+};
+
+template <class O, class M, class P1, class Q, class T>
+Gate1<P1> callback1(O *object, bool (M::*method)(P1, Q), T arg) {
+	return Gate1<P1>(new Gate1MethodActionArg<O, bool (M::*)(P1, Q), P1, T>
+	                         (object, method, arg));
+}
+
+template <class O, class M, class P1, class Q, class T>
+Gate1<P1> callback1(const O *object, bool (M::*method)(P1, Q) const, T arg) {
+	return Gate1<P1>(new Gate1MethodActionArg<const O, bool (M::*)(P1, Q) const, P1, T>
+	                         (object, method, arg));
+}
+
+template <class F, class P1, class T, class HC = F>
+struct Gate1ActionCallArg : public Gate1Action<P1> {
+	F         fn;
+	T         arg;
+	bool    Execute(P1 p1) { return fn(p1, arg); }
+
+	Gate1ActionCallArg(F fn, T arg) : fn(fn), arg(arg) {}
+};
+
+template <class P1, class Q, class T>
+Gate1<P1> callback1(bool (*fn)(P1, Q), T arg)
+{
+	return Gate1<P1>(new Gate1ActionCallArg<bool (*)(P1, Q), P1, T, uintptr_t>(fn, arg));
+}
+
+//reduct
+template <class P1, class Q, class T>
+Gate1<P1> callback1(Gate2<P1, Q> cb, T arg) {
+	return Gate1<P1>(new Gate1ActionCallArg<Gate2<P1, Q>, P1, T>(cb, arg));
+}
+
+//1 arg to Gate2
+
+template <class O, class M, class P1, class P2, class T>
+struct Gate2MethodActionArg : public Gate2Action<P1, P2> {
+	O  *object;
+	M   method;
+	T         arg;
+	bool    Execute(P1 p1, P2 p2) { return object ? (object->*method)(p1, p2, arg) : false; }
+
+	Gate2MethodActionArg(O *object, M method, T arg)
+	: object(object), method(method), arg(arg) {}
+};
+
+template <class O, class M, class P1, class P2, class Q, class T>
+Gate2<P1, P2> callback1(O *object, bool (M::*method)(P1, P2, Q), T arg) {
+	return Gate2<P1, P2>(new Gate2MethodActionArg<O, bool (M::*)(P1, P2, Q), P1, P2, T>
+	                         (object, method, arg));
+}
+
+template <class O, class M, class P1, class P2, class Q, class T>
+Gate2<P1, P2> callback1(const O *object, bool (M::*method)(P1, P2, Q) const, T arg) {
+	return Gate2<P1, P2>(new Gate2MethodActionArg<const O, bool (M::*)(P1, P2, Q) const, P1, P2, T>
+	                         (object, method, arg));
+}
+
+template <class F, class P1, class P2, class T, class HC = F>
+struct Gate2ActionCallArg : Gate2Action<P1, P2> {
+	F         fn;
+	T         arg;
+	bool    Execute(P1 p1, P2 p2) { return fn(p1, p2, arg); }
+
+	Gate2ActionCallArg(F fn, T arg) : fn(fn), arg(arg) {}
+};
+
+template <class P1, class P2, class Q, class T>
+Gate2<P1, P2> callback1(bool (*fn)(P1, P2, Q), T arg)
+{
+	return Gate2<P1, P2>(new Gate2ActionCallArg<bool (*)(P1, P2, Q), P1, P2, T, uintptr_t>(fn, arg));
+}
+
+//reduct
+template <class P1, class P2, class Q, class T>
+Gate2<P1, P2> callback1(Gate3<P1, P2, Q> cb, T arg) {
+	return Gate2<P1, P2>(new Gate2ActionCallArg<Gate3<P1, P2, Q>, P1, P2, T>(cb, arg));
+}
+
+//1 arg to Gate3
+
+template <class O, class M, class P1, class P2, class P3, class T>
+struct Gate3MethodActionArg : public Gate3Action<P1, P2, P3> {
+	O  *object;
+	M   method;
+	T         arg;
+	bool    Execute(P1 p1, P2 p2, P3 p3) { return object ? (object->*method)(p1, p2, p3, arg) : false; }
+
+	Gate3MethodActionArg(O *object, M method, T arg)
+	: object(object), method(method), arg(arg) {}
+};
+
+template <class O, class M, class P1, class P2, class P3, class Q, class T>
+Gate3<P1, P2, P3> callback1(O *object, bool (M::*method)(P1, P2, P3, Q), T arg) {
+	return Gate3<P1, P2, P3>(new Gate3MethodActionArg<O, bool (M::*)(P1, P2, P3, Q), P1, P2, P3, T>
+	                         (object, method, arg));
+}
+
+template <class O, class M, class P1, class P2, class P3, class Q, class T>
+Gate3<P1, P2, P3> callback1(const O *object, bool (M::*method)(P1, P2, P3, Q) const, T arg) {
+	return Gate3<P1, P2, P3>(new Gate3MethodActionArg<const O, bool (M::*)(P1, P2, P3, Q) const, P1, P2, P3, T>
+	                         (object, method, arg));
+}
+
+template <class F, class P1, class P2, class P3, class T, class HC = F>
+struct Gate3ActionCallArg : Gate3Action<P1, P2, P3> {
+	F         fn;
+	T         arg;
+	bool    Execute(P1 p1, P2 p2, P3 p3) { return fn(p1, p2, p3, arg); }
+
+	Gate3ActionCallArg(F fn, T arg) : fn(fn), arg(arg) {}
+};
+
+template <class P1, class P2, class P3, class Q, class T>
+Gate3<P1, P2, P3> callback1(bool (*fn)(P1, P2, P3, Q), T arg)
+{
+	return Gate3<P1, P2, P3>(new Gate3ActionCallArg<bool (*)(P1, P2, P3, Q), P1, P2, P3, T, uintptr_t>(fn, arg));
+}
+
+//reduct
+template <class P1, class P2, class P3, class Q, class T>
+Gate3<P1, P2, P3> callback1(Gate4<P1, P2, P3, Q> cb, T arg) {
+	return Gate3<P1, P2, P3>(new Gate3ActionCallArg<Gate4<P1, P2, P3, Q>, P1, P2, P3, T>(cb, arg));
+}
+
+//1 arg to Gate4
+
+template <class O, class M, class P1, class P2, class P3, class P4, class T>
+struct Gate4MethodActionArg : public Gate4Action<P1, P2, P3, P4> {
+	O  *object;
+	M   method;
+	T         arg;
+	bool    Execute(P1 p1, P2 p2, P3 p3, P4 p4) { return object ? (object->*method)(p1, p2, p3, p4, arg) : false; }
+
+	Gate4MethodActionArg(O *object, M method, T arg)
+	: object(object), method(method), arg(arg) {}
+};
+
+template <class O, class M, class P1, class P2, class P3, class P4, class Q, class T>
+Gate4<P1, P2, P3, P4> callback1(O *object, bool (M::*method)(P1, P2, P3, P4, Q), T arg) {
+	return Gate4<P1, P2, P3, P4>(new Gate4MethodActionArg<O, bool (M::*)(P1, P2, P3, P4, Q), P1, P2, P3, P4, T>
+	                         (object, method, arg));
+}
+
+template <class O, class M, class P1, class P2, class P3, class P4, class Q, class T>
+Gate4<P1, P2, P3, P4> callback1(const O *object, bool (M::*method)(P1, P2, P3, P4, Q) const, T arg) {
+	return Gate4<P1, P2, P3, P4>(new Gate4MethodActionArg<const O, bool (M::*)(P1, P2, P3, P4, Q) const, P1, P2, P3, P4, T>
+	                         (object, method, arg));
+}
+
+template <class F, class P1, class P2, class P3, class P4, class T, class HC = F>
+struct Gate4ActionCallArg : Gate4Action<P1, P2, P3, P4> {
+	F         fn;
+	T         arg;
+	bool    Execute(P1 p1, P2 p2, P3 p3, P4 p4) { return fn(p1, p2, p3, p4, arg); }
+
+	Gate4ActionCallArg(F fn, T arg) : fn(fn), arg(arg) {}
+};
+
+template <class P1, class P2, class P3, class P4, class Q, class T>
+Gate4<P1, P2, P3, P4> callback1(bool (*fn)(P1, P2, P3, P4, Q), T arg)
+{
+	return Gate4<P1, P2, P3, P4>(new Gate4ActionCallArg<bool (*)(P1, P2, P3, P4, Q), P1, P2, P3, P4, T, uintptr_t>(fn, arg));
+}
diff --git a/uppsrc/Core/Callback2.h b/uppsrc/Core/Callback2.h
new file mode 100644
index 000000000..f27c9cdc3
--- /dev/null
+++ b/uppsrc/Core/Callback2.h
@@ -0,0 +1,598 @@
+// 2 args to Callback
+
+template <class O, class M, class T1, class T2>
+struct CallbackMethodActionArg2Pte : public CallbackAction {
+	Ptr<O>  object;
+	M       method;
+	T1            arg1;
+	T2            arg2;
+	void    Execute() { if(object) (object->*method)(arg1, arg2); }
+
+	CallbackMethodActionArg2Pte(O *object, M method, T1 arg1, T2 arg2)
+	: object(object), method(method), arg1(arg1), arg2(arg2) {}
+};
+
+/* wrong type R?
+template <class O, class R, class M, class Q1, class Q2, class T1, class T2>
+Callback pteback2(O *object, R (M::*method)(Q1, Q2), T1 arg1, T2 arg2) {
+	return Callback(new CallbackMethodActionArg2Pte<O, R (M::*)(Q1, Q2), T1, T2>
+	                    (object, method, arg1, arg2));
+}
+*/
+
+template <class O, class M, class Q1, class Q2, class T1, class T2>
+Callback pteback2(O *object, void (M::*method)(Q1, Q2), T1 arg1, T2 arg2) {
+	return Callback(new CallbackMethodActionArg2Pte<O, void (M::*)(Q1, Q2), T1, T2>
+	                    (object, method, arg1, arg2));
+}
+
+template <class O, class M, class T1, class T2>
+struct CallbackMethodActionArg2 : public CallbackAction {
+	O  *object;
+	M   method;
+	T1        arg1;
+	T2        arg2;
+	void    Execute() { (object->*method)(arg1, arg2); }
+
+	CallbackMethodActionArg2(O *object, M method, T1 arg1, T2 arg2)
+	: object(object), method(method), arg1(arg1), arg2(arg2) {}
+};
+
+/* wrong type R?
+template <class O, class R, class M, class Q1, class Q2, class T1, class T2>
+Callback callback2(O *object, R (M::*method)(Q1, Q2), T1 arg1, T2 arg2) {
+	return Callback(new CallbackMethodActionArg2<O, R (M::*)(Q1, Q2), T1, T2>
+	                    (object, method, arg1, arg2));
+}
+
+template <class O, class R, class M, class Q1, class Q2, class T1, class T2>
+Callback callback2(const O *object, R (M::*method)(Q1, Q2) const, T1 arg1, T2 arg2) {
+	return Callback(new CallbackMethodActionArg2<const O, R (M::*)(Q1, Q2) const, T1, T2>
+	                    (object, method, arg1, arg2));
+}
+*/
+
+template <class O, class M, class Q1, class Q2, class T1, class T2>
+Callback callback2(O *object, void (M::*method)(Q1, Q2), T1 arg1, T2 arg2) {
+	return Callback(new CallbackMethodActionArg2<O, void (M::*)(Q1, Q2), T1, T2>
+	                    (object, method, arg1, arg2));
+}
+
+template <class O, class M, class Q1, class Q2, class T1, class T2>
+Callback callback2(const O *object, void (M::*method)(Q1, Q2) const, T1 arg1, T2 arg2) {
+	return Callback(new CallbackMethodActionArg2<const O, void (M::*)(Q1, Q2) const, T1, T2>
+	                    (object, method, arg1, arg2));
+}
+
+template <class X, class T1, class T2, class HC = X>
+struct CallbackActionCallArg2 : public CallbackAction {
+	X         x;
+	T1        arg1;
+	T2        arg2;
+	void    Execute() { x(arg1, arg2); }
+
+	CallbackActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(arg1), arg2(arg2) {}
+};
+
+/* wrong type R?
+template <class R, class Q1, class Q2, class T1, class T2>
+Callback callback2(R (*fn)(Q1, Q2), T1 arg1, T2 arg2) {
+	return Callback(new CallbackActionCallArg2<R (*)(Q1, Q2), T1, T2, uintptr_t>(fn, arg1, arg2));
+}
+*/
+
+template <class Q1, class Q2, class T1, class T2>
+Callback callback2(void (*fn)(Q1, Q2), T1 arg1, T2 arg2) {
+	return Callback(new CallbackActionCallArg2<void (*)(Q1, Q2), T1, T2, uintptr_t>(fn, arg1, arg2));
+}
+
+template <class Q1, class Q2, class T1, class T2>
+Callback callback2(Callback2<Q1, Q2> cb, T1 arg1, T2 arg2) {
+	return Callback(new CallbackActionCallArg2<Callback2<Q1, Q2>, T1, T2>(cb, arg1, arg2));
+}
+
+//2 args to Callback1
+
+template <class O, class M, class P1, class T1, class T2>
+struct Callback1MethodActionArg2 : public Callback1Action<P1> {
+	O  *object;
+	M   method;
+	T1        arg1;
+	T2        arg2;
+	void    Execute(P1 p1) { (object->*method)(p1, arg1, arg2); }
+
+	Callback1MethodActionArg2(O *object, M method, T1 arg1, T2 arg2)
+	: object(object), method(method), arg1(arg1), arg2(arg2) {}
+};
+
+template <class O, class M, class P1, class Q1, class Q2, class T1, class T2>
+Callback1<P1> callback2(O *object, void (M::*method)(P1, Q1, Q2), T1 arg1, T2 arg2) {
+	return Callback1<P1>(new Callback1MethodActionArg2<O, void (M::*)(P1, Q1, Q2), P1, T1, T2>
+	                         (object, method, arg1, arg2));
+}
+
+template <class O, class M, class P1, class Q1, class Q2, class T1, class T2>
+Callback1<P1> callback2(const O *object, void (M::*method)(P1, Q1, Q2) const, T1 arg1, T2 arg2) {
+	return Callback1<P1>(new Callback1MethodActionArg2<const O, void (M::*)(P1, Q1, Q2) const, P1, T1, T2>
+	                         (object, method, arg1, arg2));
+}
+
+template <class X, class P1, class T1, class T2, class HC = X>
+struct Callback1ActionCallArg2 : public Callback1Action<P1> {
+	X         x;
+	T1        arg1;
+	T2        arg2;
+	void    Execute(P1 p1) { x(p1, arg1, arg2); }
+
+	Callback1ActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(arg1), arg2(arg2) {}
+};
+
+/* wrong type R?
+template <class R, class P1, class Q1, class Q2, class T1, class T2>
+Callback1<P1> callback2(R (*fn)(P1, Q1, Q2), T1 arg1, T2 arg2) {
+	return Callback1<P1>(new Callback1ActionCallArg2<R (*)(P1, Q1, Q2), P1, T1, T2, uintptr_t>(fn, arg1, arg2));
+}
+*/
+
+template <class P1, class Q1, class Q2, class T1, class T2>
+Callback1<P1> callback2(void (*fn)(P1, Q1, Q2), T1 arg1, T2 arg2) {
+	return Callback1<P1>(new Callback1ActionCallArg2<void (*)(P1, Q1, Q2), P1, T1, T2, uintptr_t>(fn, arg1, arg2));
+}
+
+template <class P1, class Q1, class Q2, class T1, class T2>
+Callback1<P1> callback2(Callback3<P1, Q1, Q2> cb, T1 arg1, T2 arg2) {
+	return Callback1<P1>(new Callback1ActionCallArg2<Callback3<P1, Q1, Q2>, P1, T1, T2>(cb, arg1, arg2));
+}
+
+//2 args to Callback2
+
+template <class O, class M, class P1, class P2, class T1, class T2>
+struct Callback2MethodActionArg2 : public Callback2Action<P1, P2> {
+	O  *object;
+	M   method;
+	T1        arg1;
+	T2        arg2;
+	void    Execute(P1 p1, P2 p2) { (object->*method)(p1, p2, arg1, arg2); }
+
+	Callback2MethodActionArg2(O *object, M method, T1 arg1, T2 arg2)
+	: object(object), method(method), arg1(arg1), arg2(arg2) {}
+};
+
+template <class O, class M, class P1, class P2, class Q1, class Q2, class T1, class T2>
+Callback2<P1, P2> callback2(O *object, void (M::*method)(P1, P2, Q1, Q2), T1 arg1, T2 arg2) {
+	return Callback2<P1, P2>(new Callback2MethodActionArg2<O, void (M::*)(P1, P2, Q1, Q2), P1, P2, T1, T2>
+	                         (object, method, arg1, arg2));
+}
+
+template <class O, class M, class P1, class P2, class Q1, class Q2, class T1, class T2>
+Callback2<P1, P2> callback2(const O *object, void (M::*method)(P1, P2, Q1, Q2) const, T1 arg1, T2 arg2) {
+	return Callback2<P1, P2>(new Callback2MethodActionArg2<const O, void (M::*)(P1, P2, Q1, Q2) const, P1, P2, T1, T2>
+	                         (object, method, arg1, arg2));
+}
+
+template <class X, class P1, class P2, class T1, class T2, class HC = X>
+struct Callback2ActionCallArg2 : public Callback2Action<P1, P2> {
+	X         x;
+	T1        arg1;
+	T2        arg2;
+	void    Execute(P1 p1, P2 p2) { x(p1, p2, arg1, arg2); }
+
+	Callback2ActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(arg1), arg2(arg2) {}
+};
+
+/* wrong type R?
+template <class R, class P1, class P2, class Q1, class Q2, class T1, class T2>
+Callback2<P1, P2> callback2(R (*fn)(P1, P2, Q1, Q2), T1 arg1, T2 arg2) {
+	return Callback2<P1, P2>(new Callback2ActionCallArg2<R (*)(P1, P2, Q1, Q2), P1, P2, T1, T2, uintptr_t>(fn, arg1, arg2));
+}
+*/
+
+template <class P1, class P2, class Q1, class Q2, class T1, class T2>
+Callback2<P1, P2> callback2(void (*fn)(P1, P2, Q1, Q2), T1 arg1, T2 arg2) {
+	return Callback2<P1, P2>(new Callback2ActionCallArg2<void (*)(P1, P2, Q1, Q2), P1, P2, T1, T2, uintptr_t>(fn, arg1, arg2));
+}
+
+template <class P1, class P2, class Q1, class Q2, class T1, class T2>
+Callback2<P1, P2> callback2(Callback4<P1, P2, Q1, Q2> cb, T1 arg1, T2 arg2) {
+	return Callback2<P1, P2>(new Callback2ActionCallArg2<Callback4<P1, P2, Q1, Q2>, P1, P2, T1, T2>(cb, arg1, arg2));
+}
+
+//2 args to Callback3
+
+template <class O, class M, class P1, class P2, class P3, class T1, class T2>
+struct Callback3MethodActionArg2 : public Callback3Action<P1, P2, P3> {
+	O  *object;
+	M   method;
+	T1        arg1;
+	T2        arg2;
+	void    Execute(P1 p1, P2 p2, P3 p3) { (object->*method)(p1, p2, p3, arg1, arg2); }
+
+	Callback3MethodActionArg2(O *object, M method, T1 arg1, T2 arg2)
+	: object(object), method(method), arg1(arg1), arg2(arg2) {}
+};
+
+template <class O, class M, class P1, class P2, class P3, class Q1, class Q2, class T1, class T2>
+Callback3<P1, P2, P3> callback2(O *object, void (M::*method)(P1, P2, P3, Q1, Q2), T1 arg1, T2 arg2) {
+	return Callback3<P1, P2, P3>(new Callback3MethodActionArg2<O, void (M::*)(P1, P2, P3, Q1, Q2), P1, P2, P3, T1, T2>
+	                         (object, method, arg1, arg2));
+}
+
+template <class O, class M, class P1, class P2, class P3, class Q1, class Q2, class T1, class T2>
+Callback3<P1, P2, P3> callback2(const O *object, void (M::*method)(P1, P2, P3, Q1, Q2) const, T1 arg1, T2 arg2) {
+	return Callback3<P1, P2, P3>(new Callback3MethodActionArg2<const O, void (M::*)(P1, P2, P3, Q1, Q2) const, P1, P2, P3, T1, T2>
+	                         (object, method, arg1, arg2));
+}
+
+template <class X, class P1, class P2, class P3, class T1, class T2, class HC = X>
+struct Callback3ActionCallArg2 : public Callback3Action<P1, P2, P3> {
+	X         x;
+	T1        arg1;
+	T2        arg2;
+	void    Execute(P1 p1, P2 p2, P3 p3) { x(p1, p2, p3, arg1, arg2); }
+
+	Callback3ActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(arg1), arg2(arg2) {}
+};
+
+/* wrong type R?
+template <class R, class P1, class P2, class P3, class Q1, class Q2, class T1, class T2>
+Callback3<P1, P2, P3> callback2(R (*fn)(P1, P2, P3, Q1, Q2), T1 arg1, T2 arg2) {
+	return Callback3<P1, P2, P3>(new Callback3ActionCallArg2<R (*)(P1, P2, P3, Q1, Q2), P1, P2, P3, T1, T2, uintptr_t>(fn, arg1, arg2));
+}
+*/
+
+template <class P1, class P2, class P3, class Q1, class Q2, class T1, class T2>
+Callback3<P1, P2, P3> callback2(void (*fn)(P1, P2, P3, Q1, Q2), T1 arg1, T2 arg2) {
+	return Callback3<P1, P2, P3>(new Callback3ActionCallArg2<void (*)(P1, P2, P3, Q1, Q2), P1, P2, P3, T1, T2, uintptr_t>(fn, arg1, arg2));
+}
+
+//2 args to Callback4
+
+template <class O, class M, class P1, class P2, class P3, class P4, class T1, class T2>
+struct Callback4MethodActionArg2 : public Callback4Action<P1, P2, P3, P4> {
+	O  *object;
+	M   method;
+	T1        arg1;
+	T2        arg2;
+	void    Execute(P1 p1, P2 p2, P3 p3, P4 p4) { (object->*method)(p1, p2, p3, p4, arg1, arg2); }
+
+	Callback4MethodActionArg2(O *object, M method, T1 arg1, T2 arg2)
+	: object(object), method(method), arg1(arg1), arg2(arg2) {}
+};
+
+template <class O, class M, class P1, class P2, class P3, class P4, class Q1, class Q2, class T1, class T2>
+Callback4<P1, P2, P3, P4> callback2(O *object, void (M::*method)(P1, P2, P3, P4, Q1, Q2), T1 arg1, T2 arg2) {
+	return Callback4<P1, P2, P3, P4>(new Callback4MethodActionArg2<O, void (M::*)(P1, P2, P3, P4, Q1, Q2), P1, P2, P3, P4, T1, T2>
+	                         (object, method, arg1, arg2));
+}
+
+template <class O, class M, class P1, class P2, class P3, class P4, class Q1, class Q2, class T1, class T2>
+Callback4<P1, P2, P3, P4> callback2(const O *object, void (M::*method)(P1, P2, P3, P4, Q1, Q2) const, T1 arg1, T2 arg2) {
+	return Callback4<P1, P2, P3, P4>(new Callback4MethodActionArg2<const O, void (M::*)(P1, P2, P3, P4, Q1, Q2) const, P1, P2, P3, P4, T1, T2>
+	                         (object, method, arg1, arg2));
+}
+
+template <class X, class P1, class P2, class P3, class P4, class T1, class T2, class HC = X>
+struct Callback4ActionCallArg2 : public Callback4Action<P1, P2, P3, P4> {
+	X         x;
+	T1        arg1;
+	T2        arg2;
+	void    Execute(P1 p1, P2 p2, P3 p3, P4 p4) { x(p1, p2, p3, p4, arg1, arg2); }
+
+	Callback4ActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(arg1), arg2(arg2) {}
+};
+
+/* wrong type R?
+template <class R, class P1, class P2, class P3, class P4, class Q1, class Q2, class T1, class T2>
+Callback4<P1, P2, P3, P4> callback2(R (*fn)(P1, P2, P3, P4, Q1, Q2), T1 arg1, T2 arg2) {
+	return Callback4<P1, P2, P3, P4>(new Callback4ActionCallArg2<R (*)(P1, P2, P3, P4, Q1, Q2), P1, P2, P3, P4, T1, T2, uintptr_t>(fn, arg1, arg2));
+}
+*/
+
+template <class P1, class P2, class P3, class P4, class Q1, class Q2, class T1, class T2>
+Callback4<P1, P2, P3, P4> callback2(void (*fn)(P1, P2, P3, P4, Q1, Q2), T1 arg1, T2 arg2) {
+	return Callback4<P1, P2, P3, P4>(new Callback4ActionCallArg2<void (*)(P1, P2, P3, P4, Q1, Q2), P1, P2, P3, P4, T1, T2, uintptr_t>(fn, arg1, arg2));
+}
+
+// ---------------------------------------------------------
+
+// 2 args to Gate
+
+template <class O, class M, class T1, class T2>
+struct GateMethodActionArg2Pte : public GateAction {
+	Ptr<O>  object;
+	M       method;
+	T1            arg1;
+	T2            arg2;
+	bool    Execute() { return object ? (object->*method)(arg1, arg2) : false; }
+
+	GateMethodActionArg2Pte(O *object, M method, T1 arg1, T2 arg2)
+	: object(object), method(method), arg1(arg1), arg2(arg2) {}
+};
+
+/* ambigiuous with Callback versions
+
+template <class O, class R, class M, class Q1, class Q2, class T1, class T2>
+Gate pteback2(O *object, R (M::*method)(Q1, Q2), T1 arg1, T2 arg2) {
+	return Gate(new GateMethodActionArg2Pte<O, R (M::*)(Q1, Q2), T1, T2>
+	                    (object, method, arg1, arg2));
+}
+*/
+
+template <class O, class M, class Q1, class Q2, class T1, class T2>
+Gate pteback2(O *object, bool (M::*method)(Q1, Q2), T1 arg1, T2 arg2) {
+	return Gate(new GateMethodActionArg2Pte<O, bool (M::*)(Q1, Q2), T1, T2>
+	                    (object, method, arg1, arg2));
+}
+
+template <class O, class M, class T1, class T2>
+struct GateMethodActionArg2 : public GateAction {
+	O  *object;
+	M   method;
+	T1        arg1;
+	T2        arg2;
+	bool    Execute() { return object ? (object->*method)(arg1, arg2) : false; }
+
+	GateMethodActionArg2(O *object, M method, T1 arg1, T2 arg2)
+	: object(object), method(method), arg1(arg1), arg2(arg2) {}
+};
+
+/* ambigiuous with Callback versions
+
+template <class O, class R, class M, class Q1, class Q2, class T1, class T2>
+Gate callback2(O *object, R (M::*method)(Q1, Q2), T1 arg1, T2 arg2) {
+	return Gate(new GateMethodActionArg2<O, R (M::*)(Q1, Q2), T1, T2>
+	                    (object, method, arg1, arg2));
+}
+
+template <class O, class R, class M, class Q1, class Q2, class T1, class T2>
+Gate callback2(const O *object, R (M::*method)(Q1, Q2) const, T1 arg1, T2 arg2) {
+	return Gate(new GateMethodActionArg2<const O, R (M::*)(Q1, Q2) const, T1, T2>
+	                    (object, method, arg1, arg2));
+}
+*/
+
+template <class O, class M, class Q1, class Q2, class T1, class T2>
+Gate callback2(O *object, bool (M::*method)(Q1, Q2), T1 arg1, T2 arg2) {
+	return Gate(new GateMethodActionArg2<O, bool (M::*)(Q1, Q2), T1, T2>
+	                    (object, method, arg1, arg2));
+}
+
+template <class O, class M, class Q1, class Q2, class T1, class T2>
+Gate callback2(const O *object, bool (M::*method)(Q1, Q2) const, T1 arg1, T2 arg2) {
+	return Gate(new GateMethodActionArg2<const O, bool (M::*)(Q1, Q2) const, T1, T2>
+	                    (object, method, arg1, arg2));
+}
+
+template <class X, class T1, class T2, class HC = X>
+struct GateActionCallArg2 : public GateAction {
+	X         x;
+	T1        arg1;
+	T2        arg2;
+	bool    Execute() { return x(arg1, arg2); }
+
+	GateActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(arg1), arg2(arg2) {}
+};
+
+/* ambigiuous with Callback versions
+
+template <class R, class Q1, class Q2, class T1, class T2>
+Gate callback2(R (*fn)(Q1, Q2), T1 arg1, T2 arg2) {
+	return Gate(new GateActionCallArg2<R (*)(Q1, Q2), T1, T2, uintptr_t>(fn, arg1, arg2));
+}
+*/
+
+template <class Q1, class Q2, class T1, class T2>
+Gate callback2(bool (*fn)(Q1, Q2), T1 arg1, T2 arg2) {
+	return Gate(new GateActionCallArg2<bool (*)(Q1, Q2), T1, T2, uintptr_t>(fn, arg1, arg2));
+}
+
+template <class Q1, class Q2, class T1, class T2>
+Gate callback2(Gate2<Q1, Q2> cb, T1 arg1, T2 arg2) {
+	return Gate(new GateActionCallArg2<Gate2<Q1, Q2>, T1, T2>(cb, arg1, arg2));
+}
+
+//2 args to Gate1
+
+template <class O, class M, class P1, class T1, class T2>
+struct Gate1MethodActionArg2 : public Gate1Action<P1> {
+	O  *object;
+	M   method;
+	T1        arg1;
+	T2        arg2;
+	bool    Execute(P1 p1) { return object ? (object->*method)(p1, arg1, arg2) : false; }
+
+	Gate1MethodActionArg2(O *object, M method, T1 arg1, T2 arg2)
+	: object(object), method(method), arg1(arg1), arg2(arg2) {}
+};
+
+template <class O, class M, class P1, class Q1, class Q2, class T1, class T2>
+Gate1<P1> callback2(O *object, bool (M::*method)(P1, Q1, Q2), T1 arg1, T2 arg2) {
+	return Gate1<P1>(new Gate1MethodActionArg2<O, bool (M::*)(P1, Q1, Q2), P1, T1, T2>
+	                         (object, method, arg1, arg2));
+}
+
+template <class O, class M, class P1, class Q1, class Q2, class T1, class T2>
+Gate1<P1> callback2(const O *object, bool (M::*method)(P1, Q1, Q2) const, T1 arg1, T2 arg2) {
+	return Gate1<P1>(new Gate1MethodActionArg2<const O, bool (M::*)(P1, Q1, Q2) const, P1, T1, T2>
+	                         (object, method, arg1, arg2));
+}
+
+template <class X, class P1, class T1, class T2, class HC = X>
+struct Gate1ActionCallArg2 : public Gate1Action<P1> {
+	X         x;
+	T1        arg1;
+	T2        arg2;
+	bool    Execute(P1 p1) { return x(p1, arg1, arg2); }
+
+	Gate1ActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(arg1), arg2(arg2) {}
+};
+
+/* ambigiuous with Callback versions
+
+template <class R, class P1, class Q1, class Q2, class T1, class T2>
+Gate1<P1> callback2(R (*fn)(P1, Q1, Q2), T1 arg1, T2 arg2) {
+	return Gate1<P1>(new Gate1ActionCallArg2<R (*)(P1, P2, Q3), P1, T1, T2, uintptr_t>(fn, arg1, arg2));
+}
+*/
+
+template <class P1, class Q1, class Q2, class T1, class T2>
+Gate1<P1> callback2(bool (*fn)(P1, Q1, Q2), T1 arg1, T2 arg2) {
+	return Gate1<P1>(new Gate1ActionCallArg2<bool (*)(P1, Q1, Q2), P1, T1, T2, uintptr_t>(fn, arg1, arg2));
+}
+
+template <class P1, class Q1, class Q2, class T1, class T2>
+Gate1<P1> callback2(Gate3<P1, Q1, Q2> cb, T1 arg1, T2 arg2) {
+	return Gate1<P1>(new Gate1ActionCallArg2<Gate3<P1, Q1, Q2>, P1, T1, T2>(cb, arg1, arg2));
+}
+
+//2 args to Gate2
+
+template <class O, class M, class P1, class P2, class T1, class T2>
+struct Gate2MethodActionArg2 : public Gate2Action<P1, P2> {
+	O  *object;
+	M   method;
+	T1        arg1;
+	T2        arg2;
+	bool    Execute(P1 p1, P2 p2) { return object ? (object->*method)(p1, p2, arg1, arg2) : false; }
+
+	Gate2MethodActionArg2(O *object, M method, T1 arg1, T2 arg2)
+	: object(object), method(method), arg1(arg1), arg2(arg2) {}
+};
+
+template <class O, class M, class P1, class P2, class Q1, class Q2, class T1, class T2>
+Gate2<P1, P2> callback2(O *object, bool (M::*method)(P1, P2, Q1, Q2), T1 arg1, T2 arg2) {
+	return Gate2<P1, P2>(new Gate2MethodActionArg2<O, bool (M::*)(P1, P2, Q1, Q2), P1, P2, T1, T2>
+	                         (object, method, arg1, arg2));
+}
+
+template <class O, class M, class P1, class P2, class Q1, class Q2, class T1, class T2>
+Gate2<P1, P2> callback2(const O *object, bool (M::*method)(P1, P2, Q1, Q2) const, T1 arg1, T2 arg2) {
+	return Gate2<P1, P2>(new Gate2MethodActionArg2<const O, bool (M::*)(P1, P2, Q1, Q2) const, P1, P2, T1, T2>
+	                         (object, method, arg1, arg2));
+}
+
+template <class X, class P1, class P2, class T1, class T2, class HC = X>
+struct Gate2ActionCallArg2 : public Gate2Action<P1, P2> {
+	X         x;
+	T1        arg1;
+	T2        arg2;
+	bool    Execute(P1 p1, P2 p2) { return x(p1, p2, arg1, arg2); }
+
+	Gate2ActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(arg1), arg2(arg2) {}
+};
+
+/* ambigiuous with Callback versions
+
+template <class R, class P1, class P2, class Q1, class Q2, class T1, class T2>
+Gate2<P1, P2> callback2(R (*fn)(P1, P2, Q1, Q2), T1 arg1, T2 arg2) {
+	return Gate2<P1, P2>(new Gate2ActionCallArg2<R (*)(P1, P2, Q1, Q1), P1, P2, T1, T2, uintptr_t>(fn, arg1, arg2));
+}
+*/
+
+template <class P1, class P2, class Q1, class Q2, class T1, class T2>
+Gate2<P1, P2> callback2(bool (*fn)(P1, P2, Q1, Q2), T1 arg1, T2 arg2) {
+	return Gate2<P1, P2>(new Gate2ActionCallArg2<bool (*)(P1, P2, Q1, Q2), P1, P2, T1, T2, uintptr_t>(fn, arg1, arg2));
+}
+
+template <class P1, class P2, class Q1, class Q2, class T1, class T2>
+Gate2<P1, P2> callback2(Gate4<P1, P2, Q1, Q2> cb, T1 arg1, T2 arg2) {
+	return Gate2<P1, P2>(new Gate2ActionCallArg2<Gate4<P1, P2, Q1, Q2>, P1, P2, T1, T2>(cb, arg1, arg2));
+}
+
+//2 args to Gate3
+
+template <class O, class M, class P1, class P2, class P3, class T1, class T2>
+struct Gate3MethodActionArg2 : public Gate3Action<P1, P2, P3> {
+	O  *object;
+	M   method;
+	T1        arg1;
+	T2        arg2;
+	bool    Execute(P1 p1, P2 p2, P3 p3) { return object ? (object->*method)(p1, p2, p3, arg1, arg2) : false; }
+
+	Gate3MethodActionArg2(O *object, M method, T1 arg1, T2 arg2)
+	: object(object), method(method), arg1(arg1), arg2(arg2) {}
+};
+
+template <class O, class M, class P1, class P2, class P3, class Q1, class Q2, class T1, class T2>
+Gate3<P1, P2, P3> callback2(O *object, bool (M::*method)(P1, P2, P3, Q1, Q2), T1 arg1, T2 arg2) {
+	return Gate3<P1, P2, P3>(new Gate3MethodActionArg2<O, bool (M::*)(P1, P2, P3, Q1, Q2), P1, P2, P3, T1, T2>
+	                         (object, method, arg1, arg2));
+}
+
+template <class O, class M, class P1, class P2, class P3, class Q1, class Q2, class T1, class T2>
+Gate3<P1, P2, P3> callback2(const O *object, bool (M::*method)(P1, P2, P3, Q1, Q2) const, T1 arg1, T2 arg2) {
+	return Gate3<P1, P2, P3>(new Gate3MethodActionArg2<const O, bool (M::*)(P1, P2, P3, Q1, Q2) const, P1, P2, P3, T1, T2>
+	                         (object, method, arg1, arg2));
+}
+
+template <class X, class P1, class P2, class P3, class T1, class T2, class HC = X>
+struct Gate3ActionCallArg2 : public Gate3Action<P1, P2, P3> {
+	X         x;
+	T1        arg1;
+	T2        arg2;
+	bool    Execute(P1 p1, P2 p2, P3 p3) { return x(p1, p2, p3, arg1, arg2); }
+
+	Gate3ActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(arg1), arg2(arg2) {}
+};
+
+/* ambigiuous with Callback versions
+
+template <class R, class P1, class P2, class P3, class Q1, class Q2, class T1, class T2>
+Gate3<P1, P2, P3> callback2(R (*fn)(P1, P2, P3, Q1, Q2), T1 arg1, T2 arg2) {
+	return Gate3<P1, P2, P3>(new Gate3ActionCallArg2<R (*)(P1, P2, P3, Q1, Q2), P1, P2, P3, T1, T2, uintptr_t>(fn, arg1, arg2));
+}
+*/
+
+template <class P1, class P2, class P3, class Q1, class Q2, class T1, class T2>
+Gate3<P1, P2, P3> callback2(bool (*fn)(P1, P2, P3, Q1, Q2), T1 arg1, T2 arg2) {
+	return Gate3<P1, P2, P3>(new Gate3ActionCallArg2<bool (*)(P1, P2, P3, Q1, Q2), P1, P2, P3, T1, T2, uintptr_t>(fn, arg1, arg2));
+}
+
+//2 args to Gate4
+
+template <class O, class M, class P1, class P2, class P3, class P4, class T1, class T2>
+struct Gate4MethodActionArg2 : public Gate4Action<P1, P2, P3, P4> {
+	O  *object;
+	M   method;
+	T1        arg1;
+	T2        arg2;
+	bool    Execute(P1 p1, P2 p2, P3 p3, P4 p4) { return object ? (object->*method)(p1, p2, p3, p4, arg1, arg2) : false; }
+
+	Gate4MethodActionArg2(O *object, M method, T1 arg1, T2 arg2)
+	: object(object), method(method), arg1(arg1), arg2(arg2) {}
+};
+
+template <class O, class M, class P1, class P2, class P3, class P4, class Q1, class Q2, class T1, class T2>
+Gate4<P1, P2, P3, P4> callback2(O *object, bool (M::*method)(P1, P2, P3, P4, Q1, Q2), T1 arg1, T2 arg2) {
+	return Gate4<P1, P2, P3, P4>(new Gate4MethodActionArg2<O, bool (M::*)(P1, P2, P3, P4, Q1, Q2), P1, P2, P3, P4, T1, T2>
+	                         (object, method, arg1, arg2));
+}
+
+template <class O, class M, class P1, class P2, class P3, class P4, class Q1, class Q2, class T1, class T2>
+Gate4<P1, P2, P3, P4> callback2(const O *object, bool (M::*method)(P1, P2, P3, P4, Q1, Q2) const, T1 arg1, T2 arg2) {
+	return Gate4<P1, P2, P3, P4>(new Gate4MethodActionArg2<const O, bool (M::*)(P1, P2, P3, P4, Q1, Q2) const, P1, P2, P3, P4, T1, T2>
+	                         (object, method, arg1, arg2));
+}
+
+template <class X, class P1, class P2, class P3, class P4, class T1, class T2, class HC = X>
+struct Gate4ActionCallArg2 : public Gate4Action<P1, P2, P3, P4> {
+	X         x;
+	T1        arg1;
+	T2        arg2;
+	bool    Execute(P1 p1, P2 p2, P3 p3, P4 p4) { return x(p1, p2, p3, p4, arg1, arg2); }
+
+	Gate4ActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(arg1), arg2(arg2) {}
+};
+
+/* ambigiuous with Callback versions
+
+template <class R, class P1, class P2, class P3, class P4, class Q1, class Q2, class T1, class T2>
+Gate4<P1, P2, P3, P4> callback2(R (*fn)(P1, P2, P3, P4, Q1, Q2), T1 arg1, T2 arg2) {
+	return Gate4<P1, P2, P3, P4>(new Gate4ActionCallArg2<R (*)(P1, P2, P3, P4, Q1, Q2), P1, P2, P3, P4, T1, T2, uintptr_t>(fn, arg1, arg2));
+}
+*/
+
+template <class P1, class P2, class P3, class P4, class Q1, class Q2, class T1, class T2>
+Gate4<P1, P2, P3, P4> callback2(bool (*fn)(P1, P2, P3, P4, Q1, Q2), T1 arg1, T2 arg2) {
+	return Gate4<P1, P2, P3, P4>(new Gate4ActionCallArg2<bool (*)(P1, P2, P3, P4, Q1, Q2), P1, P2, P3, P4, T1, T2, uintptr_t>(fn, arg1, arg2));
+}
diff --git a/uppsrc/Core/Callback3.h b/uppsrc/Core/Callback3.h
new file mode 100644
index 000000000..c71ba6ff9
--- /dev/null
+++ b/uppsrc/Core/Callback3.h
@@ -0,0 +1,428 @@
+//3 args to Callback
+
+template <class O, class M, class T1, class T2, class T3>
+struct CallbackMethodActionArg3Pte : public CallbackAction {
+	Ptr<O>  object;
+	M       method;
+	T1            arg1;
+	T2            arg2;
+	T3            arg3;
+	void    Execute() { if(object) (object->*method)(arg1, arg2, arg3); }
+
+	CallbackMethodActionArg3Pte(O *object, M method, T1 arg1, T2 arg2, T3 arg3)
+	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {}
+};
+
+/* wrong type R?
+template <class O, class R, class M, class Q1, class Q2, class Q3, class T1, class T2, class T3>
+Callback pteback3(O *object, R (M::*method)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
+	return Callback(new CallbackMethodActionArg3Pte<O, R (M::*)(Q1, Q2, Q3), T1, T2, T3>
+	                    (object, method, arg1, arg2, arg3));
+}
+*/
+
+template <class O, class M, class Q1, class Q2, class Q3, class T1, class T2, class T3>
+Callback pteback3(O *object, void (M::*method)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
+	return Callback(new CallbackMethodActionArg3Pte<O, void (M::*)(Q1, Q2, Q3), T1, T2, T3>
+	                    (object, method, arg1, arg2, arg3));
+}
+
+template <class O, class M, class T1, class T2, class T3>
+struct CallbackMethodActionArg3 : public CallbackAction 
+{
+	O  *object;
+	M   method;
+	T1        arg1;
+	T2        arg2;
+	T3        arg3;
+	
+	void    Execute() { (object->*method)(arg1, arg2, arg3); }
+
+	CallbackMethodActionArg3(O *object, M method, T1 arg1, T2 arg2, T3 arg3)
+	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {}
+};
+
+/* wrong type R?
+template <class O, class R, class M, class Q1, class Q2, class Q3, class T1, class T2, class T3> 
+Callback callback3(O *object, R (M::*method)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) 
+{
+	return Callback(
+		new CallbackMethodActionArg3<O, R (M::*)(Q1, Q2, Q3), T1, T2, T3>(object, method, arg1, arg2, arg3));
+}
+
+template <class O, class R, class M, class Q1, class Q2, class Q3, class T1, class T2, class T3> 
+Callback callback3(const O *object, R (M::*method)(Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
+	return Callback(new CallbackMethodActionArg3<const O, R (M::*)(Q1, Q2, Q3) const, T1, T2, T3>
+	                    (object, method, arg1, arg2, arg3));
+}
+*/
+
+template <class O, class M, class Q1, class Q2, class Q3, class T1, class T2, class T3> 
+Callback callback3(O *object, void (M::*method)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) 
+{
+	return Callback(
+		new CallbackMethodActionArg3<O, void (M::*)(Q1, Q2, Q3), T1, T2, T3>(object, method, arg1, arg2, arg3));
+}
+
+template <class O, class M, class Q1, class Q2, class Q3, class T1, class T2, class T3> 
+Callback callback3(const O *object, void (M::*method)(Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
+	return Callback(new CallbackMethodActionArg3<const O, void (M::*)(Q1, Q2, Q3) const, T1, T2, T3>
+	                    (object, method, arg1, arg2, arg3));
+}
+
+template <class X, class T1, class T2, class T3, class HC = X>
+struct CallbackActionCallArg3 : public CallbackAction {
+	X         x;
+	T1        arg1;
+	T2        arg2;
+	T3        arg3;
+	void    Execute() { x(arg1, arg2, arg3); }
+
+	CallbackActionCallArg3(X x, T1 arg1, T2 arg2, T3 arg3) 
+		: x(x), arg1(arg1), arg2(arg2), arg3(arg3) {}
+};
+
+/* wrong type R?
+template <class R, class Q1, class Q2, class Q3, class T1, class T2, class T3>
+Callback callback3(R (*fn)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
+	return Callback(
+		new CallbackActionCallArg3<R (*)(Q1, Q2, Q3), T1, T2, T3, uintptr_t>(fn, arg1, arg2, arg3));
+}
+*/
+
+template <class Q1, class Q2, class Q3, class T1, class T2, class T3>
+Callback callback3(void (*fn)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
+	return Callback(
+		new CallbackActionCallArg3<void (*)(Q1, Q2, Q3), T1, T2, T3, uintptr_t>(fn, arg1, arg2, arg3));
+}
+
+template <class Q1, class Q2, class Q3, class T1, class T2, class T3>
+Callback callback3(Callback3<Q1, Q2, Q3> cb, T1 arg1, T2 arg2, T3 arg3) {
+	return Callback(
+		new CallbackActionCallArg3<Callback3<Q1, Q2, Q3>, T1, T2, T3>(cb, arg1, arg2, arg3));
+}
+
+//3 args to Callback1
+
+template <class O, class M, class P1, class T1, class T2, class T3>
+struct Callback1MethodActionArg3 : public Callback1Action<P1> {
+	O  *object;
+	M   method;
+	T1        arg1;
+	T2        arg2;
+	T3        arg3;
+	void    Execute(P1 p1) { (object->*method)(p1, arg1, arg2, arg3); }
+
+	Callback1MethodActionArg3(O *object, M method, T1 arg1, T2 arg2, T3 arg3)
+	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {}
+};
+
+template <class O, class M, class P1, class Q1, class Q2, class Q3, class T1, class T2, class T3>
+Callback1<P1> callback3(O *object, void (M::*method)(P1, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
+	return Callback1<P1>(new Callback1MethodActionArg3<O, void (M::*)(P1, Q1, Q2, Q3), P1, T1, T2, T3>
+	                         (object, method, arg1, arg2, arg3));
+}
+
+template <class O, class M, class P1, class Q1, class Q2, class Q3, class T1, class T2, class T3>
+Callback1<P1> callback3(const O *object, void (M::*method)(P1, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
+	return Callback1<P1>(new Callback1MethodActionArg3<const O, void (M::*)(P1, Q1, Q2, Q3) const, P1, T1, T2, T3>
+	                         (object, method, arg1, arg2, arg3));
+}
+
+//3 args to Callback2
+
+template <class O, class M, class P1, class P2, class T1, class T2, class T3>
+struct Callback2MethodActionArg3 : public Callback2Action<P1, P2> {
+	O  *object;
+	M   method;
+	T1        arg1;
+	T2        arg2;
+	T3        arg3;
+	void    Execute(P1 p1, P2 p2) { (object->*method)(p1, p2, arg1, arg2, arg3); }
+
+	Callback2MethodActionArg3(O *object, M method, T1 arg1, T2 arg2, T3 arg3)
+	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {}
+};
+
+template <class O, class M, class P1, class P2, class Q1, class Q2, class Q3, class T1, class T2, class T3>
+Callback2<P1, P2> callback3(O *object, void (M::*method)(P1, P2, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
+	return Callback2<P1, P2>(new Callback2MethodActionArg3<O, void (M::*)(P1, P2, Q1, Q2, Q3), P1, P2, T1, T2, T3>
+	                         (object, method, arg1, arg2, arg3));
+}
+
+template <class O, class M, class P1, class P2, class Q1, class Q2, class Q3, class T1, class T2, class T3>
+Callback2<P1, P2> callback3(const O *object, void (M::*method)(P1, P2, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
+	return Callback2<P1, P2>(new Callback2MethodActionArg3<const O, void (M::*)(P1, P2, Q1, Q2, Q3) const, P1, P2, T1, T2, T3>
+	                         (object, method, arg1, arg2, arg3));
+}
+
+//3 args to Callback3
+
+template <class O, class M, class P1, class P2, class P3, class T1, class T2, class T3>
+struct Callback3MethodActionArg3 : public Callback3Action<P1, P2, P3> {
+	O  *object;
+	M   method;
+	T1        arg1;
+	T2        arg2;
+	T3        arg3;
+	void    Execute(P1 p1, P2 p2, P3 p3) { (object->*method)(p1, p2, p3, arg1, arg2, arg3); }
+
+	Callback3MethodActionArg3(O *object, M method, T1 arg1, T2 arg2, T3 arg3)
+	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {}
+};
+
+template <class O, class M, class P1, class P2, class P3, class Q1, class Q2, class Q3, class T1, class T2, class T3>
+Callback3<P1, P2, P3> callback3(O *object, void (M::*method)(P1, P2, P3, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
+	return Callback3<P1, P2, P3>(new Callback3MethodActionArg3<O, void (M::*)(P1, P2, P3, Q1, Q2, Q3), P1, P2, P3, T1, T2, T3>
+	                         (object, method, arg1, arg2, arg3));
+}
+
+template <class O, class M, class P1, class P2, class P3, class Q1, class Q2, class Q3, class T1, class T2, class T3>
+Callback3<P1, P2, P3> callback3(const O *object, void (M::*method)(P1, P2, P3, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
+	return Callback3<P1, P2, P3>(new Callback3MethodActionArg3<const O, void (M::*)(P1, P2, P3, Q1, Q2, Q3) const, P1, P2, P3, T1, T2, T3>
+	                         (object, method, arg1, arg2, arg3));
+}
+
+//3 args to Callback4
+
+template <class O, class M, class P1, class P2, class P3, class P4, class T1, class T2, class T3>
+struct Callback4MethodActionArg3 : public Callback4Action<P1, P2, P3, P4> {
+	O  *object;
+	M   method;
+	T1        arg1;
+	T2        arg2;
+	T3        arg3;
+	void    Execute(P1 p1, P2 p2, P3 p3, P4 p4) { (object->*method)(p1, p2, p3, p4, arg1, arg2, arg3); }
+
+	Callback4MethodActionArg3(O *object, M method, T1 arg1, T2 arg2, T3 arg3)
+	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {}
+};
+
+template <class O, class M, class P1, class P2, class P3, class P4, class Q1, class Q2, class Q3, class T1, class T2, class T3>
+Callback4<P1, P2, P3, P4> callback3(O *object, void (M::*method)(P1, P2, P3, P4, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
+	return Callback4<P1, P2, P3, P4>(new Callback4MethodActionArg3<O, void (M::*)(P1, P2, P3, P4, Q1, Q2, Q3), P1, P2, P3, P4, T1, T2, T3>
+	                         (object, method, arg1, arg2, arg3));
+}
+
+template <class O, class M, class P1, class P2, class P3, class P4, class Q1, class Q2, class Q3, class T1, class T2, class T3>
+Callback4<P1, P2, P3, P4> callback3(const O *object, void (M::*method)(P1, P2, P3, P4, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
+	return Callback4<P1, P2, P3, P4>(new Callback4MethodActionArg3<const O, void (M::*)(P1, P2, P3, P4, Q1, Q2, Q3) const, P1, P2, P3, P4, T1, T2, T3>
+	                         (object, method, arg1, arg2, arg3));
+}
+
+// --------------------------------------------------------
+
+//3 args to Gate
+
+template <class O, class M, class T1, class T2, class T3>
+struct GateMethodActionArg3Pte : public GateAction {
+	Ptr<O>  object;
+	M       method;
+	T1            arg1;
+	T2            arg2;
+	T3            arg3;
+	bool    Execute() { return object ? (object->*method)(arg1, arg2, arg3): false; }
+
+	GateMethodActionArg3Pte(O *object, M method, T1 arg1, T2 arg2, T3 arg3)
+	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {}
+};
+
+/* ambigiuous with Callback versions
+
+template <class O, class R, class M, class Q1, class Q2, class Q3, class T1, class T2, class T3>
+Gate pteback3(O *object, R (M::*method)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
+	return Gate(new GateMethodActionArg3Pte<O, R (M::*)(Q1, Q2, Q3), T1, T2, T3>
+	                    (object, method, arg1, arg2, arg3));
+}
+*/
+
+template <class O, class M, class Q1, class Q2, class Q3, class T1, class T2, class T3>
+Gate pteback3(O *object, bool (M::*method)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
+	return Gate(new GateMethodActionArg3Pte<O, bool (M::*)(Q1, Q2, Q3), T1, T2, T3>
+	                    (object, method, arg1, arg2, arg3));
+}
+
+template <class O, class M, class T1, class T2, class T3>
+struct GateMethodActionArg3 : public GateAction 
+{
+	O  *object;
+	M   method;
+	T1        arg1;
+	T2        arg2;
+	T3        arg3;
+	
+	bool    Execute() { return object ? (object->*method)(arg1, arg2, arg3) : false; }
+
+	GateMethodActionArg3(O *object, M method, T1 arg1, T2 arg2, T3 arg3)
+	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {}
+};
+
+/* ambigiuous with Callback versions
+
+template <class O, class R, class M, class Q1, class Q2, class Q3, class T1, class T2, class T3> 
+Gate callback3(O *object, R (M::*method)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) 
+{
+	return Gate(
+		new GateMethodActionArg3<O, R (M::*)(Q1, Q2, Q3), T1, T2, T3>(object, method, arg1, arg2, arg3));
+}
+
+template <class O, class R, class M, class Q1, class Q2, class Q3, class T1, class T2, class T3> 
+Gate callback3(const O *object, R (M::*method)(Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
+	return Gate(new GateMethodActionArg3<const O, R (M::*)(Q1, Q2, Q3) const, T1, T2, T3>
+	                    (object, method, arg1, arg2, arg3));
+}
+*/
+
+template <class O, class M, class Q1, class Q2, class Q3, class T1, class T2, class T3> 
+Gate callback3(O *object, bool (M::*method)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) 
+{
+	return Gate(
+		new GateMethodActionArg3<O, bool (M::*)(Q1, Q2, Q3), T1, T2, T3>(object, method, arg1, arg2, arg3));
+}
+
+template <class O, class M, class Q1, class Q2, class Q3, class T1, class T2, class T3> 
+Gate callback3(const O *object, bool (M::*method)(Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
+	return Gate(new GateMethodActionArg3<const O, bool (M::*)(Q1, Q2, Q3) const, T1, T2, T3>
+	                    (object, method, arg1, arg2, arg3));
+}
+
+template <class X, class T1, class T2, class T3, class HC = X>
+struct GateActionCallArg3 : public GateAction {
+	X         x;
+	T1        arg1;
+	T2        arg2;
+	T3        arg3;
+	bool    Execute() { return x(arg1, arg2, arg3); }
+
+	GateActionCallArg3(X x, T1 arg1, T2 arg2, T3 arg3) 
+		: x(x), arg1(arg1), arg2(arg2), arg3(arg3) {}
+};
+
+/* ambigiuous with Callback versions
+
+template <class R, class Q1, class Q2, class Q3, class T1, class T2, class T3>
+Gate callback3(R (*fn)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
+	return Gate(
+		new GateActionCallArg3<R (*)(Q1, Q2, Q3), T1, T2, T3, uintptr_t>(fn, arg1, arg2, arg3));
+}
+*/
+
+template <class Q1, class Q2, class Q3, class T1, class T2, class T3>
+Gate callback3(bool (*fn)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
+	return Gate(
+		new GateActionCallArg3<bool (*)(Q1, Q2, Q3), T1, T2, T3, uintptr_t>(fn, arg1, arg2, arg3));
+}
+
+template <class Q1, class Q2, class Q3, class T1, class T2, class T3>
+Gate callback3(Gate3<Q1, Q2, Q3> cb, T1 arg1, T2 arg2, T3 arg3) {
+	return Gate(
+		new GateActionCallArg3<Gate3<Q1, Q2, Q3>, T1, T2, T3>(cb, arg1, arg2, arg3));
+}
+
+//3 args to Gate1
+
+template <class O, class M, class P1, class T1, class T2, class T3>
+struct Gate1MethodActionArg3 : public Gate1Action<P1> {
+	O  *object;
+	M   method;
+	T1        arg1;
+	T2        arg2;
+	T3        arg3;
+	bool    Execute(P1 p1) { return object ? (object->*method)(p1, arg1, arg2, arg3) : false; }
+
+	Gate1MethodActionArg3(O *object, M method, T1 arg1, T2 arg2, T3 arg3)
+	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {}
+};
+
+template <class O, class M, class P1, class Q1, class Q2, class Q3, class T1, class T2, class T3>
+Gate1<P1> callback3(O *object, bool (M::*method)(P1, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
+	return Gate1<P1>(new Gate1MethodActionArg3<O, bool (M::*)(P1, Q1, Q2, Q3), P1, T1, T2, T3>
+	                         (object, method, arg1, arg2, arg3));
+}
+
+template <class O, class M, class P1, class Q1, class Q2, class Q3, class T1, class T2, class T3>
+Gate1<P1> callback3(const O *object, bool (M::*method)(P1, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
+	return Gate1<P1>(new Gate1MethodActionArg3<const O, bool (M::*)(P1, Q1, Q2, Q3) const, P1, T1, T2, T3>
+	                         (object, method, arg1, arg2, arg3));
+}
+
+//3 args to Gate2
+
+template <class O, class M, class P1, class P2, class T1, class T2, class T3>
+struct Gate2MethodActionArg3 : public Gate2Action<P1, P2> {
+	O  *object;
+	M   method;
+	T1        arg1;
+	T2        arg2;
+	T3        arg3;
+	bool    Execute(P1 p1, P2 p2) { return object ? (object->*method)(p1, p2, arg1, arg2, arg3) : false; }
+
+	Gate2MethodActionArg3(O *object, M method, T1 arg1, T2 arg2, T3 arg3)
+	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {}
+};
+
+template <class O, class M, class P1, class P2, class Q1, class Q2, class Q3, class T1, class T2, class T3>
+Gate2<P1, P2> callback3(O *object, bool (M::*method)(P1, P2, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
+	return Gate2<P1, P2>(new Gate2MethodActionArg3<O, bool (M::*)(P1, P2, Q1, Q2, Q3), P1, P2, T1, T2, T3>
+	                         (object, method, arg1, arg2, arg3));
+}
+
+template <class O, class M, class P1, class P2, class Q1, class Q2, class Q3, class T1, class T2, class T3>
+Gate2<P1, P2> callback3(const O *object, bool (M::*method)(P1, P2, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
+	return Gate2<P1, P2>(new Gate2MethodActionArg3<const O, bool (M::*)(P1, P2, Q1, Q2, Q3) const, P1, P2, T1, T2, T3>
+	                         (object, method, arg1, arg2, arg3));
+}
+
+//3 args to Gate3
+
+template <class O, class M, class P1, class P2, class P3, class T1, class T2, class T3>
+struct Gate3MethodActionArg3 : public Gate3Action<P1, P2, P3> {
+	O  *object;
+	M   method;
+	T1        arg1;
+	T2        arg2;
+	T3        arg3;
+	bool    Execute(P1 p1, P2 p2, P3 p3) { return object ? (object->*method)(p1, p2, p3, arg1, arg2, arg3) : false; }
+
+	Gate3MethodActionArg3(O *object, M method, T1 arg1, T2 arg2, T3 arg3)
+	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {}
+};
+
+template <class O, class M, class P1, class P2, class P3, class Q1, class Q2, class Q3, class T1, class T2, class T3>
+Gate3<P1, P2, P3> callback3(O *object, bool (M::*method)(P1, P2, P3, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
+	return Gate3<P1, P2, P3>(new Gate3MethodActionArg3<O, bool (M::*)(P1, P2, P3, Q1, Q2, Q3), P1, P2, P3, T1, T2, T3>
+	                         (object, method, arg1, arg2, arg3));
+}
+
+template <class O, class M, class P1, class P2, class P3, class Q1, class Q2, class Q3, class T1, class T2, class T3>
+Gate3<P1, P2, P3> callback3(const O *object, bool (M::*method)(P1, P2, P3, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
+	return Gate3<P1, P2, P3>(new Gate3MethodActionArg3<const O, bool (M::*)(P1, P2, P3, Q1, Q2, Q3) const, P1, P2, P3, T1, T2, T3>
+	                         (object, method, arg1, arg2, arg3));
+}
+
+//3 args to Gate4
+
+template <class O, class M, class P1, class P2, class P3, class P4, class T1, class T2, class T3>
+struct Gate4MethodActionArg3 : public Gate4Action<P1, P2, P3, P4> {
+	O  *object;
+	M   method;
+	T1        arg1;
+	T2        arg2;
+	T3        arg3;
+	bool    Execute(P1 p1, P2 p2, P3 p3, P4 p4) { return object ? (object->*method)(p1, p2, p3, p4, arg1, arg2, arg3) : false; }
+
+	Gate4MethodActionArg3(O *object, M method, T1 arg1, T2 arg2, T3 arg3)
+	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {}
+};
+
+template <class O, class M, class P1, class P2, class P3, class P4, class Q1, class Q2, class Q3, class T1, class T2, class T3>
+Gate4<P1, P2, P3, P4> callback3(O *object, bool (M::*method)(P1, P2, P3, P4, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
+	return Gate4<P1, P2, P3, P4>(new Gate4MethodActionArg3<O, bool (M::*)(P1, P2, P3, P4, Q1, Q2, Q3), P1, P2, P3, P4, T1, T2, T3>
+	                         (object, method, arg1, arg2, arg3));
+}
+
+template <class O, class M, class P1, class P2, class P3, class P4, class Q1, class Q2, class Q3, class T1, class T2, class T3>
+Gate4<P1, P2, P3, P4> callback3(const O *object, bool (M::*method)(P1, P2, P3, P4, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
+	return Gate4<P1, P2, P3, P4>(new Gate4MethodActionArg3<const O, bool (M::*)(P1, P2, P3, P4, Q1, Q2, Q3) const, P1, P2, P3, P4, T1, T2, T3>
+	                         (object, method, arg1, arg2, arg3));
+}
diff --git a/uppsrc/Core/Callback4.h b/uppsrc/Core/Callback4.h
new file mode 100644
index 000000000..40114ab72
--- /dev/null
+++ b/uppsrc/Core/Callback4.h
@@ -0,0 +1,442 @@
+//4 args to Callback
+
+template <class O, class M, class T1, class T2, class T3, class T4>
+struct CallbackMethodActionArg4Pte : public CallbackAction {
+	Ptr<O>  object;
+	M       method;
+	T1            arg1;
+	T2            arg2;
+	T3            arg3;
+	T4            arg4;
+	void    Execute() { if(object) (object->*method)(arg1, arg2, arg3, arg4); }
+
+	CallbackMethodActionArg4Pte(O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {}
+};
+
+/* ambigiuous with Callback versions
+
+template <class O, class R, class M, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
+Callback pteback4(O *object, R (M::*method)(Q1, Q2,Q3,Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+	return Callback(new CallbackMethodActionArg4Pte<O, R (M::*)(Q1, Q2, Q3, Q4), T1, T2, T3, T4>
+	                    (object, method, arg1, arg2, arg3, arg4));
+}
+*/
+
+template <class O, class M, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
+Callback pteback4(O *object, void (M::*method)(Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+	return Callback(new CallbackMethodActionArg4Pte<O, void (M::*)(Q1, Q2, Q3, Q4), T1, T2, T3, T4>
+	                    (object, method, arg1, arg2, arg3, arg4));
+}
+
+template <class O, class M, class T1, class T2, class T3, class T4>
+struct CallbackMethodActionArg4 : public CallbackAction 
+{
+	O  *object;
+	M   method;
+	T1        arg1;
+	T2        arg2;
+	T3        arg3;
+	T4        arg4;
+	
+	void    Execute() { (object->*method)(arg1, arg2, arg3, arg4); }
+
+	CallbackMethodActionArg4(O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {}
+};
+
+/* ambigiuous with Callback versions
+
+template <class O, class R, class M, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4> 
+Callback callback4(O *object, R (M::*method)(Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) 
+{
+	return Callback(
+		new CallbackMethodActionArg4<O, R (M::*)(Q1, Q2, Q3, Q4), T1, T2, T3, T4>(object, method, arg1, arg2, arg3, arg4));
+}
+
+template <class O, class R, class M, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4> 
+Callback callback4(const O *object, R (M::*method)(Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+	return Callback(new CallbackMethodActionArg4<const O, R (M::*)(Q1, Q2, Q3, Q4) const, T1, T2, T3, T4>
+	                    (object, method, arg1, arg2, arg3, arg4));
+}
+*/
+
+template <class O, class M, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4> 
+Callback callback4(O *object, void (M::*method)(Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) 
+{
+	return Callback(
+		new CallbackMethodActionArg4<O, void (M::*)(Q1, Q2, Q3, Q4), T1, T2, T3, T4>(object, method, arg1, arg2, arg3, arg4));
+}
+
+template <class O, class M, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4> 
+Callback callback4(const O *object, void (M::*method)(Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+	return Callback(new CallbackMethodActionArg4<const O, void (M::*)(Q1, Q2, Q3, Q4) const, T1, T2, T3, T4>
+	                    (object, method, arg1, arg2, arg3, arg4));
+}
+
+template <class X, class T1, class T2, class T3, class T4, class HC = X>
+struct CallbackActionCallArg4 : public CallbackAction {
+	X         x;
+	T1        arg1;
+	T2        arg2;
+	T3        arg3;
+	T4        arg4;
+	void    Execute() { x(arg1, arg2, arg3, arg4); }
+
+	CallbackActionCallArg4(X x, T1 arg1, T2 arg2, T3 arg3, T4 arg4) 
+		: x(x), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {}
+};
+
+/* ambigiuous with Callback versions
+
+template <class R, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
+Callback callback4(R (*fn)(Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+	return Callback(
+		new CallbackActionCallArg4<R (*)(Q1, Q2, Q3, Q4), T1, T2, T3, T4, uintptr_t>(fn, arg1, arg2, arg3, arg4));
+}
+*/
+
+template <class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
+Callback callback4(void (*fn)(Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+	return Callback(
+		new CallbackActionCallArg4<void (*)(Q1, Q2, Q3, Q4), T1, T2, T3, T4, uintptr_t>(fn, arg1, arg2, arg3, arg4));
+}
+
+template <class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
+Callback callback4(Callback4<Q1, Q2, Q3, Q4> cb, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+	return Callback(
+		new CallbackActionCallArg4<Callback4<Q1, Q2, Q3, Q4>, T1, T2, T3, T4>(cb, arg1, arg2, arg3, arg4));
+}
+
+//4 args to Callback1
+
+template <class O, class M, class P1, class T1, class T2, class T3, class T4>
+struct Callback1MethodActionArg4 : public Callback1Action<P1> {
+	O  *object;
+	M   method;
+	T1        arg1;
+	T2        arg2;
+	T3        arg3;
+	T4        arg4;
+	void    Execute(P1 p1) { (object->*method)(p1, arg1, arg2, arg3, arg4); }
+
+	Callback1MethodActionArg4(O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {}
+};
+
+template <class O, class M, class P1, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
+Callback1<P1> callback4(O *object, void (M::*method)(P1, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+	return Callback1<P1>(new Callback1MethodActionArg4<O, void (M::*)(P1, Q1, Q2, Q3, Q4), P1, T1, T2, T3, T4>
+	                         (object, method, arg1, arg2, arg3, arg4));
+}
+
+template <class O, class M, class P1, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
+Callback1<P1> callback4(const O *object, void (M::*method)(P1, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+	return Callback1<P1>(new Callback1MethodActionArg4<const O, void (M::*)(P1, Q1, Q2, Q3, Q4) const, P1, T1, T2, T3, T4>
+	                         (object, method, arg1, arg2, arg3, arg4));
+}
+
+//4 args to Callback2
+
+template <class O, class M, class P1, class P2, class T1, class T2, class T3, class T4>
+struct Callback2MethodActionArg4 : public Callback2Action<P1, P2> {
+	O  *object;
+	M   method;
+	T1        arg1;
+	T2        arg2;
+	T3        arg3;
+	T4        arg4;
+	void    Execute(P1 p1, P2 p2) { (object->*method)(p1, p2, arg1, arg2, arg3, arg4); }
+
+	Callback2MethodActionArg4(O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {}
+};
+
+template <class O, class M, class P1, class P2, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
+Callback2<P1, P2> callback4(O *object, void (M::*method)(P1, P2, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+	return Callback2<P1, P2>(new Callback2MethodActionArg4<O, void (M::*)(P1, P2, Q1, Q2, Q3, Q4), P1, P2, T1, T2, T3, T4>
+	                         (object, method, arg1, arg2, arg3, arg4));
+}
+
+template <class O, class M, class P1, class P2, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
+Callback2<P1, P2> callback4(const O *object, void (M::*method)(P1, P2, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+	return Callback2<P1, P2>(new Callback2MethodActionArg4<const O, void (M::*)(P1, P2, Q1, Q2, Q3, Q4) const, P1, P2, T1, T2, T3, T4>
+	                         (object, method, arg1, arg2, arg3, arg4));
+}
+
+//4 args to Callback3
+
+template <class O, class M, class P1, class P2, class P3, class T1, class T2, class T3, class T4>
+struct Callback3MethodActionArg4 : public Callback3Action<P1, P2, P3> {
+	O  *object;
+	M   method;
+	T1        arg1;
+	T2        arg2;
+	T3        arg3;
+	T3        arg4;
+	void    Execute(P1 p1, P2 p2, P3 p3) { (object->*method)(p1, p2, p3, arg1, arg2, arg3, arg4); }
+
+	Callback3MethodActionArg4(O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {}
+};
+
+template <class O, class M, class P1, class P2, class P3, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
+Callback3<P1, P2, P3> callback4(O *object, void (M::*method)(P1, P2, P3, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+	return Callback3<P1, P2, P3>(new Callback3MethodActionArg4<O, void (M::*)(P1, P2, P3, Q1, Q2, Q3, Q4), P1, P2, P3, T1, T2, T3, T4>
+	                         (object, method, arg1, arg2, arg3, arg4));
+}
+
+template <class O, class M, class P1, class P2, class P3, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
+Callback3<P1, P2, P3> callback4(const O *object, void (M::*method)(P1, P2, P3, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+	return Callback3<P1, P2, P3>(new Callback3MethodActionArg4<const O, void (M::*)(P1, P2, P3, Q1, Q2, Q3, Q4) const, P1, P2, P3, T1, T2, T3, T4>
+	                         (object, method, arg1, arg2, arg3, arg4));
+}
+
+//4 args to Callback4
+
+template <class O, class M, class P1, class P2, class P3, class P4, class T1, class T2, class T3, class T4>
+struct Callback4MethodActionArg4 : public Callback4Action<P1, P2, P3, P4> {
+	O  *object;
+	M   method;
+	T1        arg1;
+	T2        arg2;
+	T3        arg3;
+	T4        arg4;
+	void    Execute(P1 p1, P2 p2, P3 p3, P4 p4) { (object->*method)(p1, p2, p3, p4, arg1, arg2, arg3, arg4); }
+
+	Callback4MethodActionArg4(O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {}
+};
+
+template <class O, class M, class P1, class P2, class P3, class P4, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
+Callback4<P1, P2, P3, P4> callback4(O *object, void (M::*method)(P1, P2, P3, P4, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+	return Callback4<P1, P2, P3, P4>(new Callback4MethodActionArg4<O, void (M::*)(P1, P2, P3, P4, Q1, Q2, Q3, Q4), P1, P2, P3, P4, T1, T2, T3, T4>
+	                         (object, method, arg1, arg2, arg3, arg4));
+}
+
+template <class O, class M, class P1, class P2, class P3, class P4, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
+Callback4<P1, P2, P3, P4> callback4(const O *object, void (M::*method)(P1, P2, P3, P4, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+	return Callback4<P1, P2, P3, P4>(new Callback4MethodActionArg4<const O, void (M::*)(P1, P2, P3, P4, Q1, Q2, Q3, Q4) const, P1, P2, P3, P4, T1, T2, T3, T4>
+	                         (object, method, arg1, arg2, arg3, arg4));
+}
+
+//----------------------------------------------------------
+
+//4 args to Gate
+
+template <class O, class M, class T1, class T2, class T3, class T4>
+struct GateMethodActionArg4Pte : public GateAction {
+	Ptr<O>  object;
+	M       method;
+	T1            arg1;
+	T2            arg2;
+	T3            arg3;
+	T4            arg4;
+	bool    Execute() { return object ? (object->*method)(arg1, arg2, arg3, arg4) : false; }
+
+	GateMethodActionArg4Pte(O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {}
+};
+
+/*
+template <class O, class R, class M, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
+Gate pteback4(O *object, R (M::*method)(Q1, Q2,Q3,Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+	return Gate(new GateMethodActionArg4Pte<O, R (M::*)(Q1, Q2, Q3, Q4), T1, T2, T3, T4>
+	                    (object, method, arg1, arg2, arg3, arg4));
+}
+*/
+
+template <class O, class M, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
+Gate pteback4(O *object, bool (M::*method)(Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+	return Gate(new GateMethodActionArg4Pte<O, bool (M::*)(Q1, Q2, Q3, Q4), T1, T2, T3, T4>
+	                    (object, method, arg1, arg2, arg3, arg4));
+}
+
+template <class O, class M, class T1, class T2, class T3, class T4>
+struct GateMethodActionArg4 : public GateAction 
+{
+	O  *object;
+	M   method;
+	T1        arg1;
+	T2        arg2;
+	T3        arg3;
+	T4        arg4;
+	
+	bool    Execute() { return object ? (object->*method)(arg1, arg2, arg3, arg4) : false; }
+
+	GateMethodActionArg4(O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {}
+};
+
+/*
+template <class O, class R, class M, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4> 
+Gate callback4(O *object, R (M::*method)(Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) 
+{
+	return Gate(
+		new GateMethodActionArg4<O, R (M::*)(Q1, Q2, Q3, Q4), T1, T2, T3, T4>(object, method, arg1, arg2, arg3, arg4));
+}
+
+template <class O, class R, class M, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4> 
+Gate callback4(const O *object, R (M::*method)(Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+	return Gate(new GateMethodActionArg4<const O, R (M::*)(Q1, Q2, Q3, Q4) const, T1, T2, T3, T4>
+	                    (object, method, arg1, arg2, arg3, arg4));
+}
+*/
+
+template <class O, class M, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4> 
+Gate callback4(O *object, bool (M::*method)(Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) 
+{
+	return Gate(
+		new GateMethodActionArg4<O, bool (M::*)(Q1, Q2, Q3, Q4), T1, T2, T3, T4>(object, method, arg1, arg2, arg3, arg4));
+}
+
+template <class O, class M, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4> 
+Gate callback4(const O *object, bool (M::*method)(Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+	return Gate(new GateMethodActionArg4<const O, bool (M::*)(Q1, Q2, Q3, Q4) const, T1, T2, T3, T4>
+	                    (object, method, arg1, arg2, arg3, arg4));
+}
+
+template <class X, class T1, class T2, class T3, class T4, class HC = X>
+struct GateActionCallArg4 : public GateAction {
+	X         x;
+	T1        arg1;
+	T2        arg2;
+	T3        arg3;
+	T4        arg4;
+	bool    Execute() { return x(arg1, arg2, arg3, arg4); }
+
+	GateActionCallArg4(X x, T1 arg1, T2 arg2, T3 arg3, T4 arg4) 
+		: x(x), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {}
+};
+
+/*
+template <class R, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
+Gate callback4(R (*fn)(Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+	return Gate(
+		new GateActionCallArg4<R (*)(Q1, Q2, Q3, Q4), T1, T2, T3, T4, uintptr_t>(fn, arg1, arg2, arg3, arg4));
+}
+*/
+
+template <class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
+Gate callback4(bool (*fn)(Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+	return Gate(
+		new GateActionCallArg4<bool (*)(Q1, Q2, Q3, Q4), T1, T2, T3, T4, uintptr_t>(fn, arg1, arg2, arg3, arg4));
+}
+
+template <class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
+Gate callback4(Gate4<Q1, Q2, Q3, Q4> cb, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+	return Gate(
+		new GateActionCallArg4<Gate4<Q1, Q2, Q3, Q4>, T1, T2, T3, T4>(cb, arg1, arg2, arg3, arg4));
+}
+
+//4 args to Gate1
+
+template <class O, class M, class P1, class T1, class T2, class T3, class T4>
+struct Gate1MethodActionArg4 : public Gate1Action<P1> {
+	O  *object;
+	M   method;
+	T1        arg1;
+	T2        arg2;
+	T3        arg3;
+	T4        arg4;
+	bool    Execute(P1 p1) { return object ? (object->*method)(p1, arg1, arg2, arg3, arg4) : false; }
+
+	Gate1MethodActionArg4(O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {}
+};
+
+template <class O, class M, class P1, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
+Gate1<P1> callback4(O *object, bool (M::*method)(P1, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+	return Gate1<P1>(new Gate1MethodActionArg4<O, bool (M::*)(P1, Q1, Q2, Q3, Q4), P1, T1, T2, T3, T4>
+	                         (object, method, arg1, arg2, arg3, arg4));
+}
+
+template <class O, class M, class P1, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
+Gate1<P1> callback4(const O *object, bool (M::*method)(P1, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+	return Gate1<P1>(new Gate1MethodActionArg4<const O, bool (M::*)(P1, Q1, Q2, Q3, Q4) const, P1, T1, T2, T3, T4>
+	                         (object, method, arg1, arg2, arg3, arg4));
+}
+
+//4 args to Gate2
+
+template <class O, class M, class P1, class P2, class T1, class T2, class T3, class T4>
+struct Gate2MethodActionArg4 : public Gate2Action<P1, P2> {
+	O  *object;
+	M   method;
+	T1        arg1;
+	T2        arg2;
+	T3        arg3;
+	T4        arg4;
+	bool    Execute(P1 p1, P2 p2) { return object ? (object->*method)(p1, p2, arg1, arg2, arg3, arg4) : false; }
+
+	Gate2MethodActionArg4(O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {}
+};
+
+template <class O, class M, class P1, class P2, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
+Gate2<P1, P2> callback4(O *object, bool (M::*method)(P1, P2, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+	return Gate2<P1, P2>(new Gate2MethodActionArg4<O, bool (M::*)(P1, P2, Q1, Q2, Q3, Q4), P1, P2, T1, T2, T3, T4>
+	                         (object, method, arg1, arg2, arg3, arg4));
+}
+
+template <class O, class M, class P1, class P2, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
+Gate2<P1, P2> callback4(const O *object, bool (M::*method)(P1, P2, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+	return Gate2<P1, P2>(new Gate2MethodActionArg4<const O, bool (M::*)(P1, P2, Q1, Q2, Q3, Q4) const, P1, P2, T1, T2, T3, T4>
+	                         (object, method, arg1, arg2, arg3, arg4));
+}
+
+//4 args to Gate3
+
+template <class O, class M, class P1, class P2, class P3, class T1, class T2, class T3, class T4>
+struct Gate3MethodActionArg4 : public Gate3Action<P1, P2, P3> {
+	O  *object;
+	M   method;
+	T1        arg1;
+	T2        arg2;
+	T3        arg3;
+	T3        arg4;
+	bool    Execute(P1 p1, P2 p2, P3 p3) { return object ? (object->*method)(p1, p2, p3, arg1, arg2, arg3, arg4) : false; }
+
+	Gate3MethodActionArg4(O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {}
+};
+
+template <class O, class M, class P1, class P2, class P3, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
+Gate3<P1, P2, P3> callback4(O *object, bool (M::*method)(P1, P2, P3, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+	return Gate3<P1, P2, P3>(new Gate3MethodActionArg4<O, bool (M::*)(P1, P2, P3, Q1, Q2, Q3, Q4), P1, P2, P3, T1, T2, T3, T4>
+	                         (object, method, arg1, arg2, arg3, arg4));
+}
+
+template <class O, class M, class P1, class P2, class P3, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
+Gate3<P1, P2, P3> callback4(const O *object, bool (M::*method)(P1, P2, P3, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+	return Gate3<P1, P2, P3>(new Gate3MethodActionArg4<const O, bool (M::*)(P1, P2, P3, Q1, Q2, Q3, Q4) const, P1, P2, P3, T1, T2, T3, T4>
+	                         (object, method, arg1, arg2, arg3, arg4));
+}
+
+//4 args to Gate4
+
+template <class O, class M, class P1, class P2, class P3, class P4, class T1, class T2, class T3, class T4>
+struct Gate4MethodActionArg4 : public Gate4Action<P1, P2, P3, P4> {
+	O  *object;
+	M   method;
+	T1        arg1;
+	T2        arg2;
+	T3        arg3;
+	T4        arg4;
+	bool    Execute(P1 p1, P2 p2, P3 p3, P4 p4) { return object ? (object->*method)(p1, p2, p3, p4, arg1, arg2, arg3, arg4) : false; }
+
+	Gate4MethodActionArg4(O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+	: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {}
+};
+
+template <class O, class M, class P1, class P2, class P3, class P4, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
+Gate4<P1, P2, P3, P4> callback4(O *object, bool (M::*method)(P1, P2, P3, P4, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+	return Gate4<P1, P2, P3, P4>(new Gate4MethodActionArg4<O, bool (M::*)(P1, P2, P3, P4, Q1, Q2, Q3, Q4), P1, P2, P3, P4, T1, T2, T3, T4>
+	                         (object, method, arg1, arg2, arg3, arg4));
+}
+
+template <class O, class M, class P1, class P2, class P3, class P4, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
+Gate4<P1, P2, P3, P4> callback4(const O *object, bool (M::*method)(P1, P2, P3, P4, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+	return Gate4<P1, P2, P3, P4>(new Gate4MethodActionArg4<const O, bool (M::*)(P1, P2, P3, P4, Q1, Q2, Q3, Q4) const, P1, P2, P3, P4, T1, T2, T3, T4>
+	                         (object, method, arg1, arg2, arg3, arg4));
+}
diff --git a/uppsrc/Core/Cbgen.h b/uppsrc/Core/Cbgen.h
index 36bae5476..e94fc9489 100644
--- a/uppsrc/Core/Cbgen.h
+++ b/uppsrc/Core/Cbgen.h
@@ -1,5 +1,3 @@
-#ifndef CPP_PART__
-
 // -----------------------------------------------------------
 
 struct CallbackAction {
@@ -12,35 +10,6 @@ struct CallbackAction {
 	virtual ~CallbackAction() {}
 };
 
-template <class OBJECT, class METHOD>
-struct CallbackMethodActionPte : public CallbackAction {
-	Ptr<OBJECT>  object;
-	METHOD       method;
-
-	void Execute() { if(object) (object->*method)(); }
-	bool IsValid() const { return object; }
-
-	CallbackMethodActionPte(OBJECT *object, METHOD method) : object(object), method(method) {}
-};
-
-template <class OBJECT, class METHOD>
-struct CallbackMethodAction : public CallbackAction {
-	OBJECT  *object;
-	METHOD   method;
-
-	void Execute() { (object->*method)(); }
-
-	CallbackMethodAction(OBJECT *object, METHOD method) : object(object), method(method) {}
-};
-
-struct CallbackFnAction : public CallbackAction {
-	void (*fn)();
-
-	void Execute() { (*fn)(); }
-
-	CallbackFnAction(void (*fn)()) : fn(fn) {}
-};
-
 class Callback : Moveable< Callback > {
 	CallbackAction *action;
 
@@ -71,81 +40,6 @@ public:
 
 };
 
-template <class OBJECT, class METHOD>
-Callback pteback(OBJECT *object, void (METHOD::*method)()) {
-	return Callback(new CallbackMethodActionPte<OBJECT, void (METHOD::*)()>(object, method));
-}
-
-template <class OBJECT, class METHOD>
-Callback callback(OBJECT *object, void (METHOD::*method)()) {
-	return Callback(new CallbackMethodAction<OBJECT, void (METHOD::*)()>(object, method));
-}
-
-template <class OBJECT, class METHOD>
-Callback callback(const OBJECT *object, void (METHOD::*method)() const) {
-	return Callback(new CallbackMethodAction<const OBJECT, void (METHOD::*)() const>(object, method));
-}
-
-inline Callback callback(void (*fn)()) {
-	return Callback(new CallbackFnAction (fn));
-}
-
-struct CallbackForkAction : public CallbackAction {
-	Callback cb1, cb2;
-
-	void Execute() { cb1(); cb2(); }
-
-	CallbackForkAction(Callback cb1, Callback cb2)
-		 : cb1(cb1), cb2(cb2) {}
-};
-
-inline Callback Proxy(Callback& cb)
-{
-	return callback(&cb, &Callback::Execute);
-}
-
-Callback callback(Callback cb1, Callback cb2);
-Callback& operator<<(Callback& a, Callback b);
-
-#endif
-#ifdef CPP_PART__
-
-Callback callback(Callback cb1, Callback cb2)
-{
-	return Callback(new CallbackForkAction (cb1, cb2));
-}
-
-Callback& operator<<(Callback& a, Callback b)
-{
-	if(a)
-		a = callback(a, b);
-	else
-		a = b;
-	return a;
-}
-
-Callback& Callback::operator=(const Callback& c)
-{
-	c.Retain();
-	Release();
-	action = c.action;
-	return *this;
-}
-
-Callback::Callback(const Callback& c)
-{
-	action = c.action;
-	Retain();
-}
-
-Callback::~Callback()
-{
-	Release();
-}
-
-#endif
-#ifndef CPP_PART__
-
 // -----------------------------------------------------------
 
 template <class P1>
@@ -159,36 +53,6 @@ struct Callback1Action {
 	virtual ~Callback1Action() {}
 };
 
-template <class OBJECT, class METHOD, class P1>
-struct Callback1MethodActionPte : public Callback1Action<P1> {
-	Ptr<OBJECT>  object;
-	METHOD       method;
-
-	void Execute(P1 p1) { if(object) (object->*method)(p1); }
-	bool IsValid() const { return object; }
-
-	Callback1MethodActionPte(OBJECT *object, METHOD method) : object(object), method(method) {}
-};
-
-template <class OBJECT, class METHOD, class P1>
-struct Callback1MethodAction : public Callback1Action<P1> {
-	OBJECT  *object;
-	METHOD   method;
-
-	void Execute(P1 p1) { (object->*method)(p1); }
-
-	Callback1MethodAction(OBJECT *object, METHOD method) : object(object), method(method) {}
-};
-
-template <class P1>
-struct Callback1FnAction : public Callback1Action<P1> {
-	void (*fn)(P1 p1);
-
-	void Execute(P1 p1) { (*fn)(p1); }
-
-	Callback1FnAction(void (*fn)(P1 p1)) : fn(fn) {}
-};
-
 template <class P1>
 class Callback1 : Moveable< Callback1<P1> > {
 	Callback1Action<P1> *action;
@@ -220,58 +84,6 @@ public:
 
 };
 
-template <class OBJECT, class METHOD, class P1>
-Callback1<P1> pteback(OBJECT *object, void (METHOD::*method)(P1 p1)) {
-	return Callback1<P1>(new Callback1MethodActionPte<OBJECT, void (METHOD::*)(P1 p1), P1>(object, method));
-}
-
-template <class OBJECT, class METHOD, class P1>
-Callback1<P1> callback(OBJECT *object, void (METHOD::*method)(P1 p1)) {
-	return Callback1<P1>(new Callback1MethodAction<OBJECT, void (METHOD::*)(P1 p1), P1>(object, method));
-}
-
-template <class OBJECT, class METHOD, class P1>
-Callback1<P1> callback(const OBJECT *object, void (METHOD::*method)(P1 p1) const) {
-	return Callback1<P1>(new Callback1MethodAction<const OBJECT, void (METHOD::*)(P1 p1) const, P1>(object, method));
-}
-
-template <class P1>
-inline Callback1<P1> callback(void (*fn)(P1 p1)) {
-	return Callback1<P1>(new Callback1FnAction <P1>(fn));
-}
-
-template <class P1>
-struct Callback1ForkAction : public Callback1Action<P1> {
-	Callback1<P1> cb1, cb2;
-
-	void Execute(P1 p1) { cb1(p1); cb2(p1); }
-
-	Callback1ForkAction(Callback1<P1> cb1, Callback1<P1> cb2)
-		 : cb1(cb1), cb2(cb2) {}
-};
-
-template <class P1>
-inline Callback1<P1> Proxy(Callback1<P1>& cb)
-{
-	return callback(&cb, &Callback1<P1>::Execute);
-}
-
-template <class P1>
-Callback1<P1> callback(Callback1<P1> cb1, Callback1<P1> cb2)
-{
-	return Callback1<P1>(new Callback1ForkAction <P1>(cb1, cb2));
-}
-
-template <class P1>
-Callback1<P1>& operator<<(Callback1<P1>& a, Callback1<P1> b)
-{
-	if(a)
-		a = callback(a, b);
-	else
-		a = b;
-	return a;
-}
-
 template <class P1>
 Callback1<P1>& Callback1<P1>::operator=(const Callback1& c)
 {
@@ -307,36 +119,6 @@ struct Callback2Action {
 	virtual ~Callback2Action() {}
 };
 
-template <class OBJECT, class METHOD, class P1, class P2>
-struct Callback2MethodActionPte : public Callback2Action<P1, P2> {
-	Ptr<OBJECT>  object;
-	METHOD       method;
-
-	void Execute(P1 p1, P2 p2) { if(object) (object->*method)(p1, p2); }
-	bool IsValid() const { return object; }
-
-	Callback2MethodActionPte(OBJECT *object, METHOD method) : object(object), method(method) {}
-};
-
-template <class OBJECT, class METHOD, class P1, class P2>
-struct Callback2MethodAction : public Callback2Action<P1, P2> {
-	OBJECT  *object;
-	METHOD   method;
-
-	void Execute(P1 p1, P2 p2) { (object->*method)(p1, p2); }
-
-	Callback2MethodAction(OBJECT *object, METHOD method) : object(object), method(method) {}
-};
-
-template <class P1, class P2>
-struct Callback2FnAction : public Callback2Action<P1, P2> {
-	void (*fn)(P1 p1, P2 p2);
-
-	void Execute(P1 p1, P2 p2) { (*fn)(p1, p2); }
-
-	Callback2FnAction(void (*fn)(P1 p1, P2 p2)) : fn(fn) {}
-};
-
 template <class P1, class P2>
 class Callback2 : Moveable< Callback2<P1, P2> > {
 	Callback2Action<P1, P2> *action;
@@ -368,58 +150,6 @@ public:
 
 };
 
-template <class OBJECT, class METHOD, class P1, class P2>
-Callback2<P1, P2> pteback(OBJECT *object, void (METHOD::*method)(P1 p1, P2 p2)) {
-	return Callback2<P1, P2>(new Callback2MethodActionPte<OBJECT, void (METHOD::*)(P1 p1, P2 p2), P1, P2>(object, method));
-}
-
-template <class OBJECT, class METHOD, class P1, class P2>
-Callback2<P1, P2> callback(OBJECT *object, void (METHOD::*method)(P1 p1, P2 p2)) {
-	return Callback2<P1, P2>(new Callback2MethodAction<OBJECT, void (METHOD::*)(P1 p1, P2 p2), P1, P2>(object, method));
-}
-
-template <class OBJECT, class METHOD, class P1, class P2>
-Callback2<P1, P2> callback(const OBJECT *object, void (METHOD::*method)(P1 p1, P2 p2) const) {
-	return Callback2<P1, P2>(new Callback2MethodAction<const OBJECT, void (METHOD::*)(P1 p1, P2 p2) const, P1, P2>(object, method));
-}
-
-template <class P1, class P2>
-inline Callback2<P1, P2> callback(void (*fn)(P1 p1, P2 p2)) {
-	return Callback2<P1, P2>(new Callback2FnAction <P1, P2>(fn));
-}
-
-template <class P1, class P2>
-struct Callback2ForkAction : public Callback2Action<P1, P2> {
-	Callback2<P1, P2> cb1, cb2;
-
-	void Execute(P1 p1, P2 p2) { cb1(p1, p2); cb2(p1, p2); }
-
-	Callback2ForkAction(Callback2<P1, P2> cb1, Callback2<P1, P2> cb2)
-		 : cb1(cb1), cb2(cb2) {}
-};
-
-template <class P1, class P2>
-inline Callback2<P1, P2> Proxy(Callback2<P1, P2>& cb)
-{
-	return callback(&cb, &Callback2<P1, P2>::Execute);
-}
-
-template <class P1, class P2>
-Callback2<P1, P2> callback(Callback2<P1, P2> cb1, Callback2<P1, P2> cb2)
-{
-	return Callback2<P1, P2>(new Callback2ForkAction <P1, P2>(cb1, cb2));
-}
-
-template <class P1, class P2>
-Callback2<P1, P2>& operator<<(Callback2<P1, P2>& a, Callback2<P1, P2> b)
-{
-	if(a)
-		a = callback(a, b);
-	else
-		a = b;
-	return a;
-}
-
 template <class P1, class P2>
 Callback2<P1, P2>& Callback2<P1, P2>::operator=(const Callback2& c)
 {
@@ -455,36 +185,6 @@ struct Callback3Action {
 	virtual ~Callback3Action() {}
 };
 
-template <class OBJECT, class METHOD, class P1, class P2, class P3>
-struct Callback3MethodActionPte : public Callback3Action<P1, P2, P3> {
-	Ptr<OBJECT>  object;
-	METHOD       method;
-
-	void Execute(P1 p1, P2 p2, P3 p3) { if(object) (object->*method)(p1, p2, p3); }
-	bool IsValid() const { return object; }
-
-	Callback3MethodActionPte(OBJECT *object, METHOD method) : object(object), method(method) {}
-};
-
-template <class OBJECT, class METHOD, class P1, class P2, class P3>
-struct Callback3MethodAction : public Callback3Action<P1, P2, P3> {
-	OBJECT  *object;
-	METHOD   method;
-
-	void Execute(P1 p1, P2 p2, P3 p3) { (object->*method)(p1, p2, p3); }
-
-	Callback3MethodAction(OBJECT *object, METHOD method) : object(object), method(method) {}
-};
-
-template <class P1, class P2, class P3>
-struct Callback3FnAction : public Callback3Action<P1, P2, P3> {
-	void (*fn)(P1 p1, P2 p2, P3 p3);
-
-	void Execute(P1 p1, P2 p2, P3 p3) { (*fn)(p1, p2, p3); }
-
-	Callback3FnAction(void (*fn)(P1 p1, P2 p2, P3 p3)) : fn(fn) {}
-};
-
 template <class P1, class P2, class P3>
 class Callback3 : Moveable< Callback3<P1, P2, P3> > {
 	Callback3Action<P1, P2, P3> *action;
@@ -516,58 +216,6 @@ public:
 
 };
 
-template <class OBJECT, class METHOD, class P1, class P2, class P3>
-Callback3<P1, P2, P3> pteback(OBJECT *object, void (METHOD::*method)(P1 p1, P2 p2, P3 p3)) {
-	return Callback3<P1, P2, P3>(new Callback3MethodActionPte<OBJECT, void (METHOD::*)(P1 p1, P2 p2, P3 p3), P1, P2, P3>(object, method));
-}
-
-template <class OBJECT, class METHOD, class P1, class P2, class P3>
-Callback3<P1, P2, P3> callback(OBJECT *object, void (METHOD::*method)(P1 p1, P2 p2, P3 p3)) {
-	return Callback3<P1, P2, P3>(new Callback3MethodAction<OBJECT, void (METHOD::*)(P1 p1, P2 p2, P3 p3), P1, P2, P3>(object, method));
-}
-
-template <class OBJECT, class METHOD, class P1, class P2, class P3>
-Callback3<P1, P2, P3> callback(const OBJECT *object, void (METHOD::*method)(P1 p1, P2 p2, P3 p3) const) {
-	return Callback3<P1, P2, P3>(new Callback3MethodAction<const OBJECT, void (METHOD::*)(P1 p1, P2 p2, P3 p3) const, P1, P2, P3>(object, method));
-}
-
-template <class P1, class P2, class P3>
-inline Callback3<P1, P2, P3> callback(void (*fn)(P1 p1, P2 p2, P3 p3)) {
-	return Callback3<P1, P2, P3>(new Callback3FnAction <P1, P2, P3>(fn));
-}
-
-template <class P1, class P2, class P3>
-struct Callback3ForkAction : public Callback3Action<P1, P2, P3> {
-	Callback3<P1, P2, P3> cb1, cb2;
-
-	void Execute(P1 p1, P2 p2, P3 p3) { cb1(p1, p2, p3); cb2(p1, p2, p3); }
-
-	Callback3ForkAction(Callback3<P1, P2, P3> cb1, Callback3<P1, P2, P3> cb2)
-		 : cb1(cb1), cb2(cb2) {}
-};
-
-template <class P1, class P2, class P3>
-inline Callback3<P1, P2, P3> Proxy(Callback3<P1, P2, P3>& cb)
-{
-	return callback(&cb, &Callback3<P1, P2, P3>::Execute);
-}
-
-template <class P1, class P2, class P3>
-Callback3<P1, P2, P3> callback(Callback3<P1, P2, P3> cb1, Callback3<P1, P2, P3> cb2)
-{
-	return Callback3<P1, P2, P3>(new Callback3ForkAction <P1, P2, P3>(cb1, cb2));
-}
-
-template <class P1, class P2, class P3>
-Callback3<P1, P2, P3>& operator<<(Callback3<P1, P2, P3>& a, Callback3<P1, P2, P3> b)
-{
-	if(a)
-		a = callback(a, b);
-	else
-		a = b;
-	return a;
-}
-
 template <class P1, class P2, class P3>
 Callback3<P1, P2, P3>& Callback3<P1, P2, P3>::operator=(const Callback3& c)
 {
@@ -603,36 +251,6 @@ struct Callback4Action {
 	virtual ~Callback4Action() {}
 };
 
-template <class OBJECT, class METHOD, class P1, class P2, class P3, class P4>
-struct Callback4MethodActionPte : public Callback4Action<P1, P2, P3, P4> {
-	Ptr<OBJECT>  object;
-	METHOD       method;
-
-	void Execute(P1 p1, P2 p2, P3 p3, P4 p4) { if(object) (object->*method)(p1, p2, p3, p4); }
-	bool IsValid() const { return object; }
-
-	Callback4MethodActionPte(OBJECT *object, METHOD method) : object(object), method(method) {}
-};
-
-template <class OBJECT, class METHOD, class P1, class P2, class P3, class P4>
-struct Callback4MethodAction : public Callback4Action<P1, P2, P3, P4> {
-	OBJECT  *object;
-	METHOD   method;
-
-	void Execute(P1 p1, P2 p2, P3 p3, P4 p4) { (object->*method)(p1, p2, p3, p4); }
-
-	Callback4MethodAction(OBJECT *object, METHOD method) : object(object), method(method) {}
-};
-
-template <class P1, class P2, class P3, class P4>
-struct Callback4FnAction : public Callback4Action<P1, P2, P3, P4> {
-	void (*fn)(P1 p1, P2 p2, P3 p3, P4 p4);
-
-	void Execute(P1 p1, P2 p2, P3 p3, P4 p4) { (*fn)(p1, p2, p3, p4); }
-
-	Callback4FnAction(void (*fn)(P1 p1, P2 p2, P3 p3, P4 p4)) : fn(fn) {}
-};
-
 template <class P1, class P2, class P3, class P4>
 class Callback4 : Moveable< Callback4<P1, P2, P3, P4> > {
 	Callback4Action<P1, P2, P3, P4> *action;
@@ -664,58 +282,6 @@ public:
 
 };
 
-template <class OBJECT, class METHOD, class P1, class P2, class P3, class P4>
-Callback4<P1, P2, P3, P4> pteback(OBJECT *object, void (METHOD::*method)(P1 p1, P2 p2, P3 p3, P4 p4)) {
-	return Callback4<P1, P2, P3, P4>(new Callback4MethodActionPte<OBJECT, void (METHOD::*)(P1 p1, P2 p2, P3 p3, P4 p4), P1, P2, P3, P4>(object, method));
-}
-
-template <class OBJECT, class METHOD, class P1, class P2, class P3, class P4>
-Callback4<P1, P2, P3, P4> callback(OBJECT *object, void (METHOD::*method)(P1 p1, P2 p2, P3 p3, P4 p4)) {
-	return Callback4<P1, P2, P3, P4>(new Callback4MethodAction<OBJECT, void (METHOD::*)(P1 p1, P2 p2, P3 p3, P4 p4), P1, P2, P3, P4>(object, method));
-}
-
-template <class OBJECT, class METHOD, class P1, class P2, class P3, class P4>
-Callback4<P1, P2, P3, P4> callback(const OBJECT *object, void (METHOD::*method)(P1 p1, P2 p2, P3 p3, P4 p4) const) {
-	return Callback4<P1, P2, P3, P4>(new Callback4MethodAction<const OBJECT, void (METHOD::*)(P1 p1, P2 p2, P3 p3, P4 p4) const, P1, P2, P3, P4>(object, method));
-}
-
-template <class P1, class P2, class P3, class P4>
-inline Callback4<P1, P2, P3, P4> callback(void (*fn)(P1 p1, P2 p2, P3 p3, P4 p4)) {
-	return Callback4<P1, P2, P3, P4>(new Callback4FnAction <P1, P2, P3, P4>(fn));
-}
-
-template <class P1, class P2, class P3, class P4>
-struct Callback4ForkAction : public Callback4Action<P1, P2, P3, P4> {
-	Callback4<P1, P2, P3, P4> cb1, cb2;
-
-	void Execute(P1 p1, P2 p2, P3 p3, P4 p4) { cb1(p1, p2, p3, p4); cb2(p1, p2, p3, p4); }
-
-	Callback4ForkAction(Callback4<P1, P2, P3, P4> cb1, Callback4<P1, P2, P3, P4> cb2)
-		 : cb1(cb1), cb2(cb2) {}
-};
-
-template <class P1, class P2, class P3, class P4>
-inline Callback4<P1, P2, P3, P4> Proxy(Callback4<P1, P2, P3, P4>& cb)
-{
-	return callback(&cb, &Callback4<P1, P2, P3, P4>::Execute);
-}
-
-template <class P1, class P2, class P3, class P4>
-Callback4<P1, P2, P3, P4> callback(Callback4<P1, P2, P3, P4> cb1, Callback4<P1, P2, P3, P4> cb2)
-{
-	return Callback4<P1, P2, P3, P4>(new Callback4ForkAction <P1, P2, P3, P4>(cb1, cb2));
-}
-
-template <class P1, class P2, class P3, class P4>
-Callback4<P1, P2, P3, P4>& operator<<(Callback4<P1, P2, P3, P4>& a, Callback4<P1, P2, P3, P4> b)
-{
-	if(a)
-		a = callback(a, b);
-	else
-		a = b;
-	return a;
-}
-
 template <class P1, class P2, class P3, class P4>
 Callback4<P1, P2, P3, P4>& Callback4<P1, P2, P3, P4>::operator=(const Callback4& c)
 {
@@ -750,35 +316,6 @@ struct GateAction {
 	virtual ~GateAction() {}
 };
 
-template <class OBJECT, class METHOD>
-struct GateMethodActionPte : public GateAction {
-	Ptr<OBJECT>  object;
-	METHOD       method;
-
-	bool Execute() { return object ? (object->*method)() : false; }
-	bool IsValid() const { return object; }
-
-	GateMethodActionPte(OBJECT *object, METHOD method) : object(object), method(method) {}
-};
-
-template <class OBJECT, class METHOD>
-struct GateMethodAction : public GateAction {
-	OBJECT  *object;
-	METHOD   method;
-
-	bool Execute() { return (object->*method)(); }
-
-	GateMethodAction(OBJECT *object, METHOD method) : object(object), method(method) {}
-};
-
-struct GateFnAction : public GateAction {
-	bool (*fn)();
-
-	bool Execute() { return (*fn)(); }
-
-	GateFnAction(bool (*fn)()) : fn(fn) {}
-};
-
 class Gate : Moveable< Gate > {
 	GateAction *action;
 
@@ -813,81 +350,6 @@ public:
 
 };
 
-template <class OBJECT, class METHOD>
-Gate pteback(OBJECT *object, bool (METHOD::*method)()) {
-	return Gate(new GateMethodActionPte<OBJECT, bool (METHOD::*)()>(object, method));
-}
-
-template <class OBJECT, class METHOD>
-Gate callback(OBJECT *object, bool (METHOD::*method)()) {
-	return Gate(new GateMethodAction<OBJECT, bool (METHOD::*)()>(object, method));
-}
-
-template <class OBJECT, class METHOD>
-Gate callback(const OBJECT *object, bool (METHOD::*method)() const) {
-	return Gate(new GateMethodAction<const OBJECT, bool (METHOD::*)() const>(object, method));
-}
-
-inline Gate callback(bool (*fn)()) {
-	return Gate(new GateFnAction (fn));
-}
-
-struct GateForkAction : public GateAction {
-	Gate cb1, cb2;
-
-	bool Execute() { cb1(); return cb2(); }
-
-	GateForkAction(Gate cb1, Gate cb2)
-		 : cb1(cb1), cb2(cb2) {}
-};
-
-inline Gate Proxy(Gate& cb)
-{
-	return callback(&cb, &Gate::Execute);
-}
-
-Gate callback(Gate cb1, Gate cb2);
-Gate& operator<<(Gate& a, Gate b);
-
-#endif
-#ifdef CPP_PART__
-
-Gate callback(Gate cb1, Gate cb2)
-{
-	return Gate(new GateForkAction (cb1, cb2));
-}
-
-Gate& operator<<(Gate& a, Gate b)
-{
-	if(a)
-		a = callback(a, b);
-	else
-		a = b;
-	return a;
-}
-
-Gate& Gate::operator=(const Gate& c)
-{
-	c.Retain();
-	Release();
-	action = c.action;
-	return *this;
-}
-
-Gate::Gate(const Gate& c)
-{
-	action = c.action;
-	Retain();
-}
-
-Gate::~Gate()
-{
-	Release();
-}
-
-#endif
-#ifndef CPP_PART__
-
 // -----------------------------------------------------------
 
 template <class P1>
@@ -901,36 +363,6 @@ struct Gate1Action {
 	virtual ~Gate1Action() {}
 };
 
-template <class OBJECT, class METHOD, class P1>
-struct Gate1MethodActionPte : public Gate1Action<P1> {
-	Ptr<OBJECT>  object;
-	METHOD       method;
-
-	bool Execute(P1 p1) { return object ? (object->*method)(p1) : false; }
-	bool IsValid() const { return object; }
-
-	Gate1MethodActionPte(OBJECT *object, METHOD method) : object(object), method(method) {}
-};
-
-template <class OBJECT, class METHOD, class P1>
-struct Gate1MethodAction : public Gate1Action<P1> {
-	OBJECT  *object;
-	METHOD   method;
-
-	bool Execute(P1 p1) { return (object->*method)(p1); }
-
-	Gate1MethodAction(OBJECT *object, METHOD method) : object(object), method(method) {}
-};
-
-template <class P1>
-struct Gate1FnAction : public Gate1Action<P1> {
-	bool (*fn)(P1 p1);
-
-	bool Execute(P1 p1) { return (*fn)(p1); }
-
-	Gate1FnAction(bool (*fn)(P1 p1)) : fn(fn) {}
-};
-
 template <class P1>
 class Gate1 : Moveable< Gate1<P1> > {
 	Gate1Action<P1> *action;
@@ -950,7 +382,8 @@ public:
 
 
 	operator bool() const        { return (void *)action != (void *)1 && action && action->IsValid(); }
-	bool Execute(P1 p1) const;
+	bool Execute(P1 p1) const	 { return (void *)action == (void *)1 ? true : action ? action->Execute(p1) : false; }
+
 	bool operator()(P1 p1) const { return Execute(p1); }
 	void ClearTrue()             { Clear(); action = (Gate1Action<P1> *)1; }
 	void ClearFalse()            { Clear(); }
@@ -966,58 +399,6 @@ public:
 
 };
 
-template <class OBJECT, class METHOD, class P1>
-Gate1<P1> pteback(OBJECT *object, bool (METHOD::*method)(P1 p1)) {
-	return Gate1<P1>(new Gate1MethodActionPte<OBJECT, bool (METHOD::*)(P1 p1), P1>(object, method));
-}
-
-template <class OBJECT, class METHOD, class P1>
-Gate1<P1> callback(OBJECT *object, bool (METHOD::*method)(P1 p1)) {
-	return Gate1<P1>(new Gate1MethodAction<OBJECT, bool (METHOD::*)(P1 p1), P1>(object, method));
-}
-
-template <class OBJECT, class METHOD, class P1>
-Gate1<P1> callback(const OBJECT *object, bool (METHOD::*method)(P1 p1) const) {
-	return Gate1<P1>(new Gate1MethodAction<const OBJECT, bool (METHOD::*)(P1 p1) const, P1>(object, method));
-}
-
-template <class P1>
-inline Gate1<P1> callback(bool (*fn)(P1 p1)) {
-	return Gate1<P1>(new Gate1FnAction <P1>(fn));
-}
-
-template <class P1>
-struct Gate1ForkAction : public Gate1Action<P1> {
-	Gate1<P1> cb1, cb2;
-
-	bool Execute(P1 p1) { cb1(p1); return cb2(p1); }
-
-	Gate1ForkAction(Gate1<P1> cb1, Gate1<P1> cb2)
-		 : cb1(cb1), cb2(cb2) {}
-};
-
-template <class P1>
-inline Gate1<P1> Proxy(Gate1<P1>& cb)
-{
-	return callback(&cb, &Gate1<P1>::Execute);
-}
-
-template <class P1>
-Gate1<P1> callback(Gate1<P1> cb1, Gate1<P1> cb2)
-{
-	return Gate1<P1>(new Gate1ForkAction <P1>(cb1, cb2));
-}
-
-template <class P1>
-Gate1<P1>& operator<<(Gate1<P1>& a, Gate1<P1> b)
-{
-	if(a)
-		a = callback(a, b);
-	else
-		a = b;
-	return a;
-}
-
 template <class P1>
 Gate1<P1>& Gate1<P1>::operator=(const Gate1& c)
 {
@@ -1053,36 +434,6 @@ struct Gate2Action {
 	virtual ~Gate2Action() {}
 };
 
-template <class OBJECT, class METHOD, class P1, class P2>
-struct Gate2MethodActionPte : public Gate2Action<P1, P2> {
-	Ptr<OBJECT>  object;
-	METHOD       method;
-
-	bool Execute(P1 p1, P2 p2) { return object ? (object->*method)(p1, p2) : false; }
-	bool IsValid() const { return object; }
-
-	Gate2MethodActionPte(OBJECT *object, METHOD method) : object(object), method(method) {}
-};
-
-template <class OBJECT, class METHOD, class P1, class P2>
-struct Gate2MethodAction : public Gate2Action<P1, P2> {
-	OBJECT  *object;
-	METHOD   method;
-
-	bool Execute(P1 p1, P2 p2) { return (object->*method)(p1, p2); }
-
-	Gate2MethodAction(OBJECT *object, METHOD method) : object(object), method(method) {}
-};
-
-template <class P1, class P2>
-struct Gate2FnAction : public Gate2Action<P1, P2> {
-	bool (*fn)(P1 p1, P2 p2);
-
-	bool Execute(P1 p1, P2 p2) { return (*fn)(p1, p2); }
-
-	Gate2FnAction(bool (*fn)(P1 p1, P2 p2)) : fn(fn) {}
-};
-
 template <class P1, class P2>
 class Gate2 : Moveable< Gate2<P1, P2> > {
 	Gate2Action<P1, P2> *action;
@@ -1102,7 +453,7 @@ public:
 
 
 	operator bool() const        { return (void *)action != (void *)1 && action && action->IsValid(); }
-	bool Execute(P1 p1, P2 p2) const;
+	bool Execute(P1 p1, P2 p2) const { return (void *)action == (void *)1 ? true : action ? action->Execute(p1, p2) : false; }
 	bool operator()(P1 p1, P2 p2) const { return Execute(p1, p2); }
 	void ClearTrue()             { Clear(); action = (Gate2Action<P1, P2> *)1; }
 	void ClearFalse()            { Clear(); }
@@ -1118,58 +469,6 @@ public:
 
 };
 
-template <class OBJECT, class METHOD, class P1, class P2>
-Gate2<P1, P2> pteback(OBJECT *object, bool (METHOD::*method)(P1 p1, P2 p2)) {
-	return Gate2<P1, P2>(new Gate2MethodActionPte<OBJECT, bool (METHOD::*)(P1 p1, P2 p2), P1, P2>(object, method));
-}
-
-template <class OBJECT, class METHOD, class P1, class P2>
-Gate2<P1, P2> callback(OBJECT *object, bool (METHOD::*method)(P1 p1, P2 p2)) {
-	return Gate2<P1, P2>(new Gate2MethodAction<OBJECT, bool (METHOD::*)(P1 p1, P2 p2), P1, P2>(object, method));
-}
-
-template <class OBJECT, class METHOD, class P1, class P2>
-Gate2<P1, P2> callback(const OBJECT *object, bool (METHOD::*method)(P1 p1, P2 p2) const) {
-	return Gate2<P1, P2>(new Gate2MethodAction<const OBJECT, bool (METHOD::*)(P1 p1, P2 p2) const, P1, P2>(object, method));
-}
-
-template <class P1, class P2>
-inline Gate2<P1, P2> callback(bool (*fn)(P1 p1, P2 p2)) {
-	return Gate2<P1, P2>(new Gate2FnAction <P1, P2>(fn));
-}
-
-template <class P1, class P2>
-struct Gate2ForkAction : public Gate2Action<P1, P2> {
-	Gate2<P1, P2> cb1, cb2;
-
-	bool Execute(P1 p1, P2 p2) { cb1(p1, p2); return cb2(p1, p2); }
-
-	Gate2ForkAction(Gate2<P1, P2> cb1, Gate2<P1, P2> cb2)
-		 : cb1(cb1), cb2(cb2) {}
-};
-
-template <class P1, class P2>
-inline Gate2<P1, P2> Proxy(Gate2<P1, P2>& cb)
-{
-	return callback(&cb, &Gate2<P1, P2>::Execute);
-}
-
-template <class P1, class P2>
-Gate2<P1, P2> callback(Gate2<P1, P2> cb1, Gate2<P1, P2> cb2)
-{
-	return Gate2<P1, P2>(new Gate2ForkAction <P1, P2>(cb1, cb2));
-}
-
-template <class P1, class P2>
-Gate2<P1, P2>& operator<<(Gate2<P1, P2>& a, Gate2<P1, P2> b)
-{
-	if(a)
-		a = callback(a, b);
-	else
-		a = b;
-	return a;
-}
-
 template <class P1, class P2>
 Gate2<P1, P2>& Gate2<P1, P2>::operator=(const Gate2& c)
 {
@@ -1205,36 +504,6 @@ struct Gate3Action {
 	virtual ~Gate3Action() {}
 };
 
-template <class OBJECT, class METHOD, class P1, class P2, class P3>
-struct Gate3MethodActionPte : public Gate3Action<P1, P2, P3> {
-	Ptr<OBJECT>  object;
-	METHOD       method;
-
-	bool Execute(P1 p1, P2 p2, P3 p3) { return object ? (object->*method)(p1, p2, p3) : false; }
-	bool IsValid() const { return object; }
-
-	Gate3MethodActionPte(OBJECT *object, METHOD method) : object(object), method(method) {}
-};
-
-template <class OBJECT, class METHOD, class P1, class P2, class P3>
-struct Gate3MethodAction : public Gate3Action<P1, P2, P3> {
-	OBJECT  *object;
-	METHOD   method;
-
-	bool Execute(P1 p1, P2 p2, P3 p3) { return (object->*method)(p1, p2, p3); }
-
-	Gate3MethodAction(OBJECT *object, METHOD method) : object(object), method(method) {}
-};
-
-template <class P1, class P2, class P3>
-struct Gate3FnAction : public Gate3Action<P1, P2, P3> {
-	bool (*fn)(P1 p1, P2 p2, P3 p3);
-
-	bool Execute(P1 p1, P2 p2, P3 p3) { return (*fn)(p1, p2, p3); }
-
-	Gate3FnAction(bool (*fn)(P1 p1, P2 p2, P3 p3)) : fn(fn) {}
-};
-
 template <class P1, class P2, class P3>
 class Gate3 : Moveable< Gate3<P1, P2, P3> > {
 	Gate3Action<P1, P2, P3> *action;
@@ -1254,7 +523,7 @@ public:
 
 
 	operator bool() const        { return (void *)action != (void *)1 && action && action->IsValid(); }
-	bool Execute(P1 p1, P2 p2, P3 p3) const;
+	bool Execute(P1 p1, P2 p2, P3 p3) const { return (void *)action == (void *)1 ? true : action ? action->Execute(p1, p2, p3) : false; }
 	bool operator()(P1 p1, P2 p2, P3 p3) const { return Execute(p1, p2, p3); }
 	void ClearTrue()             { Clear(); action = (Gate3Action<P1, P2, P3> *)1; }
 	void ClearFalse()            { Clear(); }
@@ -1270,58 +539,6 @@ public:
 
 };
 
-template <class OBJECT, class METHOD, class P1, class P2, class P3>
-Gate3<P1, P2, P3> pteback(OBJECT *object, bool (METHOD::*method)(P1 p1, P2 p2, P3 p3)) {
-	return Gate3<P1, P2, P3>(new Gate3MethodActionPte<OBJECT, bool (METHOD::*)(P1 p1, P2 p2, P3 p3), P1, P2, P3>(object, method));
-}
-
-template <class OBJECT, class METHOD, class P1, class P2, class P3>
-Gate3<P1, P2, P3> callback(OBJECT *object, bool (METHOD::*method)(P1 p1, P2 p2, P3 p3)) {
-	return Gate3<P1, P2, P3>(new Gate3MethodAction<OBJECT, bool (METHOD::*)(P1 p1, P2 p2, P3 p3), P1, P2, P3>(object, method));
-}
-
-template <class OBJECT, class METHOD, class P1, class P2, class P3>
-Gate3<P1, P2, P3> callback(const OBJECT *object, bool (METHOD::*method)(P1 p1, P2 p2, P3 p3) const) {
-	return Gate3<P1, P2, P3>(new Gate3MethodAction<const OBJECT, bool (METHOD::*)(P1 p1, P2 p2, P3 p3) const, P1, P2, P3>(object, method));
-}
-
-template <class P1, class P2, class P3>
-inline Gate3<P1, P2, P3> callback(bool (*fn)(P1 p1, P2 p2, P3 p3)) {
-	return Gate3<P1, P2, P3>(new Gate3FnAction <P1, P2, P3>(fn));
-}
-
-template <class P1, class P2, class P3>
-struct Gate3ForkAction : public Gate3Action<P1, P2, P3> {
-	Gate3<P1, P2, P3> cb1, cb2;
-
-	bool Execute(P1 p1, P2 p2, P3 p3) { cb1(p1, p2, p3); return cb2(p1, p2, p3); }
-
-	Gate3ForkAction(Gate3<P1, P2, P3> cb1, Gate3<P1, P2, P3> cb2)
-		 : cb1(cb1), cb2(cb2) {}
-};
-
-template <class P1, class P2, class P3>
-inline Gate3<P1, P2, P3> Proxy(Gate3<P1, P2, P3>& cb)
-{
-	return callback(&cb, &Gate3<P1, P2, P3>::Execute);
-}
-
-template <class P1, class P2, class P3>
-Gate3<P1, P2, P3> callback(Gate3<P1, P2, P3> cb1, Gate3<P1, P2, P3> cb2)
-{
-	return Gate3<P1, P2, P3>(new Gate3ForkAction <P1, P2, P3>(cb1, cb2));
-}
-
-template <class P1, class P2, class P3>
-Gate3<P1, P2, P3>& operator<<(Gate3<P1, P2, P3>& a, Gate3<P1, P2, P3> b)
-{
-	if(a)
-		a = callback(a, b);
-	else
-		a = b;
-	return a;
-}
-
 template <class P1, class P2, class P3>
 Gate3<P1, P2, P3>& Gate3<P1, P2, P3>::operator=(const Gate3& c)
 {
@@ -1357,36 +574,6 @@ struct Gate4Action {
 	virtual ~Gate4Action() {}
 };
 
-template <class OBJECT, class METHOD, class P1, class P2, class P3, class P4>
-struct Gate4MethodActionPte : public Gate4Action<P1, P2, P3, P4> {
-	Ptr<OBJECT>  object;
-	METHOD       method;
-
-	bool Execute(P1 p1, P2 p2, P3 p3, P4 p4) { return object ? (object->*method)(p1, p2, p3, p4) : false; }
-	bool IsValid() const { return object; }
-
-	Gate4MethodActionPte(OBJECT *object, METHOD method) : object(object), method(method) {}
-};
-
-template <class OBJECT, class METHOD, class P1, class P2, class P3, class P4>
-struct Gate4MethodAction : public Gate4Action<P1, P2, P3, P4> {
-	OBJECT  *object;
-	METHOD   method;
-
-	bool Execute(P1 p1, P2 p2, P3 p3, P4 p4) { return (object->*method)(p1, p2, p3, p4); }
-
-	Gate4MethodAction(OBJECT *object, METHOD method) : object(object), method(method) {}
-};
-
-template <class P1, class P2, class P3, class P4>
-struct Gate4FnAction : public Gate4Action<P1, P2, P3, P4> {
-	bool (*fn)(P1 p1, P2 p2, P3 p3, P4 p4);
-
-	bool Execute(P1 p1, P2 p2, P3 p3, P4 p4) { return (*fn)(p1, p2, p3, p4); }
-
-	Gate4FnAction(bool (*fn)(P1 p1, P2 p2, P3 p3, P4 p4)) : fn(fn) {}
-};
-
 template <class P1, class P2, class P3, class P4>
 class Gate4 : Moveable< Gate4<P1, P2, P3, P4> > {
 	Gate4Action<P1, P2, P3, P4> *action;
@@ -1406,7 +593,7 @@ public:
 
 
 	operator bool() const        { return (void *)action != (void *)1 && action && action->IsValid(); }
-	bool Execute(P1 p1, P2 p2, P3 p3, P4 p4) const;
+	bool Execute(P1 p1, P2 p2, P3 p3, P4 p4) const { return (void *)action == (void *)1 ? true : action ? action->Execute(p1, p2, p3, p4) : false; }
 	bool operator()(P1 p1, P2 p2, P3 p3, P4 p4) const { return Execute(p1, p2, p3, p4); }
 	void ClearTrue()             { Clear(); action = (Gate4Action<P1, P2, P3, P4> *)1; }
 	void ClearFalse()            { Clear(); }
@@ -1422,58 +609,6 @@ public:
 
 };
 
-template <class OBJECT, class METHOD, class P1, class P2, class P3, class P4>
-Gate4<P1, P2, P3, P4> pteback(OBJECT *object, bool (METHOD::*method)(P1 p1, P2 p2, P3 p3, P4 p4)) {
-	return Gate4<P1, P2, P3, P4>(new Gate4MethodActionPte<OBJECT, bool (METHOD::*)(P1 p1, P2 p2, P3 p3, P4 p4), P1, P2, P3, P4>(object, method));
-}
-
-template <class OBJECT, class METHOD, class P1, class P2, class P3, class P4>
-Gate4<P1, P2, P3, P4> callback(OBJECT *object, bool (METHOD::*method)(P1 p1, P2 p2, P3 p3, P4 p4)) {
-	return Gate4<P1, P2, P3, P4>(new Gate4MethodAction<OBJECT, bool (METHOD::*)(P1 p1, P2 p2, P3 p3, P4 p4), P1, P2, P3, P4>(object, method));
-}
-
-template <class OBJECT, class METHOD, class P1, class P2, class P3, class P4>
-Gate4<P1, P2, P3, P4> callback(const OBJECT *object, bool (METHOD::*method)(P1 p1, P2 p2, P3 p3, P4 p4) const) {
-	return Gate4<P1, P2, P3, P4>(new Gate4MethodAction<const OBJECT, bool (METHOD::*)(P1 p1, P2 p2, P3 p3, P4 p4) const, P1, P2, P3, P4>(object, method));
-}
-
-template <class P1, class P2, class P3, class P4>
-inline Gate4<P1, P2, P3, P4> callback(bool (*fn)(P1 p1, P2 p2, P3 p3, P4 p4)) {
-	return Gate4<P1, P2, P3, P4>(new Gate4FnAction <P1, P2, P3, P4>(fn));
-}
-
-template <class P1, class P2, class P3, class P4>
-struct Gate4ForkAction : public Gate4Action<P1, P2, P3, P4> {
-	Gate4<P1, P2, P3, P4> cb1, cb2;
-
-	bool Execute(P1 p1, P2 p2, P3 p3, P4 p4) { cb1(p1, p2, p3, p4); return cb2(p1, p2, p3, p4); }
-
-	Gate4ForkAction(Gate4<P1, P2, P3, P4> cb1, Gate4<P1, P2, P3, P4> cb2)
-		 : cb1(cb1), cb2(cb2) {}
-};
-
-template <class P1, class P2, class P3, class P4>
-inline Gate4<P1, P2, P3, P4> Proxy(Gate4<P1, P2, P3, P4>& cb)
-{
-	return callback(&cb, &Gate4<P1, P2, P3, P4>::Execute);
-}
-
-template <class P1, class P2, class P3, class P4>
-Gate4<P1, P2, P3, P4> callback(Gate4<P1, P2, P3, P4> cb1, Gate4<P1, P2, P3, P4> cb2)
-{
-	return Gate4<P1, P2, P3, P4>(new Gate4ForkAction <P1, P2, P3, P4>(cb1, cb2));
-}
-
-template <class P1, class P2, class P3, class P4>
-Gate4<P1, P2, P3, P4>& operator<<(Gate4<P1, P2, P3, P4>& a, Gate4<P1, P2, P3, P4> b)
-{
-	if(a)
-		a = callback(a, b);
-	else
-		a = b;
-	return a;
-}
-
 template <class P1, class P2, class P3, class P4>
 Gate4<P1, P2, P3, P4>& Gate4<P1, P2, P3, P4>::operator=(const Gate4& c)
 {
@@ -1495,6 +630,3 @@ Gate4<P1, P2, P3, P4>::~Gate4()
 {
 	Release();
 }
-
-
-#endif
diff --git a/uppsrc/Core/Core.upp b/uppsrc/Core/Core.upp
index 46657212f..b023f79f9 100644
--- a/uppsrc/Core/Core.upp
+++ b/uppsrc/Core/Core.upp
@@ -88,6 +88,11 @@ file
 	Hash.cpp optimize_speed,
 	Concretes readonly separator,
 	Cbgen.h,
+	Callback0.h,
+	Callback1.h,
+	Callback2.h,
+	Callback3.h,
+	Callback4.h,
 	Callback.h,
 	Callback.cpp optimize_speed,
 	TimeDate.h,