WindowBase.h

#ifndef NEO_WINDOW_BASE_H
#define NEO_WINDOW_BASE_H

namespace neo
{

class WindowBase;

namespace dev
{
    class Functor
    {
    public:
        virtual ~Functor() {}

        virtual bool operator() (HWND hwnd, UINT message, WPARAM wp, LPARAM lp, LRESULT& result, WindowBase* origin) = 0;
    };

    class MessageHandlerMap
    {
    public:
        typedef std::pair<MessageId, std::unique_ptr<Functor>> PAIR;
        typedef std::vector<PAIR> DATA;

        MessageHandlerMap() {}
        // make it copyable but dont actually copy anything
        MessageHandlerMap(const MessageHandlerMap& rhs) {}

        DATA::const_iterator FindHandler(const MessageId& key) const
        {
            auto end = map.end();
            for(auto it = map.begin(); it < end; ++it)
                if(it->first == key)
                    return it;
            return end;
        }
        // find the first element that is not less than key
        DATA::iterator GetLowerBound(const MessageId& key)
        {
            auto it = map.begin();
            auto end = map.end();
            while(it != end)
            {
                if(!(it->first < key))
                    break;
                ++it;
            }
            return it;
        }
        // insert into the map, sorted
        void AddHandler(const MessageId& key, Functor* handler)
        {
            auto it = GetLowerBound(key);
            if(it != map.end())
            {
                if(it->first == key)
                {
                    it->second.reset(handler);
                }
                else
                {
                    map.insert(it, std::make_pair(key, std::unique_ptr<Functor>(handler)));
                }
            }
            else
                map.push_back(std::make_pair(key, std::unique_ptr<Functor>(handler)));
        }
        void RemoveHandler(const MessageId& key)
        {
            auto found = FindHandler(key);
            if(found != map.end())
                map.erase(found);
        }
        Functor* GetHandler(const MessageId& key) const
        {
            for(size_t i = 0; i < map.size(); ++i)
                if(key.EqualOrSpecializationOf(map[i].first))
                    return map[i].second.get();
            return 0;
        }

        DATA map;
    };

    class StrongHwnd
    {
    public:
        StrongHwnd();
        // make it copiable but dont actually copy anything
        StrongHwnd(const StrongHwnd& rhs);
        ~StrongHwnd();

        void Create(DWORD exStyle,
            const tstring& cls,
            const tstring& text,
            DWORD style,
            const Rect& r,
            HWND parent,
            HMENU menu,
            HINSTANCE instance,
            WindowBase* obj);
        void Attach(HWND hwnd);
        void Clear();
        HWND GetHandle() const { return handle; }

        HWND handle;
        WNDPROC subclassedProc;
        bool isOnlyAttached;
    };

    class WeakHwnd
    {
    public:
        WeakHwnd() { handle = 0; }

        void Create(DWORD exStyle,
            const tstring& cls,
            const tstring& text,
            DWORD style,
            const Rect& r,
            HWND parent,
            HMENU menu,
            HINSTANCE instance);
        void Attach(HWND hwnd) { handle = hwnd; }
        void Clear() { handle = 0; }
        HWND GetHandle() const { return handle; }

        HWND handle;
    };
} // dev

class WindowBase
{
public:
    WindowBase();
    WindowBase(const WindowBase& rhs);
    WindowBase& operator=(const WindowBase& rhs);
    virtual ~WindowBase();

    operator HWND() const { return GetHandle(); }
    HWND GetHandle() const { return strong.handle ? strong.handle : weak.handle; }

    void Create(DWORD exStyle,
        const tstring& cls,
        const tstring& text,
        DWORD style,
        const Rect& r,
        HWND parent,
        HMENU menu,
        NEO_WINDOW_MODE mode);

    void Attach(HWND handle, NEO_WINDOW_MODE mode);
    void Clear();

    template<typename MESSAGE>
    void Bind(UINT message, void (*function)(MESSAGE&))
    {
        Bind(MessageId(message), function);
    }

    template<typename MESSAGE, typename FUNCTOR>
    void Bind(UINT message, FUNCTOR function)
    {
        Bind(MessageId(message), function);
    }

    template<typename CLASS, typename MESSAGE, typename HANDLER>
    void Bind(UINT message, void (CLASS::*function)(MESSAGE&), HANDLER* handler)
    {
        Bind(MessageId(message), function, handler);
    }

    template<typename MESSAGE>
    void Bind(const MessageId& message, void (*function)(MESSAGE&))
    {
        handlerMap.AddHandler(message, new FunctionCallback<MESSAGE>(function));
    }

    template<typename MESSAGE, typename FUNCTOR>
    void Bind(const MessageId& message, FUNCTOR function)
    {
        handlerMap.AddHandler(message, new FunctorCallback<MESSAGE, FUNCTOR>(function));
    }

    template<typename CLASS, typename MESSAGE, typename HANDLER>
    void Bind(const MessageId& message, void (CLASS::*function)(MESSAGE&), HANDLER* handler)
    {
        handlerMap.AddHandler(message, new MemberCallback<CLASS, MESSAGE, HANDLER>(function, handler));
    }

    void UnBind(UINT message)
    {
        handlerMap.RemoveHandler(MessageId(message));
    }

    void UnBind(const MessageId& message)
    {
        handlerMap.RemoveHandler(message);
    }

    bool IsMessageHandlerBound(UINT message) const { return handlerMap.GetHandler(MessageId(message)) != 0; }

