TnbRawMouseWatcher.h

[詳解]

#pragma once
#include "TnbMultiMouseManager.h"
#include "TnbDummyWindow.h"
#include "TnbSimpleVector.h"
#include "TnbStr.h"
#include "TnbVector.h"
#include "TnbWindowsVersion.h"
#include <dbt.h>
 
 
 
//TNB Library
namespace TNB
{
 
 
 
#ifndef _TnbDOXYGEN //Document作成用シンボル
_SELECTANY HHOOK s_hTnbRmwLowMouse = NULL;
#endif
 
 
 
class CRawMouseWatcher : public IMultiMouseWatcher
{
    DEFSUPER(IMultiMouseWatcher);
public:
 
    CRawMouseWatcher(void)
    {
        Refresh();
    }
 
    virtual void SetListener(IMultiMouseWatcher::IListener* P)
    {
        m_in.m_pListener = P;
    }
 
    virtual size_t GetMouseCount(void) const
    {
        return m_in.m_devsList.GetSize();
    }
 
    virtual bool Start(void)
    {
        Stop();
        if ( m_win.Create(&m_in) )
        {
            RAWINPUTDEVICE rid;
            rid.usUsagePage = 1/*HID_USAGE_PAGE_GENERIC*/; 
            rid.usUsage = 2/*HID_USAGE_GENERIC_MOUSE*/; 
            rid.dwFlags = RIDEV_INPUTSINK;
            rid.hwndTarget = m_win;
            if ( ::RegisterRawInputDevices(&rid, 1, sizeof(rid)) )
            {
                return true;
            }
        }
        Stop();
        return false;
    }
 
    virtual void Stop(void)
    {
        m_win.Destroy();
    }
 
    bool GetMouseSpecified(RID_DEVICE_INFO_MOUSE& _spec, INDEX index) const
    {
        if ( GetMouseCount() > index )
        {
            _spec = m_in.m_devsList[index].specified;
            return true;
        }
        return false;
    }
 
    CStr GetMouseName(INDEX index) const
    {
        if ( GetMouseCount() > index )
        {
            return m_in.m_devsList[index].name;
        }
        return _T("");
    }
 
    bool Refresh(void)
    {
        return m_in.Refresh();
    }
 
    static bool EnableMouseCursor(bool isEnable)
    {
        if ( ! isEnable )
        {
            //無効へ
            if ( s_hTnbRmwLowMouse == NULL )
            {
                s_hTnbRmwLowMouse = ::SetWindowsHookEx(WH_MOUSE_LL, ms_OnLowLevelMouseProc, GetInstanceHandleByTnb(), 0);
            }
            return s_hTnbRmwLowMouse != NULL;
        }
        // 有効へ
        if ( s_hTnbRmwLowMouse != NULL ) 
        {
            ::UnhookWindowsHookEx(s_hTnbRmwLowMouse);
            s_hTnbRmwLowMouse = NULL;
        }
        return s_hTnbRmwLowMouse == NULL;
    }
 
    static void MouseEvent(DWORD flags, DWORD dx = 0,DWORD dy = 0, DWORD data = 0)
    {
        ::mouse_event(flags, dx, dy, data, COOKIE);
    }
 
    static void HorizontalWheelEvent(int delta)
    {
        //CWindowsVersion wv;   @todo VISTA でも HWHEEL メッセージに対応していないウィンドウが多い・・・。
        //if ( wv.GetMajorVersion() >= 6 )
        //{
        //  MouseEvent(0x1000/*MOUSEEVENTF_HWHEEL*/, 0, 0, delta);
        //  return;
        //}
        // 現在のフォアグラウンドのウィンドウ取得
        HWND hWnd = ::GetForegroundWindow();
        TTRACE1("GetForegroundWindow = %08X\n", hWnd);
        // アクティブなウインドウのスレッドIDを取得する
        DWORD dwCurrentThreadId = ::GetCurrentThreadId();
        DWORD dwActiveProcessId;
        DWORD dwActiveThreadId = ::GetWindowThreadProcessId(hWnd, &dwActiveProcessId);
        if ( ::AttachThreadInput(dwCurrentThreadId, dwActiveThreadId, TRUE) )
        {
            hWnd = ::GetFocus();
            if ( hWnd != NULL )
            {   
                LONG style = ::GetWindowLong(hWnd, GWL_STYLE);
                bool hasScrollBar = (style & WS_HSCROLL) != 0;
                #ifdef _DEBUG
                    CStr s;
                    ::GetClassName(hWnd, s.GetBuffer(100), 100);
                    s.ReleaseBuffer();
                    TTRACE3(" GetFocus = %08X %d, [%s]\n", hWnd, hasScrollBar, s);
                #endif
                bool isDisp = false;
                if ( ! hasScrollBar )
                {
                    // memo; WORD は兄弟に ScrollBar がある。
                    isDisp = ms_SubWheel(hWnd, delta);
                    if ( ! isDisp )
                    {
                        // memo; EXCEL は一個下に ScrollBar がある。
                        HWND h = ::GetWindow(hWnd, GW_CHILD);
                        isDisp = ms_SubWheel(h, delta);
                    }
                }
                if ( ! isDisp )
                {
                    ms_PostWheel(hWnd, NULL, delta);
                }
            }
            // 開放する
            ::AttachThreadInput(dwCurrentThreadId, dwActiveThreadId, FALSE);
        }
    }
 
private:
 
