TnbMultiMouseManager.h

[詳解]

#pragma once
#include "TnbDummyWindow.h"
#include "TnbPointerVector.h"
#include "TnbBitmapImage.h"
#include <math.h>
 
 
 
//TNB Library
namespace TNB
{
 
 
 
struct IMultiMouseWatcher
{
public:
 
    struct IListener
    {
        virtual ~IListener(void) {}
 
        enum EDevice
        {
            Device_Connect,     
            Device_Reconnect,   
            Device_Remove,      
        };
 
        virtual void OnMultiMouseDevice(INDEX index, EDevice device) = 0;
 
        virtual void OnMultiMouseEvent(INDEX index, const RAWMOUSE& mouse) = 0;
    };
 
 
    //--------------------------------
 
 
    virtual void SetListener(IListener* P) = NULL;
 
    virtual size_t GetMouseCount(void) const = NULL;
 
    virtual bool Start(void) = NULL;
 
    virtual void Stop(void) = NULL;
};
 
 
 
class CMultiMouseManager
{
public:
    
    struct IListener : IMultiMouseWatcher::IListener
    {
        virtual ~IListener(void) {}
 
        enum EButton
        {
            Button_Left,        
            Button_Right,       
            Button_Middle,      
        };
 
        enum EEvent
        {
            Event_Up,           
            Event_Down,         
        };
 
        virtual void OnMultiMouseButton(INDEX index, EButton button, EEvent event, int x, int y) = 0;
 
        virtual void OnMultiMouseMove(INDEX index, BYTE buttonFlags, int x, int y) = 0;
 
        virtual void OnMultiMouseWheel(INDEX index, int d) = 0;
 
        virtual void OnMultiMouseEvent(INDEX index, const RAWMOUSE& mouse) { }
 
        #ifdef _TnbDOXYGEN  //Document作成用シンボル
 
        enum EDevice
        {
            Device_Connect,     
            Device_Reconnect,   
            Device_Remove,      
        };
 
        virtual void OnMultiMouseDevice(INDEX index, EDevice device) = 0;
 
        #endif
 
        static DWORD MakeMouseEventFlags(EButton button, EEvent event)
        {
            if ( event == Event_Down )
            {
                switch ( button )
                {
                case Button_Left:   return MOUSEEVENTF_LEFTDOWN;
                case Button_Right:  return MOUSEEVENTF_RIGHTDOWN;
                case Button_Middle: return MOUSEEVENTF_MIDDLEDOWN;
                }
            }
            else if ( event == Event_Up )
            {
                switch ( button )
                {
                case Button_Left:   return MOUSEEVENTF_LEFTUP;
                case Button_Right:  return MOUSEEVENTF_RIGHTUP;
                case Button_Middle: return MOUSEEVENTF_MIDDLEUP;
                }
            }
            return 0;
        }
    };
 
 
    //-----------------------------------
 
 
    CMultiMouseManager(void) : m_pWatcher(NULL)
    {
        ::SetRectEmpty(&m_in.m_corsorRect);
    }
 
    void SetListener(IListener* P)
    {
        EXCLUSIVE( &m_in.m_sync );
        m_in.m_pListener = P;
    }
 
    bool Start(IMultiMouseWatcher* pWatcher, HWND hParent = NULL)
    {
        EXCLUSIVE( &m_in.m_sync );
        Stop();
        m_pWatcher = pWatcher;
        m_pWatcher->SetListener(&m_in);
        if ( ! m_in.m_cursorImage.IsNull() )
        {
            m_in.m_hParent = hParent;
            if ( m_pWatcher->Start() )
            {
                size_t len = m_pWatcher->GetMouseCount();
                m_in.m_cursores.SetSize(len);
                loop ( i, len )
                {
                    if ( ! m_in.CheckIndex(i) )
                    {
                        return false;
                    }
                }
                return true;
            }
            Stop();
        }
        return false;
    }
 
    void Stop(void)
    {
        EXCLUSIVE( &m_in.m_sync );
        if ( m_pWatcher != NULL )
        {
            m_pWatcher->Stop();
            m_in.m_cursores.RemoveAll();
            m_pWatcher = NULL;
        }
    }
 
    bool SetDefaultCursorImage(int hotspotX, int hotspotY, CBitmapHandle bmp, COLORREF color = CLR_AUTOSELECT)
    {
        EXCLUSIVE( &m_in.m_sync );
        m_in.m_cursorImage = bmp;
        m_in.m_cursorMaskColor = color;
        m_in.m_cursorHotspot.x = hotspotX;
        m_in.m_cursorHotspot.y = hotspotY;
        return ! m_in.m_cursorImage.IsNull();
    }
 