    void Destroy();

    tstring GetText() const;

    void SetText(const tstring& text);

    bool IsEnabled() const;
    void Enable(bool enable);

    bool IsVisible() const;
    void Show(bool show = true);
    void Hide() { Show(false); }

    void SetRedraw(bool allowRedraw);

    HFONT GetFont() const;
    void SetFont(HFONT font, bool redraw = true);

    HICON GetIcon(bool bigIcon) const;
    HICON SetIcon(HICON icon, bool bigIcon);
    HMENU GetMenu() const;
    void SetMenu(HMENU menu);

    DWORD GetStyle() const;
    DWORD GetExStyle() const;

    DWORD GetID() const;

    HWND GetParentHandle() const;

    UINT_PTR SetTimer(int timerID, UINT interval, TIMERPROC proc = 0);
    void KillTimer(int timerID);

    Rect GetClientRect() const;

    Rect GetWindowRect() const;

    Rect GetRectOnParent() const;

    void Move(int x, int y, bool redraw = true);
    void Move(const POINT& p, bool redraw = true);
    void Move(int x, int y, int width, int height, bool redraw = true);
    void Move(const POINT& p, const SIZE& s, bool redraw = true);
    void Move(const RECT& r, bool redraw = true);
    
    void SetClientSize(int width, int height);

    bool Invalidate(const RECT* rect = 0, bool eraseBkgnd = true);
    bool Redraw(const RECT* rect = 0, HRGN region = 0, UINT flags = RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE);

    HWND SetFocus();

    void ModifyStyle(DWORD add, DWORD remove);

    void DragAcceptFiles(bool accept = true);

    LRESULT GenerateMessage(UINT message, WPARAM wp, LPARAM lp) const;

    static HFONT GetDefaultFont();
    static void SetDefaultFont(HFONT font);

    static HCURSOR GetDefaultCursor();
    static void SetDefaultCursor(HCURSOR cursor);

    static HICON GetDefaultIcon();
    static void SetDefaultIcon(HICON icon);

    static WindowBase* GetWindowFromHWND(HWND _handle);

    static LRESULT CALLBACK StaticWndProc(HWND hwnd, UINT message, WPARAM wp, LPARAM lp);
    LRESULT DefaultWndProc(HWND hwnd, UINT message, WPARAM wp, LPARAM lp);
    virtual LRESULT WndProc(HWND hwnd, UINT message, WPARAM wp, LPARAM lp);
private:
    bool ExecuteMessageHandler(HWND hwnd, UINT message, WPARAM wp, LPARAM lp, LRESULT& result);

    static HFONT& _DefaultFont()
    {
        static HFONT font = 0;
        return font;
    }

    static HCURSOR& _DefaultCursor()
    {
        static HCURSOR defaultCursor = LoadCursor(0, IDC_ARROW);
        return defaultCursor;
    }

    static HICON& _DefaultIcon()
    {
        static HICON defaultIcon = LoadIcon(0, IDI_APPLICATION);
        return defaultIcon;
    }

    // map HWND to WindowBase* with this little function
    typedef std::unordered_map<HWND, WindowBase*> HwndMap;
    static HwndMap& _GetHwndMap()
    {
        static HwndMap map;
        return map;
    };

    // functor to global function
    template<typename MESSAGE>
    struct FunctionCallback : public dev::Functor
    {
        typedef void (*FUNCTION)(MESSAGE&);

        FunctionCallback(const FUNCTION& f)
            : function(f)
        {}

        virtual bool operator() (HWND hwnd, UINT message, WPARAM wp, LPARAM lp, LRESULT& result, WindowBase* origin)
        {
            MESSAGE m;
            m.Init(hwnd, message, wp, lp);
            m.messageHandler = origin;

            function(m);

            if(m.resultSet && result)
                result = m.result;
            return m.resultSet;
        }

        FUNCTION function;
    };

    // functor to function object
    template<typename MESSAGE, typename FUNCTOR>
    struct FunctorCallback : public dev::Functor
    {
        FunctorCallback(const FUNCTOR& f)
            : function(f)
        {}

        virtual bool operator() (HWND hwnd, UINT message, WPARAM wp, LPARAM lp, LRESULT& result, WindowBase* origin)
        {
            MESSAGE m;
            m.Init(hwnd, message, wp, lp);
            m.messageHandler = origin;

            function(m);

            if(m.resultSet && result)
                result = m.result;
            return m.resultSet;
        }

        FUNCTOR function;
    };

    // functor to member function
    template<typename CLASS, typename MESSAGE, typename HANDLER>
    struct MemberCallback : public dev::Functor
    {
        typedef void (CLASS::*FUNCTION)(MESSAGE& m);

        MemberCallback(FUNCTION f, HANDLER* inst)
            : function(f)
            , instance(inst)
        {}

        virtual bool operator() (HWND hwnd, UINT message, WPARAM wp, LPARAM lp, LRESULT& result, WindowBase* origin)
        {
            MESSAGE m;
            m.Init(hwnd, message, wp, lp);
            m.messageHandler = origin;

            (instance->*function)(m);

            if(m.resultSet && result)
                result = m.result;
            return m.resultSet;
        }

        FUNCTION function;
        HANDLER* instance;
    };

    dev::StrongHwnd strong;
    dev::WeakHwnd weak;
    dev::MessageHandlerMap handlerMap;
};

} // namespace neo

#endif