コミット: 23811455b2b715fe64e9f8981c4550f0171c9bbf - MG (git)

milligram

コミットメタ情報

• リビジョン: 23811455b2b715fe64e9f8981c4550f0171c9bbf (tree)
• 日時: 2011-03-25 17:04:20
• 作者: beru <berupon@gmai...>
• コミッター: beru

ログメッセージ

basic event system implemented

変更サマリ

• delete: common/callback.hpp
• modified: main.cpp
• modified: main_plus.cpp
• modified: mg.vcproj
• modified: mg/button.cpp
• modified: mg/button.h
• modified: mg/container.cpp
• modified: mg/container.h
• modified: mg/element.cpp
• modified: mg/element.h
• modified: mg/rectangle.cpp
• modified: mg/rectangle.h

差分

--- a/common/callback.hpp
+++ /dev/null
@@ -1,1038 +0,0 @@
-#ifndef UTIL_CALLBACK_HPP
-#define UTIL_CALLBACK_HPP
-
-#define UTIL_GET_CALLBACK_FACTORY_BIND_FREE(freeFuncPtr) \
-    (util::GetCallbackFactory(freeFuncPtr).Bind<freeFuncPtr>())
-#define BIND_FREE_CB UTIL_GET_CALLBACK_FACTORY_BIND_FREE
-
-#define UTIL_GET_CALLBACK_FACTORY_BIND_MEMBER(memFuncPtr, instancePtr) \
-    (util::GetCallbackFactory(memFuncPtr).Bind<memFuncPtr>(instancePtr))
-#define BIND_MEM_CB UTIL_GET_CALLBACK_FACTORY_BIND_MEMBER
-
-namespace util {
-
-template<typename FuncSignature>
-class Callback;
-
-struct NullCallback {};
-
-// 0 parameter version
-
-template<typename R>
-class Callback<R ()>
-{
-public:
-    static const int Arity = 0;
-    typedef R ReturnType;
-
-    Callback()                    : func(0), obj(0) {}
-    Callback(NullCallback)        : func(0), obj(0) {}
-    Callback(const Callback& rhs) : func(rhs.func), obj(rhs.obj) {}
-    ~Callback() {} 
-
-    Callback& operator=(NullCallback)
-        { obj = 0; func = 0; return *this; }
-    Callback& operator=(const Callback& rhs)
-        { obj = rhs.obj; func = rhs.func; return *this; }
-
-    inline R operator()() const
-    {
-        return (*func)(obj);
-    }
-
-private:
-    typedef const void* Callback::*SafeBoolType;
-public:
-    inline operator SafeBoolType() const
-        { return func != 0 ? &Callback::obj : 0; }
-    inline bool operator!() const
-        { return func == 0; }
-
-private:
-    typedef R (*FuncType)(const void*);
-    Callback(FuncType f, const void* o) : func(f), obj(o) {}
-
-private:
-    FuncType func;
-    const void* obj;
-
-    template<typename FR>
-    friend class FreeCallbackFactory0;
-    template<typename FR, class FT>
-    friend class MemberCallbackFactory0;
-    template<typename FR, class FT>
-    friend class ConstMemberCallbackFactory0;
-};
-
-template<typename R>
-void operator==(const Callback<R ()>&,
-                const Callback<R ()>&);
-template<typename R>
-void operator!=(const Callback<R ()>&,
-                const Callback<R ()>&);
-
-template<typename R>
-class FreeCallbackFactory0
-{
-private:
-    template<R (*Func)()>
-    static R Wrapper(const void*)
-    {
-        return (*Func)();
-    }
-
-public:
-    template<R (*Func)()>
-    inline static Callback<R ()> Bind()
-    {
-        return Callback<R ()>
-            (&FreeCallbackFactory0::Wrapper<Func>, 0);
-    }
-};
-
-template<typename R>
-inline FreeCallbackFactory0<R>
-GetCallbackFactory(R (*)())
-{
-    return FreeCallbackFactory0<R>();
-}
-
-template<typename R, class T>
-class MemberCallbackFactory0
-{
-private:
-    template<R (T::*Func)()>
-    static R Wrapper(const void* o)
-    {
-        T* obj = const_cast<T*>(static_cast<const T*>(o));
-        return (obj->*Func)();
-    }
-
-public:
-    template<R (T::*Func)()>
-    inline static Callback<R ()> Bind(T* o)
-    {
-        return Callback<R ()>
-            (&MemberCallbackFactory0::Wrapper<Func>,
-            static_cast<const void*>(o));
-    }
-};
-
-template<typename R, class T>
-inline MemberCallbackFactory0<R, T>
-GetCallbackFactory(R (T::*)())
-{
-    return MemberCallbackFactory0<R, T>();
-}
-
-template<typename R, class T>
-class ConstMemberCallbackFactory0
-{
-private:
-    template<R (T::*Func)() const>
-    static R Wrapper(const void* o)
-    {
-        const T* obj = static_cast<const T*>(o);
-        return (obj->*Func)();
-    }
-
-public:
-    template<R (T::*Func)() const>
-    inline static Callback<R ()> Bind(const T* o)
-    {
-        return Callback<R ()>
-            (&ConstMemberCallbackFactory0::Wrapper<Func>,
-            static_cast<const void*>(o));
-    }
-};
-
-template<typename R, class T>
-inline ConstMemberCallbackFactory0<R, T>
-GetCallbackFactory(R (T::*)() const)
-{
-    return ConstMemberCallbackFactory0<R, T>();
-}
-
-// 1 parameter version
-
-template<typename R, typename P1>
-class Callback<R (P1)>
-{
-public:
-    static const int Arity = 1;
-    typedef R ReturnType;
-    typedef P1 Param1Type;
-
-    Callback()                    : func(0), obj(0) {}
-    Callback(NullCallback)        : func(0), obj(0) {}
-    Callback(const Callback& rhs) : func(rhs.func), obj(rhs.obj) {}
-    ~Callback() {} 
-
-    Callback& operator=(NullCallback)
-        { obj = 0; func = 0; return *this; }
-    Callback& operator=(const Callback& rhs)
-        { obj = rhs.obj; func = rhs.func; return *this; }
-
-    inline R operator()(P1 a1) const
-    {
-        return (*func)(obj, a1);
-    }
-
-private:
-    typedef const void* Callback::*SafeBoolType;
-public:
-    inline operator SafeBoolType() const
-        { return func != 0 ? &Callback::obj : 0; }
-    inline bool operator!() const
-        { return func == 0; }
-
-private:
-    typedef R (*FuncType)(const void*, P1);
-    Callback(FuncType f, const void* o) : func(f), obj(o) {}
-
-private:
-    FuncType func;
-    const void* obj;
-
-    template<typename FR, typename FP1>
-    friend class FreeCallbackFactory1;
-    template<typename FR, class FT, typename FP1>
-    friend class MemberCallbackFactory1;
-    template<typename FR, class FT, typename FP1>
-    friend class ConstMemberCallbackFactory1;
-};
-
-template<typename R, typename P1>
-void operator==(const Callback<R (P1)>&,
-                const Callback<R (P1)>&);
-template<typename R, typename P1>
-void operator!=(const Callback<R (P1)>&,
-                const Callback<R (P1)>&);
-
-template<typename R, typename P1>
-class FreeCallbackFactory1
-{
-private:
-    template<R (*Func)(P1)>
-    static R Wrapper(const void*, P1 a1)
-    {
-        return (*Func)(a1);
-    }
-
-public:
-    template<R (*Func)(P1)>
-    inline static Callback<R (P1)> Bind()
-    {
-        return Callback<R (P1)>
-            (&FreeCallbackFactory1::Wrapper<Func>, 0);
-    }
-};
-
-template<typename R, typename P1>
-inline FreeCallbackFactory1<R, P1>
-GetCallbackFactory(R (*)(P1))
-{
-    return FreeCallbackFactory1<R, P1>();
-}
-
-template<typename R, class T, typename P1>
-class MemberCallbackFactory1
-{
-private:
-    template<R (T::*Func)(P1)>
-    static R Wrapper(const void* o, P1 a1)
-    {
-        T* obj = const_cast<T*>(static_cast<const T*>(o));
-        return (obj->*Func)(a1);
-    }
-
-public:
-    template<R (T::*Func)(P1)>
-    inline static Callback<R (P1)> Bind(T* o)
-    {
-        return Callback<R (P1)>
-            (&MemberCallbackFactory1::Wrapper<Func>,
-            static_cast<const void*>(o));
-    }
-};
-
-template<typename R, class T, typename P1>
-inline MemberCallbackFactory1<R, T, P1>
-GetCallbackFactory(R (T::*)(P1))
-{
-    return MemberCallbackFactory1<R, T, P1>();
-}
-
-template<typename R, class T, typename P1>
-class ConstMemberCallbackFactory1
-{
-private:
-    template<R (T::*Func)(P1) const>
-    static R Wrapper(const void* o, P1 a1)
-    {
-        const T* obj = static_cast<const T*>(o);
-        return (obj->*Func)(a1);
-    }
-
-public:
-    template<R (T::*Func)(P1) const>
-    inline static Callback<R (P1)> Bind(const T* o)
-    {
-        return Callback<R (P1)>
-            (&ConstMemberCallbackFactory1::Wrapper<Func>,
-            static_cast<const void*>(o));
-    }
-};
-
-template<typename R, class T, typename P1>
-inline ConstMemberCallbackFactory1<R, T, P1>
-GetCallbackFactory(R (T::*)(P1) const)
-{
-    return ConstMemberCallbackFactory1<R, T, P1>();
-}
-
-// 2 parameter version
-
-template<typename R, typename P1, typename P2>
-class Callback<R (P1, P2)>
-{
-public:
-    static const int Arity = 2;
-    typedef R ReturnType;
-    typedef P1 Param1Type;
-    typedef P2 Param2Type;
-
-    Callback()                    : func(0), obj(0) {}
-    Callback(NullCallback)        : func(0), obj(0) {}
-    Callback(const Callback& rhs) : func(rhs.func), obj(rhs.obj) {}
-    ~Callback() {} 
-
-    Callback& operator=(NullCallback)
-        { obj = 0; func = 0; return *this; }
-    Callback& operator=(const Callback& rhs)
-        { obj = rhs.obj; func = rhs.func; return *this; }
-
-    inline R operator()(P1 a1, P2 a2) const
-    {
-        return (*func)(obj, a1, a2);
-    }
-
-private:
-    typedef const void* Callback::*SafeBoolType;
-public:
-    inline operator SafeBoolType() const
-        { return func != 0 ? &Callback::obj : 0; }
-    inline bool operator!() const
-        { return func == 0; }
-
-private:
-    typedef R (*FuncType)(const void*, P1, P2);
-    Callback(FuncType f, const void* o) : func(f), obj(o) {}
-
-private:
-    FuncType func;
-    const void* obj;
-
-    template<typename FR, typename FP1, typename FP2>
-    friend class FreeCallbackFactory2;
-    template<typename FR, class FT, typename FP1, typename FP2>
-    friend class MemberCallbackFactory2;
-    template<typename FR, class FT, typename FP1, typename FP2>
-    friend class ConstMemberCallbackFactory2;
-};
-
-template<typename R, typename P1, typename P2>
-void operator==(const Callback<R (P1, P2)>&,
-                const Callback<R (P1, P2)>&);
-template<typename R, typename P1, typename P2>
-void operator!=(const Callback<R (P1, P2)>&,
-                const Callback<R (P1, P2)>&);
-
-template<typename R, typename P1, typename P2>
-class FreeCallbackFactory2
-{
-private:
-    template<R (*Func)(P1, P2)>
-    static R Wrapper(const void*, P1 a1, P2 a2)
-    {
-        return (*Func)(a1, a2);
-    }
-
-public:
-    template<R (*Func)(P1, P2)>
-    inline static Callback<R (P1, P2)> Bind()
-    {
-        return Callback<R (P1, P2)>
-            (&FreeCallbackFactory2::Wrapper<Func>, 0);
-    }
-};
-
-template<typename R, typename P1, typename P2>
-inline FreeCallbackFactory2<R, P1, P2>
-GetCallbackFactory(R (*)(P1, P2))
-{
-    return FreeCallbackFactory2<R, P1, P2>();
-}
-
-template<typename R, class T, typename P1, typename P2>
-class MemberCallbackFactory2
-{
-private:
-    template<R (T::*Func)(P1, P2)>
-    static R Wrapper(const void* o, P1 a1, P2 a2)
-    {
-        T* obj = const_cast<T*>(static_cast<const T*>(o));
-        return (obj->*Func)(a1, a2);
-    }
-
-public:
-    template<R (T::*Func)(P1, P2)>
-    inline static Callback<R (P1, P2)> Bind(T* o)
-    {
-        return Callback<R (P1, P2)>
-            (&MemberCallbackFactory2::Wrapper<Func>,
-            static_cast<const void*>(o));
-    }
-};
-
-template<typename R, class T, typename P1, typename P2>
-inline MemberCallbackFactory2<R, T, P1, P2>
-GetCallbackFactory(R (T::*)(P1, P2))
-{
-    return MemberCallbackFactory2<R, T, P1, P2>();
-}
-
-template<typename R, class T, typename P1, typename P2>
-class ConstMemberCallbackFactory2
-{
-private:
-    template<R (T::*Func)(P1, P2) const>
-    static R Wrapper(const void* o, P1 a1, P2 a2)
-    {
-        const T* obj = static_cast<const T*>(o);
-        return (obj->*Func)(a1, a2);
-    }
-
-public:
-    template<R (T::*Func)(P1, P2) const>
-    inline static Callback<R (P1, P2)> Bind(const T* o)
-    {
-        return Callback<R (P1, P2)>
-            (&ConstMemberCallbackFactory2::Wrapper<Func>,
-            static_cast<const void*>(o));
-    }
-};
-
-template<typename R, class T, typename P1, typename P2>
-inline ConstMemberCallbackFactory2<R, T, P1, P2>
-GetCallbackFactory(R (T::*)(P1, P2) const)
-{
-    return ConstMemberCallbackFactory2<R, T, P1, P2>();
-}
-
-// 3 parameter version
-
-template<typename R, typename P1, typename P2, typename P3>
-class Callback<R (P1, P2, P3)>
-{
-public:
-    static const int Arity = 3;
-    typedef R ReturnType;
-    typedef P1 Param1Type;
-    typedef P2 Param2Type;
-    typedef P3 Param3Type;
-
-    Callback()                    : func(0), obj(0) {}
-    Callback(NullCallback)        : func(0), obj(0) {}
-    Callback(const Callback& rhs) : func(rhs.func), obj(rhs.obj) {}
-    ~Callback() {} 
-
-    Callback& operator=(NullCallback)
-        { obj = 0; func = 0; return *this; }
-    Callback& operator=(const Callback& rhs)
-        { obj = rhs.obj; func = rhs.func; return *this; }
-
-    inline R operator()(P1 a1, P2 a2, P3 a3) const
-    {
-        return (*func)(obj, a1, a2, a3);
-    }
-
-private:
-    typedef const void* Callback::*SafeBoolType;
-public:
-    inline operator SafeBoolType() const
-        { return func != 0 ? &Callback::obj : 0; }
-    inline bool operator!() const
-        { return func == 0; }
-
-private:
-    typedef R (*FuncType)(const void*, P1, P2, P3);
-    Callback(FuncType f, const void* o) : func(f), obj(o) {}
-
-private:
-    FuncType func;
-    const void* obj;
-
-    template<typename FR, typename FP1, typename FP2, typename FP3>
-    friend class FreeCallbackFactory3;
-    template<typename FR, class FT, typename FP1, typename FP2, typename FP3>
-    friend class MemberCallbackFactory3;
-    template<typename FR, class FT, typename FP1, typename FP2, typename FP3>
-    friend class ConstMemberCallbackFactory3;
-};
-
-template<typename R, typename P1, typename P2, typename P3>
-void operator==(const Callback<R (P1, P2, P3)>&,
-                const Callback<R (P1, P2, P3)>&);
-template<typename R, typename P1, typename P2, typename P3>
-void operator!=(const Callback<R (P1, P2, P3)>&,
-                const Callback<R (P1, P2, P3)>&);
-
-template<typename R, typename P1, typename P2, typename P3>
-class FreeCallbackFactory3
-{
-private:
-    template<R (*Func)(P1, P2, P3)>
-    static R Wrapper(const void*, P1 a1, P2 a2, P3 a3)
-    {
-        return (*Func)(a1, a2, a3);
-    }
-
-public:
-    template<R (*Func)(P1, P2, P3)>
-    inline static Callback<R (P1, P2, P3)> Bind()
-    {
-        return Callback<R (P1, P2, P3)>
-            (&FreeCallbackFactory3::Wrapper<Func>, 0);
-    }
-};
-
-template<typename R, typename P1, typename P2, typename P3>
-inline FreeCallbackFactory3<R, P1, P2, P3>
-GetCallbackFactory(R (*)(P1, P2, P3))
-{
-    return FreeCallbackFactory3<R, P1, P2, P3>();
-}
-
-template<typename R, class T, typename P1, typename P2, typename P3>
-class MemberCallbackFactory3
-{
-private:
-    template<R (T::*Func)(P1, P2, P3)>
-    static R Wrapper(const void* o, P1 a1, P2 a2, P3 a3)
-    {
-        T* obj = const_cast<T*>(static_cast<const T*>(o));
-        return (obj->*Func)(a1, a2, a3);
-    }
-
-public:
-    template<R (T::*Func)(P1, P2, P3)>
-    inline static Callback<R (P1, P2, P3)> Bind(T* o)
-    {
-        return Callback<R (P1, P2, P3)>
-            (&MemberCallbackFactory3::Wrapper<Func>,
-            static_cast<const void*>(o));
-    }
-};
-
-template<typename R, class T, typename P1, typename P2, typename P3>
-inline MemberCallbackFactory3<R, T, P1, P2, P3>
-GetCallbackFactory(R (T::*)(P1, P2, P3))
-{
-    return MemberCallbackFactory3<R, T, P1, P2, P3>();
-}
-
-template<typename R, class T, typename P1, typename P2, typename P3>
-class ConstMemberCallbackFactory3
-{
-private:
-    template<R (T::*Func)(P1, P2, P3) const>
-    static R Wrapper(const void* o, P1 a1, P2 a2, P3 a3)
-    {
-        const T* obj = static_cast<const T*>(o);
-        return (obj->*Func)(a1, a2, a3);
-    }
-
-public:
-    template<R (T::*Func)(P1, P2, P3) const>
-    inline static Callback<R (P1, P2, P3)> Bind(const T* o)
-    {
-        return Callback<R (P1, P2, P3)>
-            (&ConstMemberCallbackFactory3::Wrapper<Func>,
-            static_cast<const void*>(o));
-    }
-};
-
-template<typename R, class T, typename P1, typename P2, typename P3>
-inline ConstMemberCallbackFactory3<R, T, P1, P2, P3>
-GetCallbackFactory(R (T::*)(P1, P2, P3) const)
-{
-    return ConstMemberCallbackFactory3<R, T, P1, P2, P3>();
-}
-
-// 4 parameter version
-
-template<typename R, typename P1, typename P2, typename P3,
-                     typename P4>
-class Callback<R (P1, P2, P3, P4)>
-{
-public:
-    static const int Arity = 4;
-    typedef R ReturnType;
-    typedef P1 Param1Type;
-    typedef P2 Param2Type;
-    typedef P3 Param3Type;
-    typedef P4 Param4Type;
-
-    Callback()                    : func(0), obj(0) {}
-    Callback(NullCallback)        : func(0), obj(0) {}
-    Callback(const Callback& rhs) : func(rhs.func), obj(rhs.obj) {}
-    ~Callback() {} 
-
-    Callback& operator=(NullCallback)
-        { obj = 0; func = 0; return *this; }
-    Callback& operator=(const Callback& rhs)
-        { obj = rhs.obj; func = rhs.func; return *this; }
-
-    inline R operator()(P1 a1, P2 a2, P3 a3, P4 a4) const
-    {
-        return (*func)(obj, a1, a2, a3, a4);
-    }
-
-private:
-    typedef const void* Callback::*SafeBoolType;
-public:
-    inline operator SafeBoolType() const
-        { return func != 0 ? &Callback::obj : 0; }
-    inline bool operator!() const
-        { return func == 0; }
-
-private:
-    typedef R (*FuncType)(const void*, P1, P2, P3, P4);
-    Callback(FuncType f, const void* o) : func(f), obj(o) {}
-
-private:
-    FuncType func;
-    const void* obj;
-
-    template<typename FR, typename FP1, typename FP2, typename FP3,
-                          typename FP4>
-    friend class FreeCallbackFactory4;
-    template<typename FR, class FT, typename FP1, typename FP2, typename FP3,
-                                    typename FP4>
-    friend class MemberCallbackFactory4;
-    template<typename FR, class FT, typename FP1, typename FP2, typename FP3,
-                                    typename FP4>
-    friend class ConstMemberCallbackFactory4;
-};
-
-template<typename R, typename P1, typename P2, typename P3,
-                     typename P4>
-void operator==(const Callback<R (P1, P2, P3, P4)>&,
-                const Callback<R (P1, P2, P3, P4)>&);
-template<typename R, typename P1, typename P2, typename P3,
-                     typename P4>
-void operator!=(const Callback<R (P1, P2, P3, P4)>&,
-                const Callback<R (P1, P2, P3, P4)>&);
-
-template<typename R, typename P1, typename P2, typename P3,
-                     typename P4>
-class FreeCallbackFactory4
-{
-private:
-    template<R (*Func)(P1, P2, P3, P4)>
-    static R Wrapper(const void*, P1 a1, P2 a2, P3 a3, P4 a4)
-    {
-        return (*Func)(a1, a2, a3, a4);
-    }
-
-public:
-    template<R (*Func)(P1, P2, P3, P4)>
-    inline static Callback<R (P1, P2, P3, P4)> Bind()
-    {
-        return Callback<R (P1, P2, P3, P4)>
-            (&FreeCallbackFactory4::Wrapper<Func>, 0);
-    }
-};
-
-template<typename R, typename P1, typename P2, typename P3,
-                     typename P4>
-inline FreeCallbackFactory4<R, P1, P2, P3, P4>
-GetCallbackFactory(R (*)(P1, P2, P3, P4))
-{
-    return FreeCallbackFactory4<R, P1, P2, P3, P4>();
-}
-
-template<typename R, class T, typename P1, typename P2, typename P3,
-                              typename P4>
-class MemberCallbackFactory4
-{
-private:
-    template<R (T::*Func)(P1, P2, P3, P4)>
-    static R Wrapper(const void* o, P1 a1, P2 a2, P3 a3, P4 a4)
-    {
-        T* obj = const_cast<T*>(static_cast<const T*>(o));
-        return (obj->*Func)(a1, a2, a3, a4);
-    }
-
-public:
-    template<R (T::*Func)(P1, P2, P3, P4)>
-    inline static Callback<R (P1, P2, P3, P4)> Bind(T* o)
-    {
-        return Callback<R (P1, P2, P3, P4)>
-            (&MemberCallbackFactory4::Wrapper<Func>,
-            static_cast<const void*>(o));
-    }
-};
-
-template<typename R, class T, typename P1, typename P2, typename P3,
-                              typename P4>
-inline MemberCallbackFactory4<R, T, P1, P2, P3, P4>
-GetCallbackFactory(R (T::*)(P1, P2, P3, P4))
-{
-    return MemberCallbackFactory4<R, T, P1, P2, P3, P4>();
-}
-
-template<typename R, class T, typename P1, typename P2, typename P3,
-                              typename P4>
-class ConstMemberCallbackFactory4
-{
-private:
-    template<R (T::*Func)(P1, P2, P3, P4) const>
-    static R Wrapper(const void* o, P1 a1, P2 a2, P3 a3, P4 a4)
-    {
-        const T* obj = static_cast<const T*>(o);
-        return (obj->*Func)(a1, a2, a3, a4);
-    }
-
-public:
-    template<R (T::*Func)(P1, P2, P3, P4) const>
-    inline static Callback<R (P1, P2, P3, P4)> Bind(const T* o)
-    {
-        return Callback<R (P1, P2, P3, P4)>
-            (&ConstMemberCallbackFactory4::Wrapper<Func>,
-            static_cast<const void*>(o));
-    }
-};
-
-template<typename R, class T, typename P1, typename P2, typename P3,
-                              typename P4>
-inline ConstMemberCallbackFactory4<R, T, P1, P2, P3, P4>
-GetCallbackFactory(R (T::*)(P1, P2, P3, P4) const)
-{
-    return ConstMemberCallbackFactory4<R, T, P1, P2, P3, P4>();
-}
-
-// 5 parameter version
-
-template<typename R, typename P1, typename P2, typename P3,
-                     typename P4, typename P5>
-class Callback<R (P1, P2, P3, P4, P5)>
-{
-public:
-    static const int Arity = 5;
-    typedef R ReturnType;
-    typedef P1 Param1Type;
-    typedef P2 Param2Type;
-    typedef P3 Param3Type;
-    typedef P4 Param4Type;
-    typedef P5 Param5Type;
-
-    Callback()                    : func(0), obj(0) {}
-    Callback(NullCallback)        : func(0), obj(0) {}
-    Callback(const Callback& rhs) : func(rhs.func), obj(rhs.obj) {}
-    ~Callback() {} 
-
-    Callback& operator=(NullCallback)
-        { obj = 0; func = 0; return *this; }
-    Callback& operator=(const Callback& rhs)
-        { obj = rhs.obj; func = rhs.func; return *this; }
-
-    inline R operator()(P1 a1, P2 a2, P3 a3, P4 a4, P5 a5) const
-    {
-        return (*func)(obj, a1, a2, a3, a4, a5);
-    }
-
-private:
-    typedef const void* Callback::*SafeBoolType;
-public:
-    inline operator SafeBoolType() const
-        { return func != 0 ? &Callback::obj : 0; }
-    inline bool operator!() const
-        { return func == 0; }
-
-private:
-    typedef R (*FuncType)(const void*, P1, P2, P3, P4, P5);
-    Callback(FuncType f, const void* o) : func(f), obj(o) {}
-
-private:
-    FuncType func;
-    const void* obj;
-
-    template<typename FR, typename FP1, typename FP2, typename FP3,
-                          typename FP4, typename FP5>
-    friend class FreeCallbackFactory5;
-    template<typename FR, class FT, typename FP1, typename FP2, typename FP3,
-                                    typename FP4, typename FP5>
-    friend class MemberCallbackFactory5;
-    template<typename FR, class FT, typename FP1, typename FP2, typename FP3,
-                                    typename FP4, typename FP5>
-    friend class ConstMemberCallbackFactory5;
-};
-
-template<typename R, typename P1, typename P2, typename P3,
-                     typename P4, typename P5>
-void operator==(const Callback<R (P1, P2, P3, P4, P5)>&,
-                const Callback<R (P1, P2, P3, P4, P5)>&);
-template<typename R, typename P1, typename P2, typename P3,
-                     typename P4, typename P5>
-void operator!=(const Callback<R (P1, P2, P3, P4, P5)>&,
-                const Callback<R (P1, P2, P3, P4, P5)>&);
-
-template<typename R, typename P1, typename P2, typename P3,
-                     typename P4, typename P5>
-class FreeCallbackFactory5
-{
-private:
-    template<R (*Func)(P1, P2, P3, P4, P5)>
-    static R Wrapper(const void*, P1 a1, P2 a2, P3 a3, P4 a4, P5 a5)
-    {
-        return (*Func)(a1, a2, a3, a4, a5);
-    }
-
-public:
-    template<R (*Func)(P1, P2, P3, P4, P5)>
-    inline static Callback<R (P1, P2, P3, P4, P5)> Bind()
-    {
-        return Callback<R (P1, P2, P3, P4, P5)>
-            (&FreeCallbackFactory5::Wrapper<Func>, 0);
-    }
-};
-
-template<typename R, typename P1, typename P2, typename P3,
-                     typename P4, typename P5>
-inline FreeCallbackFactory5<R, P1, P2, P3, P4, P5>
-GetCallbackFactory(R (*)(P1, P2, P3, P4, P5))
-{
-    return FreeCallbackFactory5<R, P1, P2, P3, P4, P5>();
-}
-
-template<typename R, class T, typename P1, typename P2, typename P3,
-                              typename P4, typename P5>
-class MemberCallbackFactory5
-{
-private:
-    template<R (T::*Func)(P1, P2, P3, P4, P5)>
-    static R Wrapper(const void* o, P1 a1, P2 a2, P3 a3, P4 a4, P5 a5)
-    {
-        T* obj = const_cast<T*>(static_cast<const T*>(o));
-        return (obj->*Func)(a1, a2, a3, a4, a5);
-    }
-
-public:
-    template<R (T::*Func)(P1, P2, P3, P4, P5)>
-    inline static Callback<R (P1, P2, P3, P4, P5)> Bind(T* o)
-    {
-        return Callback<R (P1, P2, P3, P4, P5)>
-            (&MemberCallbackFactory5::Wrapper<Func>,
-            static_cast<const void*>(o));
-    }
-};
-
-template<typename R, class T, typename P1, typename P2, typename P3,
-                              typename P4, typename P5>
-inline MemberCallbackFactory5<R, T, P1, P2, P3, P4, P5>
-GetCallbackFactory(R (T::*)(P1, P2, P3, P4, P5))
-{
-    return MemberCallbackFactory5<R, T, P1, P2, P3, P4, P5>();
-}
-
-template<typename R, class T, typename P1, typename P2, typename P3,
-                              typename P4, typename P5>
-class ConstMemberCallbackFactory5
-{
-private:
-    template<R (T::*Func)(P1, P2, P3, P4, P5) const>
-    static R Wrapper(const void* o, P1 a1, P2 a2, P3 a3, P4 a4, P5 a5)
-    {
-        const T* obj = static_cast<const T*>(o);
-        return (obj->*Func)(a1, a2, a3, a4, a5);
-    }
-
-public:
-    template<R (T::*Func)(P1, P2, P3, P4, P5) const>
-    inline static Callback<R (P1, P2, P3, P4, P5)> Bind(const T* o)
-    {
-        return Callback<R (P1, P2, P3, P4, P5)>
-            (&ConstMemberCallbackFactory5::Wrapper<Func>,
-            static_cast<const void*>(o));
-    }
-};
-
-template<typename R, class T, typename P1, typename P2, typename P3,
-                              typename P4, typename P5>
-inline ConstMemberCallbackFactory5<R, T, P1, P2, P3, P4, P5>
-GetCallbackFactory(R (T::*)(P1, P2, P3, P4, P5) const)
-{
-    return ConstMemberCallbackFactory5<R, T, P1, P2, P3, P4, P5>();
-}
-
-// 6 parameter version
-
-template<typename R, typename P1, typename P2, typename P3,
-                     typename P4, typename P5, typename P6>
-class Callback<R (P1, P2, P3, P4, P5, P6)>
-{
-public:
-    static const int Arity = 6;
-    typedef R ReturnType;
-    typedef P1 Param1Type;
-    typedef P2 Param2Type;
-    typedef P3 Param3Type;
-    typedef P4 Param4Type;
-    typedef P5 Param5Type;
-    typedef P6 Param6Type;
-
-    Callback()                    : func(0), obj(0) {}
-    Callback(NullCallback)        : func(0), obj(0) {}
-    Callback(const Callback& rhs) : func(rhs.func), obj(rhs.obj) {}
-    ~Callback() {} 
-
-    Callback& operator=(NullCallback)
-        { obj = 0; func = 0; return *this; }
-    Callback& operator=(const Callback& rhs)
-        { obj = rhs.obj; func = rhs.func; return *this; }
-
-    inline R operator()(P1 a1, P2 a2, P3 a3, P4 a4, P5 a5, P6 a6) const
-    {
-        return (*func)(obj, a1, a2, a3, a4, a5, a6);
-    }
-
-private:
-    typedef const void* Callback::*SafeBoolType;
-public:
-    inline operator SafeBoolType() const
-        { return func != 0 ? &Callback::obj : 0; }
-    inline bool operator!() const
-        { return func == 0; }
-
-private:
-    typedef R (*FuncType)(const void*, P1, P2, P3, P4, P5, P6);
-    Callback(FuncType f, const void* o) : func(f), obj(o) {}
-
-private:
-    FuncType func;
-    const void* obj;
-
-    template<typename FR, typename FP1, typename FP2, typename FP3,
-                          typename FP4, typename FP5, typename FP6>
-    friend class FreeCallbackFactory6;
-    template<typename FR, class FT, typename FP1, typename FP2, typename FP3,
-                                    typename FP4, typename FP5, typename FP6>
-    friend class MemberCallbackFactory6;
-    template<typename FR, class FT, typename FP1, typename FP2, typename FP3,
-                                    typename FP4, typename FP5, typename FP6>
-    friend class ConstMemberCallbackFactory6;
-};
-
-template<typename R, typename P1, typename P2, typename P3,
-                     typename P4, typename P5, typename P6>
-void operator==(const Callback<R (P1, P2, P3, P4, P5, P6)>&,
-                const Callback<R (P1, P2, P3, P4, P5, P6)>&);
-template<typename R, typename P1, typename P2, typename P3,
-                     typename P4, typename P5, typename P6>
-void operator!=(const Callback<R (P1, P2, P3, P4, P5, P6)>&,
-                const Callback<R (P1, P2, P3, P4, P5, P6)>&);
-
-template<typename R, typename P1, typename P2, typename P3,
-                     typename P4, typename P5, typename P6>
-class FreeCallbackFactory6
-{
-private:
-    template<R (*Func)(P1, P2, P3, P4, P5, P6)>
-    static R Wrapper(const void*, P1 a1, P2 a2, P3 a3, P4 a4, P5 a5, P6 a6)
-    {
-        return (*Func)(a1, a2, a3, a4, a5, a6);
-    }
-
-public:
-    template<R (*Func)(P1, P2, P3, P4, P5, P6)>
-    inline static Callback<R (P1, P2, P3, P4, P5, P6)> Bind()
-    {
-        return Callback<R (P1, P2, P3, P4, P5, P6)>
-            (&FreeCallbackFactory6::Wrapper<Func>, 0);
-    }
-};
-
-template<typename R, typename P1, typename P2, typename P3,
-                     typename P4, typename P5, typename P6>
-inline FreeCallbackFactory6<R, P1, P2, P3, P4, P5, P6>
-GetCallbackFactory(R (*)(P1, P2, P3, P4, P5, P6))
-{
-    return FreeCallbackFactory6<R, P1, P2, P3, P4, P5, P6>();
-}
-
-template<typename R, class T, typename P1, typename P2, typename P3,
-                              typename P4, typename P5, typename P6>
-class MemberCallbackFactory6
-{
-private:
-    template<R (T::*Func)(P1, P2, P3, P4, P5, P6)>
-    static R Wrapper(const void* o, P1 a1, P2 a2, P3 a3, P4 a4, P5 a5, P6 a6)
-    {
-        T* obj = const_cast<T*>(static_cast<const T*>(o));
-        return (obj->*Func)(a1, a2, a3, a4, a5, a6);
-    }
-
-public:
-    template<R (T::*Func)(P1, P2, P3, P4, P5, P6)>
-    inline static Callback<R (P1, P2, P3, P4, P5, P6)> Bind(T* o)
-    {
-        return Callback<R (P1, P2, P3, P4, P5, P6)>
-            (&MemberCallbackFactory6::Wrapper<Func>,
-            static_cast<const void*>(o));
-    }
-};
-
-template<typename R, class T, typename P1, typename P2, typename P3,
-                              typename P4, typename P5, typename P6>
-inline MemberCallbackFactory6<R, T, P1, P2, P3, P4, P5, P6>
-GetCallbackFactory(R (T::*)(P1, P2, P3, P4, P5, P6))
-{
-    return MemberCallbackFactory6<R, T, P1, P2, P3, P4, P5, P6>();
-}
-
-template<typename R, class T, typename P1, typename P2, typename P3,
-                              typename P4, typename P5, typename P6>
-class ConstMemberCallbackFactory6
-{
-private:
-    template<R (T::*Func)(P1, P2, P3, P4, P5, P6) const>
-    static R Wrapper(const void* o, P1 a1, P2 a2, P3 a3, P4 a4, P5 a5, P6 a6)
-    {
-        const T* obj = static_cast<const T*>(o);
-        return (obj->*Func)(a1, a2, a3, a4, a5, a6);
-    }
-
-public:
-    template<R (T::*Func)(P1, P2, P3, P4, P5, P6) const>
-    inline static Callback<R (P1, P2, P3, P4, P5, P6)> Bind(const T* o)
-    {
-        return Callback<R (P1, P2, P3, P4, P5, P6)>
-            (&ConstMemberCallbackFactory6::Wrapper<Func>,
-            static_cast<const void*>(o));
-    }
-};
-
-template<typename R, class T, typename P1, typename P2, typename P3,
-                              typename P4, typename P5, typename P6>
-inline ConstMemberCallbackFactory6<R, T, P1, P2, P3, P4, P5, P6>
-GetCallbackFactory(R (T::*)(P1, P2, P3, P4, P5, P6) const)
-{
-    return ConstMemberCallbackFactory6<R, T, P1, P2, P3, P4, P5, P6>();
-}
-
-}
-
-#endif
-

