Subversion Repositories spk

#pragma once

#include "../Overlay.h"

class MouseDevice : public IDirectInputDevice8
{
public:
        MouseDevice (IDirectInputDevice8* device, COverlay *o) : m_device(device), m_pOverlay(o)
        {
                m_pOverlay->SetMouseDevice ( device );
        }

        /*** IUnknown methods ***/
        STDMETHOD(QueryInterface)(REFIID riid, void** ppvObj)
        {
                return m_device->QueryInterface(riid, ppvObj);
        }

        STDMETHOD_(ULONG,AddRef)()
        {
                return m_device->AddRef();
        }

        STDMETHOD_(ULONG,Release)()
        {
                ULONG count = m_device->Release();
                if(0 == count)
                        delete this;

                return count;
        }

        /*** IDirectInputDevice8 methods ***/
        STDMETHOD(GetCapabilities)(LPDIDEVCAPS devCaps)
        {
                return m_device->GetCapabilities(devCaps);
        }

        STDMETHOD(EnumObjects)(LPDIENUMDEVICEOBJECTSCALLBACK callback, LPVOID ref, DWORD flags) 
        {
                return m_device->EnumObjects(callback, ref, flags);
        }

        STDMETHOD(GetProperty)(REFGUID rguid, LPDIPROPHEADER ph)
        {
                return m_device->GetProperty(rguid, ph);
        }

        STDMETHOD(SetProperty)(REFGUID rguid, LPCDIPROPHEADER ph)
        {
                return m_device->SetProperty(rguid, ph);
        }

        STDMETHOD(Acquire)()
        {
                return m_device->Acquire();
        }

        STDMETHOD(Unacquire)()
        {
                return m_device->Unacquire();
        }

        STDMETHOD(GetDeviceState)(DWORD size, LPVOID data)
        {
                HRESULT hr = m_device->GetDeviceState(size, data);

                return hr;
        }

        STDMETHOD(GetDeviceData)(DWORD size, LPDIDEVICEOBJECTDATA data, LPDWORD numElements, DWORD flags)
        {
                HRESULT hr = m_device->GetDeviceData(size, data, numElements, flags);

                for ( unsigned int i = 0; i < *numElements; i++ )
                {
                        DIDEVICEOBJECTDATA *d = &data[i];
                        if ( d->dwOfs == DIMOFS_X )
                        {
                                m_pOverlay->MoveMouseX ( (int)d->dwData );
                                if ( m_pOverlay->HaltMouse() )
                                        d->dwData = 0;
                        }
                        else if ( d->dwOfs == DIMOFS_Y )
                        {
                                m_pOverlay->MoveMouseY ( (int)d->dwData );
                                if ( m_pOverlay->HaltMouse() )
                                        d->dwData = 0;
                        }
                        else if ( d->dwOfs == DIMOFS_BUTTON0 )
                        {
                                if ( d->dwData )
                                {
                                        if ( (m_pOverlay->MouseClick ( 0 )) || (m_pOverlay->HaltMouse()) )
                                                d->dwData = 0;
                                }
                                else
                                        m_pOverlay->MouseRelease ( 0 );
                        }
                        else if ( d->dwOfs == DIMOFS_BUTTON1 )
                        {
                                if ( d->dwData )
                                {
                                        if ( (m_pOverlay->MouseClick ( 1 )) || (m_pOverlay->HaltMouse()) )
                                                d->dwData = 0;
                                }
                                else
                                        m_pOverlay->MouseRelease ( 1 );
                        }
                        else if ( d->dwOfs == DIMOFS_BUTTON2 )
                                m_pOverlay->MouseClick ( 2 );
                        else if ( d->dwOfs == DIMOFS_BUTTON3 )
                                m_pOverlay->MouseClick ( 3 );
                        else if ( d->dwOfs == DIMOFS_BUTTON4 )
                                m_pOverlay->MouseClick ( 4 );
                        else if ( d->dwOfs == DIMOFS_BUTTON5 )
                                m_pOverlay->MouseClick ( 5 );
                        else if ( d->dwOfs == DIMOFS_BUTTON6 )
                                m_pOverlay->MouseClick ( 6 );
                        else if ( d->dwOfs == DIMOFS_BUTTON7 )
                                m_pOverlay->MouseClick ( 7 );
                }

                return hr;
        }