    bool SetDefaultCursorImage(CBitmapHandle bmp, COLORREF color = CLR_AUTOSELECT)
    {
        return SetDefaultCursorImage(0, 0, bmp, color);
    }
 
    bool SetDefaultCursorImage(HCURSOR hCursor, COLORREF color = RGB(255, 0, 255))
    {
        EXCLUSIVE( &m_in.m_sync );
        CBitmapHandle bmp;
        POINT hotspot;
        if ( m_IconToBitmap(bmp, hotspot, hCursor, color) )
        {
            m_in.m_cursorImage = bmp;
            m_in.m_cursorMaskColor = color;
            m_in.m_cursorHotspot = hotspot;
            return ! m_in.m_cursorImage.IsNull();
        }
        return false;
    }
 
    size_t GetMouseCount(void) const
    {
        EXCLUSIVE( &m_in.m_sync );
        return m_in.m_cursores.GetSize();
    }
 
    bool IsValid(INDEX index) const
    {
        EXCLUSIVE( &m_in.m_sync );
        return (m_RefCursorManager(index) != NULL);
    }
 
    bool SetCursorImage(INDEX index, int hotspotX, int hotspotY, CBitmapHandle bmp, COLORREF color = CLR_AUTOSELECT)
    {
        EXCLUSIVE( &m_in.m_sync );
        CCursorManager* P = m_GetCursorManager(index);
        if ( P != NULL )
        {
            POINT po = { hotspotX, hotspotY };
            return P->SetImage(bmp, color, po);
        }
        return false;
    }
 
    bool SetCursorImage(INDEX index, CBitmapHandle bmp, COLORREF color = CLR_AUTOSELECT)
    {
        return SetCursorImage(index, 0, 0, bmp, color);
    }
 
    bool SetCursorImage(INDEX index, HCURSOR hCursor, COLORREF color = RGB(255, 0, 255))
    {
        EXCLUSIVE( &m_in.m_sync );
        CCursorManager* P = m_GetCursorManager(index);
        if ( P != NULL )
        {
            CBitmapHandle bmp;
            POINT hotspot;
            if ( m_IconToBitmap(bmp, hotspot, hCursor, color) )
            {
                return P->SetImage(bmp, color, hotspot);
            }
        }
        return false;
    }
 
    bool ShowCursor(INDEX index, bool isShow)
    {
        EXCLUSIVE( &m_in.m_sync );
        CCursorManager* P = m_GetCursorManager(index);
        if ( P != NULL )
        {
            P->Show(isShow);
            return true;
        }
        return false;
    }
 
    bool ClipCursor(INDEX index, const RECT& rect)
    {
        EXCLUSIVE( &m_in.m_sync );
        CCursorManager* P = m_GetCursorManager(index);
        if ( P != NULL )
        {
            P->Clip(rect);
            return true;
        }
        return false;
    }
    
    bool SetCursorPos(INDEX index, int x, int y)
    {
        EXCLUSIVE( &m_in.m_sync );
        CCursorManager* P = m_GetCursorManager(index);
        if ( P != NULL )
        {
            return P->SetPos(x, y);
        }
        return false;
    }
 
    POINT GetCursorPos(INDEX index) const
    {
        EXCLUSIVE( &m_in.m_sync );
        const CCursorManager* P = m_RefCursorManager(index);
        if ( P != NULL )
        {
            return P->GetPos();
        }
        POINT po = { 0, 0 };
        return po;
    }
 
    BYTE GetButtonState(INDEX index) const
    {
        EXCLUSIVE( &m_in.m_sync );
        const CCursorManager* P = m_RefCursorManager(index);
        if ( P != NULL )
        {
            return P->GetButtonState();
        }
        return 0;
    }
 
private:
 
