Commit: df726866632f095971b477ee8f068558dca82726 - MG (git)

milligram

Commit MetaInfo

• Révision: df726866632f095971b477ee8f068558dca82726 (tree)
• l'heure: 2011-03-24 17:11:53
• Auteur: beru <berupon@gmai...>
• Commiter: beru

Message de Log

bkup

Change Summary

• add: common/callback.hpp
• add: common/varray.h
• modified: main_plus.cpp
• modified: mg.vcproj
• modified: mg/bitmap.h
• modified: mg/button.cpp
• modified: mg/button.h
• modified: mg/container.cpp
• modified: mg/container.h
• modified: mg/element.cpp
• modified: mg/element.h
• add: mg/radioButton.h

Modification

--- /dev/null
+++ b/common/callback.hpp
@@ -0,0 +1,1038 @@
+#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
+

--- /dev/null
+++ b/common/varray.h
@@ -0,0 +1,46 @@
+#pragma once
+
+#include "arrayutil.h"
+
+template <typename T>
+class varray
+{
+public:
+	varray()
+		:
+		buff_(0),
+		maxLength_(0),
+		length_(0)
+	{
+	}
+	
+	varray(T* buff, size_t maxLength)
+		:
+		buff_(buff),
+		maxLength_(maxLength),
+		length_(0)
+	{
+	}
+	
+	T* buff_;
+	size_t maxLength_;
+	size_t length_;
+	
+	T& operator[] (int i) { return buff_[i]; }
+    const T& operator[] (int i) const { return buff_[i]; }
+	
+	void push_back(const T& val)
+	{
+		assert(length_ < maxLength_);
+		buff_[length_] = val;
+		++length_;
+	}
+
+};
+
+template <typename T, size_t N>
+varray<T> varray_build( T (&arr)[N] )
+{
+	return varray<T>(arr, N);
+}
+

--- a/main_plus.cpp
+++ b/main_plus.cpp
@@ -11,9 +11,35 @@
 #include "mg/button.h"
 
 #include "winutil.h"
+#include "arrayutil.h"
 #include "ReadImage/File.h"
 #include "ReadImage/ReadImage.h"
 