    enum
    {
        COOKIE = 'TbMm' 
    };
 
    struct TInfo : TNB::IComparableT<TInfo>
    {
        HANDLE                  handle;     
        CStr                    name;       
        RID_DEVICE_INFO_MOUSE   specified;  
        TInfo(void) : handle(INVALID_HANDLE_VALUE)
        {
        }
        virtual INT_PTR Compare(const TInfo& t) const
        {
            return name.Compare(t.name);
        }
    };
    class CInner : public CDummyWindow::IListener
    {
        DEFPARENTLISTENER(IMultiMouseWatcher, IParentListener);
    public:
        CInner(void) : m_pListener(NULL), m_lastHandle(INVALID_HANDLE_VALUE)
        {
        }
        virtual bool OnWindowMessage(LRESULT& _result, HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
        {
            if ( m_pListener != NULL )
            {
                if ( message == WM_DEVICECHANGE && wParam == DBT_DEVNODES_CHANGED )
                {
                    CVectorT<TInfo> newInf;
                    if ( Collect(newInf) )
                    {
                        loop ( i, m_devsList )
                        {
                            INDEX idx = newInf.Find(m_devsList[i]);
                            if ( idx != INVALID_INDEX )
                            {
                                // 再発見された
                                if ( m_devsList[i].handle == INVALID_HANDLE_VALUE )
                                {
                                    m_devsList[i] = newInf[idx];
                                    m_pListener->OnMultiMouseDevice(i, _super::IListener::Device_Reconnect);
                                }
                            }
                            else
                            {
                                // 無くなった
                                if ( m_devsList[i].handle != INVALID_HANDLE_VALUE )
                                {
                                    m_devsList[i].handle = INVALID_HANDLE_VALUE;
                                    m_pListener->OnMultiMouseDevice(i, _super::IListener::Device_Remove);
                                }
                            }
                        }
                        loop ( i, newInf )
                        {
                            INDEX idx = m_devsList.Find(newInf[i]);
                            if ( idx == INVALID_INDEX )
                            {
                                // 新規発見
                                int x = m_devsList.Add(newInf[i]);
                                m_pListener->OnMultiMouseDevice(x, _super::IListener::Device_Connect);
                            }
                        }
                    }
                }
                else if ( message == WM_INPUT )
                {
                    UINT size = 40;
                    CWorkMem w(size);
                    ::GetRawInputData(reinterpret_cast<HRAWINPUT>(lParam), RID_INPUT, w, &size, sizeof(RAWINPUTHEADER));
                    RAWINPUT* P = reinterpret_cast<RAWINPUT*>(w.Ref());
                    if ( P->header.dwType == RIM_TYPEMOUSE )
                    {
                        INDEX idx = INVALID_INDEX;
                        if ( m_lastHandle == P->header.hDevice )
                        {
                            idx = m_lastIndex;
                        }
                        else
                        {
                            loop ( i, m_devsList.GetSize() )
                            {
                                if ( m_devsList[i].handle == P->header.hDevice )
                                {
                                    idx = i;
                                    m_lastHandle = P->header.hDevice;
                                    m_lastIndex = idx;
                                    break;
                                }
                            }
                        }
                        if ( idx != INVALID_INDEX )
                        {
                            m_pListener->OnMultiMouseEvent(idx, P->data.mouse);
                        }
                    } 
                }
            }
            return false;
        }
        bool Refresh(void)
        {
            m_lastHandle = INVALID_HANDLE_VALUE;
            return Collect(m_devsList);
        }
        bool Collect(CVectorT<TInfo>& _info)
        {
            _info.RemoveAll();
            UINT count = 0;
            UINT rr = ::GetRawInputDeviceList(NULL, &count, sizeof(RAWINPUTDEVICELIST));
            if ( rr != 0 )
            {
                return false;
            }
            UINT d1 = count;
            CWorkMemT<RAWINPUTDEVICELIST> devs(count);
            UINT d2 = ::GetRawInputDeviceList(devs, &count, sizeof(RAWINPUTDEVICELIST));
            if ( d1 != d2 )
            {
                return false;
            }
            loop ( i, devs.GetSize() )
            {
                if ( devs[i].dwType != RIM_TYPEMOUSE )
                {
                    continue;
                }
                TInfo info;
                info.handle = devs[i].hDevice;
                // スペック取得
                RID_DEVICE_INFO dev;
                UINT size = sizeof(RID_DEVICE_INFO);
                if ( ::GetRawInputDeviceInfo(info.handle, RIDI_DEVICEINFO, &dev, &size) > 0 )
                {
                    info.specified = dev.mouse;
                    // デバイス名の長さ取得
                    if ( ::GetRawInputDeviceInfo(info.handle, RIDI_DEVICENAME, NULL, &size) == 0 )
                    {
                        // デバイス名取得
                        CWorkMemT<TCHAR> name(size + 1);
                        int r = ::GetRawInputDeviceInfo(info.handle, RIDI_DEVICENAME, name, &size);
                        if ( r > 0 )
                        {
                            info.name = name.Ref();
                        }
                    }
                    _info.Add(info);
                }
            }
            return true;
        }
        IParentListener*        m_pListener;    
        CVectorT<TInfo>         m_devsList;     
        mutable HANDLE          m_lastHandle;   
        mutable INDEX           m_lastIndex;    
    };
    static LRESULT CALLBACK ms_OnLowLevelMouseProc(int nCode, WPARAM wParam, LPARAM lParam)
    {
        if ( nCode == HC_ACTION )
        {
            MSLLHOOKSTRUCT* P = reinterpret_cast<MSLLHOOKSTRUCT*>(lParam);
            TTRACE3("OnLowLevelMouseProc msg=0x%X, x=%d, y=%d\n", wParam, P->pt.x, P->pt.y);
            TTRACE3("         data=%d, flags=0x%X, ex-info=%d\n", P->mouseData, P->flags, P->dwExtraInfo);
            if ( P->dwExtraInfo != COOKIE )
            {
                return 1;
            }
        } 
        return ::CallNextHookEx(s_hTnbRmwLowMouse, nCode, wParam, lParam);
    }
    // CLASS 名チェック
    static bool ms_IsScrollBar(LPCTSTR P)
    {
        const TCHAR src[] = _T("ScrollBar");
        loop ( i, sizeof(src) )
        {
            if ( src[i] != P[i] )
            {
                return false;
            }
        }
        return true;
    }
    // 送信
    static void ms_PostWheel(HWND hTargetWnd, HWND hCtrlWnd, int delta)
    {
        UINT msg = WM_HSCROLL;
        WPARAM wp = (delta < 0) ? SB_LINELEFT : SB_LINERIGHT;
        LPARAM lp = reinterpret_cast<LPARAM>(hCtrlWnd);
        int l = ((delta < 0) ? -delta : delta) / WHEEL_DELTA;
        loop ( i, l )
        {
            ::PostMessage(hTargetWnd, msg, wp, lp);
        }
        ::PostMessage(hTargetWnd, msg, SB_ENDSCROLL, lp);
    }
    // サブ
    static bool ms_SubWheel(HWND hWnd, int delta)
    {
        CWorkMemT<TCHAR> buf(100);
        HWND h = ::GetWindow(hWnd, GW_HWNDNEXT);
        while ( h != NULL )
        {
            ::GetClassName(h, buf, 100);
            LONG style = ::GetWindowLong(h, GWL_STYLE);
            bool isVisible = (style & WS_VISIBLE) != 0;
            bool isHorz = (style & (SBS_VERT | SBS_SIZEBOX)) == 0;
            if ( ms_IsScrollBar(buf) && isVisible && isHorz )
            {
                TTRACE2(" Found ScrollBar = %08X, [%s]\n", h, buf.Ref());
                HWND h2 = ::GetParent(h);
                if ( h2 != NULL )
                {
                    // 親に通知
                    ms_PostWheel(h2, h, delta);
                    return true;
                }
            }
            h = ::GetWindow(h, GW_HWNDNEXT);
        }
        return false;
    }
    CInner          m_in;                       
    CDummyWindow    m_win;                      
};
 
 
 
}; //TNB