        STDMETHOD(SetDataFormat)(LPCDIDATAFORMAT df)
        {
                return m_device->SetDataFormat(df);
        }

        STDMETHOD(SetEventNotification)(HANDLE event)
        {
                return m_device->SetEventNotification(event);
        }

        STDMETHOD(SetCooperativeLevel)(HWND window, DWORD level)
        {
                return m_device->SetCooperativeLevel(window, level);
        }

        STDMETHOD(GetObjectInfo)(LPDIDEVICEOBJECTINSTANCE object, DWORD objId, DWORD objHow)
        {
                return m_device->GetObjectInfo(object, objId, objHow);
        }

        STDMETHOD(GetDeviceInfo)(LPDIDEVICEINSTANCE di)
        {
                return m_device->GetDeviceInfo(di);
        }

        STDMETHOD(RunControlPanel)(HWND owner, DWORD flags)
        {
                return m_device->RunControlPanel(owner, flags);
        }

        STDMETHOD(Initialize)(HINSTANCE instance, DWORD version, REFGUID rguid)
        {
                return m_device->Initialize(instance, version, rguid);
        }

        STDMETHOD(CreateEffect)(REFGUID rguid, LPCDIEFFECT effect_params, LPDIRECTINPUTEFFECT* effect, LPUNKNOWN unknown)
        {
                return m_device->CreateEffect(rguid, effect_params, effect, unknown);
        }

    STDMETHOD(EnumEffects)(LPDIENUMEFFECTSCALLBACK callback, LPVOID ref, DWORD type)
        {
                return m_device->EnumEffects(callback, ref, type);
        }

    STDMETHOD(GetEffectInfo)(LPDIEFFECTINFO effect_info, REFGUID rguid)
        {
                return m_device->GetEffectInfo(effect_info, rguid);
        }

    STDMETHOD(GetForceFeedbackState)(LPDWORD state)
        {
                return m_device->GetForceFeedbackState(state);
        }

    STDMETHOD(SendForceFeedbackCommand)(DWORD flags)
        {
                return m_device->SendForceFeedbackCommand(flags);
        }

    STDMETHOD(EnumCreatedEffectObjects)(LPDIENUMCREATEDEFFECTOBJECTSCALLBACK callback, LPVOID ref, DWORD flags)
        {
                return m_device->EnumCreatedEffectObjects(callback, ref, flags);
        }

    STDMETHOD(Escape)(LPDIEFFESCAPE escape)
        {
                return m_device->Escape(escape);
        }

    STDMETHOD(Poll)()
        {
                return m_device->Poll();
        }

        STDMETHOD(SendDeviceData)(DWORD size, LPCDIDEVICEOBJECTDATA data, LPDWORD num_elements, DWORD flags)
        {
                return m_device->SendDeviceData(size, data, num_elements, flags);
        }

        STDMETHOD(EnumEffectsInFile)(LPCTSTR file_name, LPDIENUMEFFECTSINFILECALLBACK callback, LPVOID ref, DWORD flags)
        {
                return m_device->EnumEffectsInFile(file_name, callback, ref, flags);
        }

    STDMETHOD(WriteEffectToFile)(LPCTSTR file_name, DWORD num_entries, LPDIFILEEFFECT effects, DWORD flags)
        {
                return m_device->WriteEffectToFile(file_name, num_entries, effects, flags);
        }

    STDMETHOD(BuildActionMap)(LPDIACTIONFORMAT format, LPCTSTR username, DWORD flags)
        {
                return m_device->BuildActionMap(format, username, flags);
        }

    STDMETHOD(SetActionMap)(LPDIACTIONFORMAT format, LPCTSTR username, DWORD flags)
        {
                return m_device->SetActionMap(format, username, flags);
        }

    STDMETHOD(GetImageInfo)(LPDIDEVICEIMAGEINFOHEADER image_header)
        {
                return m_device->GetImageInfo(image_header);
        }

private:
        IDirectInputDevice8* m_device;  
        COverlay *m_pOverlay;
};