+namespace MG {
+
+struct BasicBG : public Element::IBackground
+{
+public:
+	optional<Color> color;
+	Image image;
+	bool repeatX;
+	bool repeatY;
+
+	virtual void Draw(const Rectangle& rect, IRenderer& renderer)
+	{
+		if (color) {
+			Color c = *color;
+			renderer.FillRectangle(rect, c);
+		}
+		if (image.pBitmap) {
+			const Bitmap& bmp = *image.pBitmap;
+			renderer.DrawBitmap(bmp, image.GetRect(), rect);
+		}
+	}
+};
+
+} // namespace MG
+
 namespace {
 
 HWND hWnd;
@@ -24,11 +50,12 @@ void* pBits;
 HDC hMemDC;
 
 MG::Renderer24 renderer;
-MG::Element* elements[128];
 
-MG::Container mg(elements, 128);
-MG::Button button1;
-MG::Button button2;
+MG::Container mg(4, 8);
+MG::Button button1(0);
+MG::Button button2(0);
+MG::Element pic1(0);
+MG::Element pic2(0);
 
 MG::Bitmap bmp24Content;
 std::vector<uint8_t> image24Buffer;
@@ -36,8 +63,11 @@ std::vector<uint8_t> image24Buffer;
 MG::Bitmap bmp32Content;
 std::vector<uint8_t> image32Buffer;
 
-MG::Element pic1;
-MG::Element pic2;
+MG::BasicBG mainbg;
+MG::BasicBG buttonBG;
+MG::BasicBG buttonBGPressed;
+MG::BasicBG picbg1;
+MG::BasicBG picbg2;
 
 bool ReadImage(const char* filename, MG::Bitmap& bmp, std::vector<uint8_t>& buffer)
 {
@@ -91,7 +121,7 @@ void OnCreate(HWND hWnd, WPARAM wParam, LPARAM lParam)
 	bmp.pBits = pBits;
 	bmp.lineOffsetBytes = width * 3;
 	renderer.SetBitmap(bmp);
-
+	
 	MG::Rectangle rect;
 	rect.x = 0;
 	rect.y = 0;
@@ -102,22 +132,33 @@ void OnCreate(HWND hWnd, WPARAM wParam, LPARAM lParam)
 	col.r = 50;
 	col.g = 200;
 	col.b = 150;
-	mg.bg.color = col;
+	
+	mainbg.color = col;
+	mg.pBG = &mainbg;
 	mg.needsToDraw = true;
 	
+	col.g = 100;
+	buttonBG.color = col;
+	col.r = 200;
+	buttonBGPressed.color = col;
+	
 	rect.x = 100;
 	rect.y = 100;
 	rect.w = 100;
 	rect.h = 50;
 	button1.rect = rect;
-	mg.Add(button1);
+	button1.pBG = &buttonBG;
+	button1.pBGPressed = &buttonBGPressed;
+	mg.AddChild(button1);
 	
 	rect.x = 300;
 	rect.y = 100;
 	rect.w = 100;
 	rect.h = 50;
 	button2.rect = rect;
-	mg.Add(button2);
+	button2.pBG = &buttonBG;
+	button2.pBGPressed = &buttonBGPressed;
+	mg.AddChild(button2);
 	
 	if (!ReadImage("test24.bmp", bmp24Content, image24Buffer)) {
 		return;
@@ -134,10 +175,11 @@ void OnCreate(HWND hWnd, WPARAM wParam, LPARAM lParam)
 	irec.y = 340;
 	irec.w = 400;
 	irec.h = 400;
-	pic1.bg.image.rect = irec;
-	pic1.bg.image.pBitmap = &bmp24Content;
+	picbg1.image.rect = irec;
+	picbg1.image.pBitmap = &bmp24Content;
+	pic1.pBG = &picbg1;
 	pic1.needsToDraw = true;
-	mg.Add(pic1);
+	mg.AddChild(pic1);
 	
 	rect.x = 300;
 	rect.y = 200;
@@ -148,10 +190,11 @@ void OnCreate(HWND hWnd, WPARAM wParam, LPARAM lParam)
 	irec.y = 0;
 	irec.w = 336;
 	irec.h = 24;
-	pic2.bg.image.rect = irec;
-	pic2.bg.image.pBitmap = &bmp32Content;
+	picbg2.image.rect = irec;
+	picbg2.image.pBitmap = &bmp32Content;
+	pic2.pBG = &picbg2;
 	pic2.needsToDraw = true;
-	mg.Add(pic2);
+	mg.AddChild(pic2);
 	
 	HDC hWndDC = ::GetDC(hWnd);
 	hMemDC = ::CreateCompatibleDC(hWndDC);

--- a/mg.vcproj
+++ b/mg.vcproj
@@ -313,6 +313,10 @@
 				>
 			</File>
 			<File
+				RelativePath=".\common\callback.hpp"
+				>
+			</File>
+			<File
 				RelativePath=".\common\optional.h"
 				>
 			</File>
@@ -321,6 +325,10 @@
 				>
 			</File>
 			<File
+				RelativePath=".\common\varray.h"
+				>
+			</File>
+			<File
 				RelativePath=".\common\winutil.cpp"
 				>
 			</File>

--- a/mg/bitmap.h
+++ b/mg/bitmap.h
@@ -15,11 +15,19 @@ struct Bitmap
 	Rectangle GetRect() const;	
 };
 
-struct Image {
+struct Image
+{
+	Image()
+		:
+		pBitmap(0)
+	{
+	}
+	
 	Bitmap* pBitmap;
 	Rectangle rect;
 	
-	Rectangle GetRect() const {
+	Rectangle GetRect() const
+	{
 		if (pBitmap) {
 			return Rectangle::Intersect(pBitmap->GetRect(), rect);
 		}else {

--- a/mg/button.cpp
+++ b/mg/button.cpp
@@ -4,7 +4,10 @@
 
 namespace MG {
 
-Button::Button()
+Button::Button(size_t nMaxEvents)
+	:
+	Element(nMaxEvents),
+	pBGPressed(0)
 {
 	needsToDraw = true;
 	bClickable_ = true;
@@ -12,11 +15,14 @@ Button::Button()
 
 void Button::Draw(int16_t offsetX, int16_t offsetY, IRenderer& renderer)
 {
-	Color c;
-	c.r = c.g = c.b = c.a = (isPressed_ ? 0xcf : 0x55);
-	bg.color = c;
-	
-	__super::Draw(offsetX, offsetY, renderer);
+	if (isPressed_) {
+		IBackground* backup = pBG;
+		pBG = pBGPressed;
+		__super::Draw(offsetX, offsetY, renderer);
+		pBG = backup;
+	}else {
+		__super::Draw(offsetX, offsetY, renderer);
+	}
 }
 
 bool Button::HitTest(int16_t x, int16_t y) const
@@ -40,6 +46,7 @@ void Button::OnMouseUp(int16_t x, int16_t y)
 
 void Button::OnMouseMove(int16_t x, int16_t y)
 {
+	;
 }
 
 } // anonymous MG

--- a/mg/button.h
+++ b/mg/button.h
@@ -10,7 +10,7 @@ class Button
 	public Element
 {
 public:
-	Button();
+	Button(size_t nMaxEvents);
 	
 	void Draw(int16_t offsetX, int16_t offsetY, IRenderer& renderer);
 	bool HitTest(int16_t x, int16_t y) const;
@@ -18,7 +18,15 @@ public:
 	void OnMouseUp(int16_t x, int16_t y);
 	void OnMouseMove(int16_t x, int16_t y);
 	
-private:
+	IBackground* pBGPressed;
+	
+	enum EventType {
+		EventType_Clicked = __super::EventType_End,
+		
+		EventType_End,
+	};
+	
+protected:
 	bool isPressed_;
 	
 };

--- a/mg/container.cpp
+++ b/mg/container.cpp
@@ -2,33 +2,42 @@
 
 #include "container.h"
 
+namespace {
+
+size_t s_nElementEntries;
+MG::Element* s_elementPtrs[128];
+
+} // anonymous namespace
+
 namespace MG {
 
-Container::Container(Element** buff, size_t maxLength)
+Container::Container(size_t nMaxEvents, size_t nMaxChildren)
 	:
-	buff_(buff),
-	maxLength_(maxLength),
-	length_(0)
+	Element(nMaxEvents),
+	clickedElementIndex_(0)
 {
+	vElements_.buff_ = &s_elementPtrs[s_nElementEntries];
+	vElements_.maxLength_ = nMaxChildren;
+	s_nElementEntries += nMaxChildren;
+	assert(s_nElementEntries < countof(s_elementPtrs));
 }
 
 Container::~Container()
 {
 }
 
-void Container::Add(Element& e)
+void Container::AddChild(Element& e)
 {
-	assert(length_ < maxLength_);
-	buff_[length_] = &e;
-	++length_;
+	vElements_.push_back(&e);
+	e.SetParent(this);
 }
 
-void Container::Remove(Element& e)
+void Container::RemoveChild(Element& e)
 {
-	const Element* ptr = &e;
-	for (size_t i=0; i<length_; ++i) {
-		if (buff_[i] == ptr) {
-			buff_[i] = NULL;
+	for (size_t i=0; i<vElements_.length_; ++i) {
+		if (vElements_[i] == &e) {
+			vElements_[i] = 0;
+			e.SetParent(0);
 			break;
 		}
 	}
@@ -43,8 +52,8 @@ void Container::Draw(int16_t offsetX, int16_t offsetY, IRenderer& renderer)
 	
 	int16_t x = rect.x + offsetX;
 	int16_t y = rect.y + offsetY;
-	for (size_t i=0; i<length_; ++i) {
-		Element* e = buff_[i];
+	for (size_t i=0; i<vElements_.length_; ++i) {
+		Element* e = vElements_[i];
 		if (e && e->needsToDraw) {
 			e->Draw(x, y, renderer);
 			e->needsToDraw = false;
@@ -61,8 +70,8 @@ void Container::OnMouseDown(int16_t x, int16_t y)
 {
 	int16_t ox = x - rect.x;
 	int16_t oy = y - rect.y;
-	for (size_t i=0; i<length_; ++i) {
-		Element* e = buff_[i];
+	for (size_t i=0; i<vElements_.length_; ++i) {
+		Element* e = vElements_[i];
 		if (e) {
 			if (1
 				&& e->IsClickable()
@@ -81,23 +90,22 @@ void Container::OnMouseUp(int16_t x, int16_t y)
 {
 	int16_t ox = x - rect.x;
 	int16_t oy = y - rect.y;
-	Element* e = buff_[clickedElementIndex_];
-	assert(e);
-	e->OnMouseUp(ox, oy);
+	Element* e = vElements_[clickedElementIndex_];
+	if (e) {
+		e->OnMouseUp(ox, oy);
+	}
 }
 
 void Container::OnMouseMove(int16_t x, int16_t y)
 {
 	int16_t ox = x - rect.x;
 	int16_t oy = y - rect.y;
-	Element* e = buff_[clickedElementIndex_];
-	assert(e);
-	e->OnMouseMove(ox, oy);
+	Element* e = vElements_[clickedElementIndex_];
+	if (e) {
+		e->OnMouseMove(ox, oy);
+	}
 }
 
 
 } // namespace MG
 
-
-
-

--- a/mg/container.h
+++ b/mg/container.h
@@ -1,17 +1,20 @@
 #pragma once
 
 #include "element.h"
+#include "varray.h"
 
 namespace MG {
 
-class Container : public Element
+class Container
+	:
+	public Element
 {
 public:
-	Container(Element** buff, size_t maxLength);
+	Container(size_t nMaxEvents, size_t nMaxChildren);
 	virtual ~Container();
 	
-	void Add(Element& e);
-	void Remove(Element& e);
+	void AddChild(Element& e);
+	void RemoveChild(Element& e);
 	
 	virtual void Draw(int16_t offsetX, int16_t offsetY, IRenderer& renderer);
 	virtual bool HitTest(int16_t x, int16_t y) const;
@@ -19,11 +22,10 @@ public:
 	virtual void OnMouseUp(int16_t x, int16_t y);
 	virtual void OnMouseMove(int16_t x, int16_t y);
 	
-private:
-	Element** buff_;
-	size_t maxLength_;
-	size_t length_;
+protected:
 	size_t clickedElementIndex_;
+	varray<Element*> vElements_;
+	
 };
 
 } // namespace MG

--- a/mg/element.cpp
+++ b/mg/element.cpp
@@ -1,9 +1,30 @@
 #include "stdafx.h"
 
 #include "element.h"
+#include "arrayutil.h"
+
+namespace {
+
+size_t s_nEventEntries;
+MG::Element::EventListenerEntry s_eventEntries[128];
+
+} // anonymous namespace
 
 namespace MG {
 
+Element::Element(size_t nMaxEvents)
+{
+	eventEntries_.buff_ = &s_eventEntries[s_nEventEntries];
+	eventEntries_.maxLength_ = nMaxEvents;
+	s_nEventEntries += nMaxEvents;
+	assert(s_nEventEntries < countof(s_eventEntries));
+	
+	pParent_ = 0;
+	needsToDraw = false;
+	pBG = 0;
+	bClickable_ = false;
+}
+
 // virtual
 void Element::Draw(int16_t offsetX, int16_t offsetY, IRenderer& renderer)
 {
@@ -11,15 +32,9 @@ void Element::Draw(int16_t offsetX, int16_t offsetY, IRenderer& renderer)
 	r.x += offsetX;
 	r.y += offsetY;
 	
-	if (bg.color) {
-		Color c = *bg.color;
-		renderer.FillRectangle(r, c);
+	if (pBG) {
+		pBG->Draw(r, renderer);
 	}
-	if (bg.image.pBitmap) {
-		const Bitmap& bmp = *bg.image.pBitmap;
-		renderer.DrawBitmap(bmp, bg.image.GetRect(), r);
-	}
-	
 }
 
 

--- a/mg/element.h
+++ b/mg/element.h
@@ -2,24 +2,18 @@
 
 #include "renderer.h"
 #include "optional.h"
+#include "callback.hpp"
+#include "varray.h"
 
 namespace MG {
 
 class Element
 {
 public:
-	Element()
-		:
-		needsToDraw(false),
-		bClickable_(false)
-	{
-		bg.repeatX = true;
-		bg.repeatY = true;
-	}
+	typedef uint8_t id_t;
 	
-	virtual ~Element()
-	{
-	}
+	Element(size_t nMaxEvents);
+	virtual ~Element() {}
 	
 	bool IsClickable() const {
 		return bClickable_;
@@ -31,17 +25,45 @@ public:
 	virtual void OnMouseUp(int16_t x, int16_t y) {}
 	virtual void OnMouseMove(int16_t x, int16_t y) {}
 	
-	Rectangle rect;
+	Rectangle rect;	// positioning, size
 	bool needsToDraw;
 	
-	struct Background {
-		optional<Color> color;
-		Image image;
-		bool repeatX;
-		bool repeatY;
-	} bg;
+	struct IBackground {
+		virtual void Draw(const Rectangle& rect, IRenderer& renderer) = 0;
+	};
+	IBackground* pBG;
+	
+	Element* GetParent() const { return pParent_; }
+	void SetParent(Element* pParent) { pParent_ = pParent; }
+	
+	// event
+	enum EventType {
+		EventType_MouseDown,
+		EventType_MouseUp,
+		EventType_MouseMove,
+		
+		EventType_End,
+	};
+	struct Event
+	{
+		Element* target;
+		uint8_t type;
+		int16_t x;
+		int16_t y;
+	};
+	typedef util::Callback<void (const Event&)> EventListener;
+	struct EventListenerEntry {
+		int type;
+		EventListener listener;
+	};
+	void AddEventListener(int type, const EventListener& listener);
+	void RemoveEventListener(int type, const EventListener& listener);
+	
 protected:
 	bool bClickable_;
+	Element* pParent_;
+	
+	varray<EventListenerEntry> eventEntries_;
 };
 
 } // namespace MG

--- /dev/null
+++ b/mg/radioButton.h
@@ -0,0 +1,29 @@
+#pragma once
+
+#include "button.h"
+
+namespace MG {
+
+class RadioButton
+	:
+	public Button
+{
+public:
+	RadioButton();
+	
+	void Draw(int16_t offsetX, int16_t offsetY, IRenderer& renderer);
+	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);
+	
+	uint8_t groupID;
+protected:
+	bool isSelected_;
+	
+};
+
+} // anonymous MG
+
+
+