Subversion Repositories spk

#pragma once

#include "../Overlay.h"

class KeyboardDevice : public IDirectInputDevice8
{
public:
        KeyboardDevice(IDirectInputDevice8* device, COverlay *o) : m_device(device), m_pOverlay(o)//, m_serverPipe(FULL_PIPE_NAME)
        {
                m_pOverlay->SetKeyboardDevice ( 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);

                /*
                You can detect immediate/buffered modes as such:
                
                HRESULT hr = m_device->SetProperty(rguid, ph);

                if(SUCCEEDED(hr) && rguid == DIPROP_BUFFERSIZE)
                {
                        DWORD data = *reinterpret_cast<const DWORD*>(ph + 1);
                        m_is_immediate = (data == 0);
                }

                return hr;
                */
        }

        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);

                if ( m_pOverlay->SetKeyBuffer ( size, (char *)data ) )
                        hr = E_PENDING;

                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->dwData )
                        {
                                if ( m_pOverlay->KeyDown ( (int)d->dwOfs ) )
                                        d->dwData = 0;
                        }
                        else
                                m_pOverlay->KeyReleased ( (int)d->dwOfs );
                }
/*
                if ( m_pOverlay->GetKeyboard () )
                {
                        char data[256];
                        if ( !FAILED (m_device->GetDeviceState(256, data)) )
                        {
                                if ( m_pOverlay->SetKeyBuffer ( 256, data ) )
                                        return DIERR_INPUTLOST;
                        }
                }*/
                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;
//      NamedPipeServer m_serverPipe;
};