--- a/main.cpp
+++ b/main.cpp
@@ -196,21 +196,21 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 	case WM_LBUTTONDOWN:
 	case WM_MBUTTONDOWN:
 	case WM_RBUTTONDOWN:
-		::SetCapture(hWnd);
+//		::SetCapture(hWnd);
 		OnMouseDown(hWnd, wParam, lParam);
 		break;
 	case WM_LBUTTONUP:
 	case WM_MBUTTONUP:
 	case WM_RBUTTONUP:
-		if (::GetCapture() == hWnd) {
-			::ReleaseCapture();
+//		if (::GetCapture() == hWnd) {
+//			::ReleaseCapture();
 			OnMouseUp(hWnd, wParam, lParam);
-		}
+//		}
 		break;
 	case WM_MOUSEMOVE:
-		if (::GetCapture() == hWnd) {
+//		if (::GetCapture() == hWnd) {
 			OnMouseMove(hWnd, wParam, lParam);
-		}
+//		}
 		break;
 	default:
 		return DefWindowProc(hWnd, message, wParam, lParam);

--- a/main_plus.cpp
+++ b/main_plus.cpp
@@ -52,7 +52,7 @@ HDC hMemDC;
 MG::Renderer24 renderer;
 
 MG::Container mg(4, 8);