    class CCursorWindow : public CDummyWindow::IListener
    {
    public:
        CCursorWindow(void) : m_rgn(NULL), m_isChild(false)
        {
        }
        ~CCursorWindow(void)
        {
            m_DeleteRgn();
        }
        bool HasCursorImage(void) const
        {
            return ! m_image.IsEmpty();
        }
        bool Create(HWND hParent)
        {
            if ( HasCursorImage() )
            {
                m_isChild = false;
                DWORD style = WS_POPUP;
                HWND hWnd = HWND_TOPMOST;
                if ( hParent != NULL )
                {
                    style = WS_CHILD;
                    hWnd = HWND_TOP;
                    m_isChild = true;
                }
                HWND hFocus = ::GetFocus();
                CStr className = "TNBLIB:MultiMouseMan_";
                if ( m_win.Create(this, NULL, className, style, NULL, hParent) )
                {
                    m_win.ModifyStyleEx(0, WS_EX_TOOLWINDOW | WS_EX_NOACTIVATE | WS_EX_TOPMOST);
                    if ( ! m_isChild )
                    {
                        m_win.ModifyStyleEx(0, WS_EX_LAYERED);
                        ::SetLayeredWindowAttributes(m_win, RGB(0, 0, 0), 0, 0);
                    }
                    ::SetFocus(hFocus);
                    const SIZE& sz = m_image.GetSize();
                    ::SetWindowPos(m_win, hWnd, 0, 0, sz.cx, sz.cy, SWP_NOMOVE | SWP_NOACTIVATE | SWP_ASYNCWINDOWPOS);
                    HRGN rgn = ::CreateRectRgn(0, 0, 0, 0);
                    ::CombineRgn(rgn, m_rgn, NULL, RGN_COPY);
                    ::SetWindowRgn(m_win, rgn, TRUE);
                    Move(0, 0);
                    return true;
                }
                ::SetFocus(hFocus);
            }
            return false;
        }
        void Move(int x, int y)
        {
            if ( ::IsWindow(m_win) )
            {
                HWND hWnd = HWND_TOPMOST;
                UINT flags = SWP_NOSIZE | SWP_NOACTIVATE | SWP_ASYNCWINDOWPOS;
                if ( m_isChild )
                {
                    hWnd = NULL;
                    flags |= SWP_NOZORDER;
                }
                ::SetWindowPos(m_win, hWnd, x - m_hotspot.x, y - m_hotspot.y, 0, 0, flags);
            }
        }
        bool SetImage(CBitmapHandle bmp, COLORREF color, const POINT& hotspot)
        {
            if ( m_image.Set(bmp) )
            {
                m_DeleteRgn();
                m_rgn = m_image.CreateRgn(color);
                m_hotspot = hotspot;
                if ( ::IsWindow(m_win) )
                {
                    const SIZE& sz = m_image.GetSize();
                    ::SetWindowPos(m_win, NULL, 0, 0, sz.cx, sz.cy, SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_ASYNCWINDOWPOS);
                    HRGN rgn = ::CreateRectRgn(0, 0, 0, 0);
                    ::CombineRgn(rgn, m_rgn, NULL, RGN_COPY);
                    ::SetWindowRgn(m_win, rgn, TRUE);
                    ::InvalidateRgn(m_win, m_rgn, TRUE);
                }
                return true;
            }
            return false;
        }
 
        void Show(bool isShow)
        {
            ::ShowWindow(m_win, isShow ? SW_SHOW : SW_HIDE);
        }
 
    protected:
        virtual bool OnWindowMessage(LRESULT& _result, HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
        {
            if ( message == WM_SETFOCUS )
            {
                ::SetFocus(reinterpret_cast<HWND>(wParam));
                return true;
            }
            else if ( message == WM_PAINT )
            {
                PAINTSTRUCT ps;
                HDC dc = ::BeginPaint(hWnd, &ps);
                ::SelectClipRgn(dc, m_rgn);
                m_image.Draw(dc, 0, 0);
                ::EndPaint(hWnd, &ps);
                return true;
            }
            else if ( message == WM_DESTROY )
            {
                m_DeleteRgn();
            }
            return false;
        }
    private:
        void m_DeleteRgn(void)
        {
            if ( m_rgn != NULL )
            {
                _DeleteObject(m_rgn);
                m_rgn = NULL;
            }
        }
        CBitmapImage    m_image;    
        HRGN            m_rgn;      
        POINT           m_hotspot;  
        CDummyWindow    m_win;      
        bool            m_isChild;  
    };
 
