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;

};