-MG::Button button1(0);
+MG::Button button1(4);
 MG::Button button2(0);
 MG::Element pic1(0);
 MG::Element pic2(0);
@@ -94,6 +94,26 @@ bool ReadImage(const char* filename, MG::Bitmap& bmp, std::vector<uint8_t>& buff
 
 } // anonymous namespace
 
+void OnButton1MouseDown(void* param, const MG::Element::Event& e)
+{
+	OutputDebugString(L"MouseDown\n");
+}
+
+void OnButton1MouseUp(void* param, const MG::Element::Event& e)
+{
+	OutputDebugString(L"MouseUp\n");
+}
+
+void OnButton1MouseMove(void* param, const MG::Element::Event& e)
+{
+	OutputDebugString(L"MouseMove\n");
+}
+
+void OnButton1Click(void* param, const MG::Element::Event& e)
+{
+	OutputDebugString(L"Click\n");
+}
+
 void OnCreate(HWND hWnd, WPARAM wParam, LPARAM lParam)
 {
 	BITMAPINFO* pBMI = (BITMAPINFO*) &bmiBuff[0];
@@ -127,15 +147,15 @@ void OnCreate(HWND hWnd, WPARAM wParam, LPARAM lParam)
 	rect.y = 0;
 	rect.w = width;
 	rect.h = height;
-	mg.rect = rect;
+	mg.rect_ = rect;
 	MG::Color col;
 	col.r = 50;
 	col.g = 200;
 	col.b = 150;
 	
 	mainbg.color = col;
-	mg.pBG = &mainbg;
-	mg.needsToDraw = true;
+	mg.pBG_ = &mainbg;
+	mg.needsToDraw_ = true;
 	
 	col.g = 100;
 	buttonBG.color = col;
@@ -146,18 +166,18 @@ void OnCreate(HWND hWnd, WPARAM wParam, LPARAM lParam)
 	rect.y = 100;
 	rect.w = 100;
 	rect.h = 50;
-	button1.rect = rect;
-	button1.pBG = &buttonBG;
-	button1.pBGPressed = &buttonBGPressed;
+	button1.rect_ = rect;
+	button1.pBG_ = &buttonBG;
+	button1.pBGPressed_ = &buttonBGPressed;
 	mg.AddChild(button1);
 	
 	rect.x = 300;
 	rect.y = 100;
 	rect.w = 100;
 	rect.h = 50;
-	button2.rect = rect;
-	button2.pBG = &buttonBG;
-	button2.pBGPressed = &buttonBGPressed;
+	button2.rect_ = rect;
+	button2.pBG_ = &buttonBG;
+	button2.pBGPressed_ = &buttonBGPressed;
 	mg.AddChild(button2);
 	
 	if (!ReadImage("test24.bmp", bmp24Content, image24Buffer)) {
@@ -169,7 +189,7 @@ void OnCreate(HWND hWnd, WPARAM wParam, LPARAM lParam)
 	
 	rect.x = 100;
 	rect.y = 300;
-	pic1.rect = rect;
+	pic1.rect_ = rect;
 	MG::Rectangle irec;
 	irec.x = 510;
 	irec.y = 340;
@@ -177,23 +197,23 @@ void OnCreate(HWND hWnd, WPARAM wParam, LPARAM lParam)
 	irec.h = 400;
 	picbg1.image.rect = irec;
 	picbg1.image.pBitmap = &bmp24Content;
-	pic1.pBG = &picbg1;
-	pic1.needsToDraw = true;
+	pic1.pBG_ = &picbg1;
+	pic1.needsToDraw_ = true;
 	mg.AddChild(pic1);
 	
 	rect.x = 300;
 	rect.y = 200;
 	rect.w = 336;
 	rect.h = 300;
-	pic2.rect = rect;
+	pic2.rect_ = rect;
 	irec.x = 0;
 	irec.y = 0;
 	irec.w = 336;
 	irec.h = 24;
 	picbg2.image.rect = irec;
 	picbg2.image.pBitmap = &bmp32Content;
-	pic2.pBG = &picbg2;
-	pic2.needsToDraw = true;
+	pic2.pBG_ = &picbg2;
+	pic2.needsToDraw_ = true;
 	mg.AddChild(pic2);
 	
 	HDC hWndDC = ::GetDC(hWnd);
@@ -202,6 +222,12 @@ void OnCreate(HWND hWnd, WPARAM wParam, LPARAM lParam)
 	::ReleaseDC(hWnd, hWndDC);
 	::SelectObject(hMemDC, hBMP);
 
+	button1.AddEventListener(MG::Element::EventType_MouseDown, OnButton1MouseDown);
+	button1.AddEventListener(MG::Element::EventType_MouseUp, OnButton1MouseUp);
+//	button1.AddEventListener(MG::Element::EventType_MouseMove, OnButton1MouseMove);
+	button1.AddEventListener(MG::Button::EventType_Click, OnButton1Click);
+	
+
 	mg.Draw(0, 0, renderer);
 }
 

--- a/mg.vcproj
+++ b/mg.vcproj
@@ -113,8 +113,9 @@
 			/>
 			<Tool
 				Name="VCCLCompilerTool"
-				Optimization="2"
+				Optimization="1"
 				EnableIntrinsicFunctions="true"
+				FavorSizeOrSpeed="2"
 				AdditionalIncludeDirectories="./;./common/"
 				PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_CRT_SECURE_NO_WARNINGS"
 				RuntimeLibrary="2"
@@ -313,10 +314,6 @@
 				>
 			</File>
 			<File
-				RelativePath=".\common\callback.hpp"
-				>
-			</File>
-			<File
 				RelativePath=".\common\optional.h"
 				>
 			</File>

--- a/mg/button.cpp
+++ b/mg/button.cpp
@@ -7,19 +7,18 @@ namespace MG {
 Button::Button(size_t nMaxEvents)
 	:
 	Element(nMaxEvents),
-	pBGPressed(0)
+	pBGPressed_(0)
 {
-	needsToDraw = true;
-	bClickable_ = true;
+	needsToDraw_ = true;
 }
 
 void Button::Draw(int16_t offsetX, int16_t offsetY, IRenderer& renderer)
 {
 	if (isPressed_) {
-		IBackground* backup = pBG;
-		pBG = pBGPressed;
+		IBackground* backup = pBG_;
+		pBG_ = pBGPressed_;
 		__super::Draw(offsetX, offsetY, renderer);
-		pBG = backup;
+		pBG_ = backup;
 	}else {
 		__super::Draw(offsetX, offsetY, renderer);
 	}
@@ -27,26 +26,38 @@ void Button::Draw(int16_t offsetX, int16_t offsetY, IRenderer& renderer)
 
 bool Button::HitTest(int16_t x, int16_t y) const
 {
-	return true;
+	return __super::HitTest(x, y);
 }
 
 void Button::OnMouseDown(int16_t x, int16_t y)
 {
-	needsToDraw = true;
+	needsToDraw_ = true;
 	isPressed_ = true;
+	s_pCapture_ = this;
+	__super::OnMouseDown(x, y);
 }
 
 void Button::OnMouseUp(int16_t x, int16_t y)
 {
+	__super::OnMouseUp(x, y);
 	if (isPressed_) {
-		needsToDraw = true;
+		needsToDraw_ = true;
 		isPressed_ = false;
+		s_pCapture_ = 0;
+		if (HitTest(x, y)) {
+			OnClick(x, y);
+		}
 	}
 }
 
-void Button::OnMouseMove(int16_t x, int16_t y)
+void Button::OnClick(int16_t x, int16_t y)
 {
-	;
+	Event e;
+	e.target = this;
+	e.type = EventType_Click;
+	e.x = x;
+	e.y = y;
+	fireEventListener(e);
 }
 
 } // anonymous MG

--- a/mg/button.h
+++ b/mg/button.h
@@ -16,12 +16,12 @@ public:
 	bool HitTest(int16_t x, int16_t y) const;
 	void OnMouseDown(int16_t x, int16_t y);
 	void OnMouseUp(int16_t x, int16_t y);
-	void OnMouseMove(int16_t x, int16_t y);
+	void OnClick(int16_t x, int16_t y);
 	
-	IBackground* pBGPressed;
+	IBackground* pBGPressed_;
 	
 	enum EventType {
-		EventType_Clicked = __super::EventType_End,
+		EventType_Click = __super::EventType_End,
 		
 		EventType_End,
 	};

--- a/mg/container.cpp
+++ b/mg/container.cpp
@@ -13,11 +13,10 @@ namespace MG {
 
 Container::Container(size_t nMaxEvents, size_t nMaxChildren)
 	:
-	Element(nMaxEvents),
-	clickedElementIndex_(0)
+	Element(nMaxEvents)
 {
-	vElements_.buff_ = &s_elementPtrs[s_nElementEntries];
-	vElements_.maxLength_ = nMaxChildren;
+	elements_.buff_ = &s_elementPtrs[s_nElementEntries];
+	elements_.maxLength_ = nMaxChildren;
 	s_nElementEntries += nMaxChildren;
 	assert(s_nElementEntries < countof(s_elementPtrs));
 }
@@ -28,15 +27,15 @@ Container::~Container()
 
 void Container::AddChild(Element& e)
 {
-	vElements_.push_back(&e);
+	elements_.push_back(&e);
 	e.SetParent(this);
 }
 
 void Container::RemoveChild(Element& e)
 {
-	for (size_t i=0; i<vElements_.length_; ++i) {
-		if (vElements_[i] == &e) {
-			vElements_[i] = 0;
+	for (size_t i=0; i<elements_.length_; ++i) {
+		if (elements_[i] == &e) {
+			elements_[i] = 0;
 			e.SetParent(0);
 			break;
 		}
@@ -45,18 +44,18 @@ void Container::RemoveChild(Element& e)
 
 void Container::Draw(int16_t offsetX, int16_t offsetY, IRenderer& renderer)
 {
-	if (needsToDraw) {
+	if (needsToDraw_) {
 		__super::Draw(offsetX, offsetY, renderer);
-		needsToDraw = false;
+		needsToDraw_ = false;
 	}
 	
-	int16_t x = rect.x + offsetX;
-	int16_t y = rect.y + offsetY;
-	for (size_t i=0; i<vElements_.length_; ++i) {
-		Element* e = vElements_[i];
-		if (e && e->needsToDraw) {
+	int16_t x = rect_.x + offsetX;
+	int16_t y = rect_.y + offsetY;
+	for (size_t i=0; i<elements_.length_; ++i) {
+		Element* e = elements_[i];
+		if (e && e->needsToDraw_) {
 			e->Draw(x, y, renderer);
-			e->needsToDraw = false;
+			e->needsToDraw_ = false;
 		}
 	}
 }
@@ -66,46 +65,66 @@ bool Container::HitTest(int16_t x, int16_t y) const
 	return true;
 }
 
-void Container::OnMouseDown(int16_t x, int16_t y)
+static
+Element* hitTestElements(varray<Element*>& elements, int16_t x, int16_t y)
 {
-	int16_t ox = x - rect.x;
-	int16_t oy = y - rect.y;
-	for (size_t i=0; i<vElements_.length_; ++i) {
-		Element* e = vElements_[i];
+	const size_t len = elements.length_;
+	for (size_t i=0; i<len; ++i) {
+		Element* e = elements[i];
 		if (e) {
-			if (1
-				&& e->IsClickable()
-				&& e->rect.Contains(ox, oy)
-				&& e->HitTest(ox, oy)
-			) {
-				clickedElementIndex_ = i;
-				e->OnMouseDown(ox, oy);
-				return;
+			if (e->HitTest(x, y)) {
+				return e;
 			}
 		}
 	}
+	return 0;
+}
+
+void Container::OnMouseDown(int16_t x, int16_t y)
+{
+	int16_t ox = x - rect_.x;
+	int16_t oy = y - rect_.y;
+
+	if (s_pCapture_) {
+		s_pCapture_->OnMouseDown(ox, oy);
+	}else {
+		Element* e = hitTestElements(elements_, x, y);
+		if (e) {
+			e->OnMouseDown(ox, oy);
+			return;
+		}
+	}
 }
 
 void Container::OnMouseUp(int16_t x, int16_t y)
 {
-	int16_t ox = x - rect.x;
-	int16_t oy = y - rect.y;
-	Element* e = vElements_[clickedElementIndex_];
-	if (e) {
-		e->OnMouseUp(ox, oy);
+	int16_t ox = x - rect_.x;
+	int16_t oy = y - rect_.y;
+	if (s_pCapture_) {
+		s_pCapture_->OnMouseUp(ox, oy);
+	}else {
+		Element* e = hitTestElements(elements_, x, y);
+		if (e) {
+			e->OnMouseUp(ox, oy);
+			return;
+		}
 	}
 }
 
 void Container::OnMouseMove(int16_t x, int16_t y)
 {
-	int16_t ox = x - rect.x;
-	int16_t oy = y - rect.y;
-	Element* e = vElements_[clickedElementIndex_];
-	if (e) {
-		e->OnMouseMove(ox, oy);
+	int16_t ox = x - rect_.x;
+	int16_t oy = y - rect_.y;
+	if (s_pCapture_) {
+		s_pCapture_->OnMouseMove(ox, oy);
+	}else {
+		Element* e = hitTestElements(elements_, x, y);
+		if (e) {
+			e->OnMouseMove(ox, oy);
+			return;
+		}
 	}
 }
 
-
 } // namespace MG
 

--- a/mg/container.h
+++ b/mg/container.h
@@ -23,8 +23,7 @@ public:
 	virtual void OnMouseMove(int16_t x, int16_t y);
 	
 protected:
-	size_t clickedElementIndex_;
-	varray<Element*> vElements_;
+	varray<Element*> elements_;
 	
 };
 

--- a/mg/element.cpp
+++ b/mg/element.cpp
@@ -12,6 +12,9 @@ MG::Element::EventListenerEntry s_eventEntries[128];
 
 namespace MG {
 
+// static
+Element* Element::s_pCapture_ = 0;
+
 Element::Element(size_t nMaxEvents)
 {
 	eventEntries_.buff_ = &s_eventEntries[s_nEventEntries];
@@ -20,23 +23,90 @@ Element::Element(size_t nMaxEvents)
 	assert(s_nEventEntries < countof(s_eventEntries));
 	
 	pParent_ = 0;
-	needsToDraw = false;
-	pBG = 0;
-	bClickable_ = false;
+	needsToDraw_ = false;
+	pBG_ = 0;
+	pEventListenerParam_ = 0;
 }
 
 // virtual
 void Element::Draw(int16_t offsetX, int16_t offsetY, IRenderer& renderer)
 {
-	Rectangle r = rect;
+	Rectangle r = rect_;
 	r.x += offsetX;
 	r.y += offsetY;
 	
-	if (pBG) {
-		pBG->Draw(r, renderer);
+	if (pBG_) {
+		pBG_->Draw(r, renderer);
 	}
 }
 
+// virtual
+bool Element::HitTest(int16_t x, int16_t y) const
+{
+	return rect_.Contains(x, y);
+}
 
-} // namespace MG
+void Element::AddEventListener(int type, const EventListener& listener)
+{
+	EventListenerEntry entry;
+	entry.type = type;
+	entry.listener = listener;
+	eventEntries_.push_back(entry);
+}
+
+void Element::RemoveEventListener(int type, const EventListener& listener)
+{
+	for (size_t i=0; i<eventEntries_.length_; ++i) {
+		EventListenerEntry& entry = eventEntries_[i];
+		if (entry.type == type && entry.listener == listener) {
+			entry.type = 0;
+			entry.listener = 0;
+			break;
+		}
+	}
+}
+
+void Element::fireEventListener(const Event& e)
+{
+	for (size_t i=0; i<eventEntries_.length_; ++i) {
+		EventListenerEntry& entry = eventEntries_[i];
+		if (entry.type == e.type) {
+			entry.listener(pEventListenerParam_, e);
+		}
+	}
+}
+
+// virtual
+void Element::OnMouseDown(int16_t x, int16_t y)
+{
+	Event e;
+	e.target = this;
+	e.type = EventType_MouseDown;
+	e.x = x;
+	e.y = y;
+	fireEventListener(e);
+}
+
+// virtual
+void Element::OnMouseUp(int16_t x, int16_t y)
+{
+	Event e;
+	e.target = this;
+	e.type = EventType_MouseUp;
+	e.x = x;
+	e.y = y;
+	fireEventListener(e);
+}
 
+// virtual
+void Element::OnMouseMove(int16_t x, int16_t y)
+{
+	Event e;
+	e.target = this;
+	e.type = EventType_MouseMove;
+	e.x = x;
+	e.y = y;
+	fireEventListener(e);
+}
+
+} // namespace MG

--- a/mg/element.h
+++ b/mg/element.h
@@ -2,7 +2,6 @@
 
 #include "renderer.h"
 #include "optional.h"
-#include "callback.hpp"
 #include "varray.h"
 
 namespace MG {
@@ -15,23 +14,20 @@ public:
 	Element(size_t nMaxEvents);
 	virtual ~Element() {}
 	
-	bool IsClickable() const {
-		return bClickable_;
-	}
-	
 	virtual void Draw(int16_t offsetX, int16_t offsetY, IRenderer& renderer);
-	virtual bool HitTest(int16_t x, int16_t y) const { return false; }
-	virtual void OnMouseDown(int16_t x, int16_t y) {}
-	virtual void OnMouseUp(int16_t x, int16_t y) {}
-	virtual void OnMouseMove(int16_t x, int16_t y) {}
+	virtual bool HitTest(int16_t x, int16_t y) const;
+	
+	virtual void OnMouseDown(int16_t x, int16_t y);
+	virtual void OnMouseUp(int16_t x, int16_t y);
+	virtual void OnMouseMove(int16_t x, int16_t y);
 	
-	Rectangle rect;	// positioning, size
-	bool needsToDraw;
+	Rectangle rect_;	// positioning, size
+	bool needsToDraw_;
 	
 	struct IBackground {
 		virtual void Draw(const Rectangle& rect, IRenderer& renderer) = 0;
 	};
-	IBackground* pBG;
+	IBackground* pBG_;
 	
 	Element* GetParent() const { return pParent_; }
 	void SetParent(Element* pParent) { pParent_ = pParent; }
@@ -51,19 +47,20 @@ public:
 		int16_t x;
 		int16_t y;
 	};
-	typedef util::Callback<void (const Event&)> EventListener;
+	typedef void (*EventListener)(void* param, const Event& e);
 	struct EventListenerEntry {
 		int type;
 		EventListener listener;
 	};
+	void* pEventListenerParam_;
 	void AddEventListener(int type, const EventListener& listener);
 	void RemoveEventListener(int type, const EventListener& listener);
-	
+	static Element* s_pCapture_;
 protected:
-	bool bClickable_;
 	Element* pParent_;
 	
 	varray<EventListenerEntry> eventEntries_;
+	void fireEventListener(const Event& e);
 };
 
 } // namespace MG

--- a/mg/rectangle.cpp
+++ b/mg/rectangle.cpp
@@ -18,7 +18,7 @@ Rectangle Rectangle::Offset(const Rectangle& r, int16_t x, int16_t y)
 	return ret;
 }
 
-bool Rectangle::Contains(int16_t x, int16_t y)
+bool Rectangle::Contains(int16_t x, int16_t y) const
 {
 	return
 		1
@@ -29,7 +29,7 @@ bool Rectangle::Contains(int16_t x, int16_t y)
 	;
 }
 
-bool Rectangle::Contains(const Rectangle& r)
+bool Rectangle::Contains(const Rectangle& r) const
 {
 	return true;
 }

--- a/mg/rectangle.h
+++ b/mg/rectangle.h
@@ -19,8 +19,8 @@ struct Rectangle
 	void Offset(int16_t x, int16_t y);
 	static Rectangle Offset(const Rectangle& r, int16_t x, int16_t y);
 	
-	bool Contains(int16_t x, int16_t y);
-	bool Contains(const Rectangle& r);
+	bool Contains(int16_t x, int16_t y) const;
+	bool Contains(const Rectangle& r) const;
 	
 	void Intersect(const Rectangle& r);
 	static Rectangle Intersect(const Rectangle& r1, const Rectangle& r2);