    class CCursorManager
    {
    public:
        CCursorManager(void) : m_button(0), m_hRgn(NULL)
        {
            Zero(m_pos);
        }
        bool Create(HWND hParent, CBitmapHandle bmp, COLORREF color, const POINT& hotspot)
        {
            m_button = 0;
            Zero(m_pos);
            if ( m_win.SetImage(bmp, color, hotspot) )
            {
                RECT rc = { 0 };
                if ( hParent != NULL )
                {
                    // 親ウィンドウ指定有り
                    ::GetClientRect(hParent, &rc);
                    Clip(rc);
                }
                else
                {
                    // デスクトップ
                    Clip(rc);
                    ::EnumDisplayMonitors(NULL, NULL, ms_MonitorEnumProc, reinterpret_cast<LPARAM>(this));
                }
                return m_win.Create(hParent);
            }
            return false;
        }
        bool SetImage(CBitmapHandle bmp, COLORREF color, const POINT& hotspot)
        {
            return m_win.SetImage(bmp, color, hotspot);
        }
        void Show(bool isShow)
        {
            m_win.Show(isShow);
        }
        void Clip(const RECT& rect)
        {
            if ( m_hRgn != NULL )
            {
                _DeleteObject(m_hRgn);
            }
            m_hRgn = ::CreateRectRgnIndirect(&rect);
        }
        bool SetPos(int x, int y)
        {
            if ( m_hRgn != NULL && ! ::PtInRegion(m_hRgn, x, y) )
            {
                // 入っていない
                bool r = false;
                if ( ::PtInRegion(m_hRgn, m_pos.x, y) )
                {
                    // X移動しなければ入る
                    int f = (m_pos.x > x) ? 1 : -1;
                    loop ( i, abs(m_pos.x - x) )
                    {
                        x += f;
                        if ( ::PtInRegion(m_hRgn, x, y) )
                        {
                            r = true;
                            break;
                        }
                    }
                }
                else if ( ::PtInRegion(m_hRgn, x, m_pos.y) )
                {
                    // Y移動しなければ入る
                    int f = (m_pos.y > y) ? 1 : -1;
                    loop ( i, abs(m_pos.y - y) )
                    {
                        y += f;
                        if ( ::PtInRegion(m_hRgn, x, y) )
                        {
                            r = true;
                            break;
                        }
                    }
                }
                else
                {
                    // Y移動に移動
                    int f = (m_pos.y > y) ? 1 : -1;
                    loop ( i, abs(m_pos.y - y) )
                    {
                        y += f;
                        if ( ::PtInRegion(m_hRgn, m_pos.x, y) )
                        {
                            break;
                        }
                    }
                    // X移動に移動
                    f = (m_pos.x > x) ? 1 : -1;
                    loop ( i, abs(m_pos.x - x) )
                    {
                        x += f;
                        if ( ::PtInRegion(m_hRgn, x, y) )
                        {
                            r = true;
                            break;
                        }
                    }
                }
                if ( ! r )
                {
                    return false;
                }
            }
            if ( m_pos.x != x || m_pos.y != y )
            {
                m_pos.x = x;
                m_pos.y = y;
                m_win.Move(m_pos.x, m_pos.y);
                return true;
            }
            return false;
        }
        bool MovePos(int dx, int dy)
        {
            return SetPos(m_pos.x + dx, m_pos.y + dy);
        }
        const POINT& GetPos(void) const
        {
            return m_pos;
        }
        BYTE GetButtonState(void) const
        {
            return m_button;
        }
        void SetButtonFlags(WORD buttonFlags)
        {
            loop ( i, 3/*ボタン数*/ * 2 )
            {
                if ( (buttonFlags & _BIT(i)) != 0 )
                {
                    if ( (i & 1) == 0 )
                    {
                        m_button |= _BIT(i / 2);
                    }
                    else
                    {
                        m_button &= ~_BIT(i / 2);
                    }
                }
            }
        }
 
    private:
        static BOOL CALLBACK ms_MonitorEnumProc(
            HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData)
        {
            CCursorManager* P = reinterpret_cast<CCursorManager*>(dwData);
            HRGN& r1 = P->m_hRgn;
            HRGN r2 = ::CreateRectRgnIndirect(lprcMonitor);
            VERIFY( ::CombineRgn(r1, r1, r2, RGN_OR) != ERROR );
            _DeleteObject(r2);
            return TRUE;
        }
        CCursorWindow   m_win;          
        POINT           m_pos;          
        HRGN            m_hRgn;         
        BYTE            m_button;       
    };
 
    class CInner : public IMultiMouseWatcher::IListener
    {
        DEFPARENTLISTENER(CMultiMouseManager, IParentListener);
    public:
        CInner(void) : m_pListener(NULL)
        {
            CBitmapImage bi;
            bi.Set(1, 1);
            m_cursorImage = bi;
        }
        bool CheckIndex(INDEX index)
        {
            if ( ! m_cursores.IsInRange(index) )
            {
                m_cursores.SetSize(index + 1);
            }
            if ( m_cursores[index] == NULL )
            {
                CCursorManager* P = new CCursorManager;
                if ( ! P->Create(m_hParent, m_cursorImage, m_cursorMaskColor, m_cursorHotspot) )
                {
                    _GetLastError("CreateWindow");
                    delete P;
                    return false;
                }
                if ( ! ::IsRectEmpty(&m_corsorRect) )
                {
                    P->Clip(m_corsorRect);
                }
                m_cursores.Set(index, P);
            }
            return true;
        }
        virtual void OnMultiMouseEvent(INDEX index, const RAWMOUSE& mouse)
        {
            EXCLUSIVE( &m_sync );
            if ( m_pListener != NULL )
            {
                m_pListener->OnMultiMouseEvent(index, mouse);
            }
            CCursorManager* P = m_cursores[index];
            if ( P == NULL )
            {
                ASSERT( P != NULL );
                return;
            }
            const POINT& po = P->GetPos();
            P->SetButtonFlags(mouse.usButtonFlags);
            if ( P->MovePos(mouse.lLastX, mouse.lLastY) )
            {
                //変化有り
                if ( m_pListener != NULL )
                {
                    m_pListener->OnMultiMouseMove(index, P->GetButtonState(), po.x, po.y);
                }
            }
            if ( m_pListener != NULL )
            {
                if ( (mouse.usButtonFlags & RI_MOUSE_WHEEL) != 0 )
                {
                    short d = mouse.usButtonData;
                    m_pListener->OnMultiMouseWheel(index, d);
                }
                loop ( i, 3/*ボタン数*/ * 2 )
                {
                    if ( (mouse.usButtonFlags & _BIT(i)) != 0 )
                    {
                        CMultiMouseManager::IListener::EEvent e = CMultiMouseManager::IListener::Event_Down;
                        if ( (i & 1) != 0 )
                        {
                            e = CMultiMouseManager::IListener::Event_Up;
                        }
                        m_pListener->OnMultiMouseButton(index, CMultiMouseManager::IListener::EButton(i / 2), e, po.x, po.y);
                    }
                }
            }
        }
        virtual void OnMultiMouseDevice(INDEX index, EDevice device)
        {
            EXCLUSIVE( &m_sync );
            if ( device == Device_Remove )
            {
                if ( m_pListener != NULL )
                {
                    m_pListener->OnMultiMouseDevice(index, device);
                }
                return;
            }
            if ( ! CheckIndex(index) )
            {
                return;
            }
            if ( m_pListener != NULL )
            {
                m_pListener->OnMultiMouseDevice(index, device);
            }
        }
        IParentListener*                m_pListener;        
        CPointerVectorT<CCursorManager> m_cursores;         
        HWND                            m_hParent;          
        CBitmapHandle                   m_cursorImage;      
        COLORREF                        m_cursorMaskColor;  
        POINT                           m_cursorHotspot;    
        RECT                            m_corsorRect;       
        CSyncSection                    m_sync;
    };  
 
    bool m_IconToBitmap(CBitmapHandle& _bmp, POINT& _hotspot, HCURSOR hCursor, COLORREF color)
    {
        ICONINFO ii;
        if ( ::GetIconInfo(hCursor, &ii) )
        {
            HBITMAP h = ii.hbmColor;
            if ( h == NULL )
            {
                h = ii.hbmMask;
            }
            BITMAP bm;
            if ( ::GetObject(h, sizeof(BITMAP), &bm) > 0 )
            {
                CBitmapImage bi;
                bi.Set(bm.bmWidth, bm.bmHeight, color);
                HDC dc = bi.GetDC();
                ::DrawIconEx(dc, 0, 0, hCursor, 0, 0, 0, NULL, DI_NORMAL);
                bi.ReleaseDC();
                _bmp = bi;
                _hotspot.x = ii.xHotspot;
                _hotspot.y = ii.yHotspot;
                return true;
            }
        }
        return false;
    }
 
    const CCursorManager* m_RefCursorManager(INDEX index) const
    {
        if ( m_in.m_cursores.IsInRange(index) )
        {
            return m_in.m_cursores[index];
        }
        return NULL;
    }
 
    CCursorManager* m_GetCursorManager(INDEX index)
    {
        m_in.CheckIndex(index);
        return m_in.m_cursores[index];
    }
 
    CInner              m_in;       
    IMultiMouseWatcher* m_pWatcher; 
};
 
 
 
}; //TNB