sapi.h

盲人输入法

// Machine generated IDispatch wrapper class(es) created with ClassWizard
/////////////////////////////////////////////////////////////////////////////
// ISpeechDataKey wrapper class

class ISpeechDataKey : public COleDispatchDriver
{
public:
	ISpeechDataKey() {}		// Calls COleDispatchDriver default constructor
	ISpeechDataKey(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechDataKey(const ISpeechDataKey& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	void SetBinaryValue(LPCTSTR ValueName, const VARIANT& Value);
	VARIANT GetBinaryValue(LPCTSTR ValueName);
	void SetStringValue(LPCTSTR ValueName, LPCTSTR Value);
	CString GetStringValue(LPCTSTR ValueName);
	void SetLongValue(LPCTSTR ValueName, long Value);
	long GetLongValue(LPCTSTR ValueName);
	LPDISPATCH OpenKey(LPCTSTR SubKeyName);
	LPDISPATCH CreateKey(LPCTSTR SubKeyName);
	void DeleteKey(LPCTSTR SubKeyName);
	void DeleteValue(LPCTSTR ValueName);
	CString EnumKeys(long Index);
	CString EnumValues(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechObjectToken wrapper class

class ISpeechObjectToken : public COleDispatchDriver
{
public:
	ISpeechObjectToken() {}		// Calls COleDispatchDriver default constructor
	ISpeechObjectToken(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechObjectToken(const ISpeechObjectToken& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	CString GetId();
	LPDISPATCH GetCategory();
	CString GetDescription(long Locale);
	CString GetAttribute(LPCTSTR AttributeName);
	LPUNKNOWN CreateInstance(LPUNKNOWN pUnkOuter, long ClsContext);
	BOOL MatchesAttributes(LPCTSTR Attributes);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechObjectTokenCategory wrapper class

class ISpeechObjectTokenCategory : public COleDispatchDriver
{
public:
	ISpeechObjectTokenCategory() {}		// Calls COleDispatchDriver default constructor
	ISpeechObjectTokenCategory(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechObjectTokenCategory(const ISpeechObjectTokenCategory& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	CString GetId();
	void SetDefault(LPCTSTR lpszNewValue);
	CString GetDefault();
	void SetId(LPCTSTR Id, BOOL CreateIfNotExist);
	LPDISPATCH EnumerateTokens(LPCTSTR RequiredAttributes, LPCTSTR OptionalAttributes);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechObjectTokens wrapper class

class ISpeechObjectTokens : public COleDispatchDriver
{
public:
	ISpeechObjectTokens() {}		// Calls COleDispatchDriver default constructor
	ISpeechObjectTokens(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechObjectTokens(const ISpeechObjectTokens& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	long GetCount();
	LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechAudioBufferInfo wrapper class

class ISpeechAudioBufferInfo : public COleDispatchDriver
{
public:
	ISpeechAudioBufferInfo() {}		// Calls COleDispatchDriver default constructor
	ISpeechAudioBufferInfo(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechAudioBufferInfo(const ISpeechAudioBufferInfo& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	long GetMinNotification();
	void SetMinNotification(long nNewValue);
	long GetBufferSize();
	void SetBufferSize(long nNewValue);
	long GetEventBias();
	void SetEventBias(long nNewValue);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechAudioStatus wrapper class

class ISpeechAudioStatus : public COleDispatchDriver
{
public:
	ISpeechAudioStatus() {}		// Calls COleDispatchDriver default constructor
	ISpeechAudioStatus(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechAudioStatus(const ISpeechAudioStatus& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	long GetFreeBufferSpace();
	long GetNonBlockingIO();
	long GetState();
	VARIANT GetCurrentSeekPosition();
	VARIANT GetCurrentDevicePosition();
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechAudioFormat wrapper class

class ISpeechAudioFormat : public COleDispatchDriver
{
public:
	ISpeechAudioFormat() {}		// Calls COleDispatchDriver default constructor
	ISpeechAudioFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechAudioFormat(const ISpeechAudioFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	long GetType();
	void SetType(long nNewValue);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechWaveFormatEx wrapper class

class ISpeechWaveFormatEx : public COleDispatchDriver
{
public:
	ISpeechWaveFormatEx() {}		// Calls COleDispatchDriver default constructor
	ISpeechWaveFormatEx(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechWaveFormatEx(const ISpeechWaveFormatEx& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	short GetFormatTag();
	void SetFormatTag(short nNewValue);
	short GetChannels();
	void SetChannels(short nNewValue);
	long GetSamplesPerSec();
	void SetSamplesPerSec(long nNewValue);
	long GetAvgBytesPerSec();
	void SetAvgBytesPerSec(long nNewValue);
	short GetBlockAlign();
	void SetBlockAlign(short nNewValue);
	short GetBitsPerSample();
	void SetBitsPerSample(short nNewValue);
	VARIANT GetExtraData();
	void SetExtraData(const VARIANT& newValue);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechBaseStream wrapper class

class ISpeechBaseStream : public COleDispatchDriver
{
public:
	ISpeechBaseStream() {}		// Calls COleDispatchDriver default constructor
	ISpeechBaseStream(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechBaseStream(const ISpeechBaseStream& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetFormat();
	void SetRefFormat(LPDISPATCH newValue);
	long Read(VARIANT* Buffer, long NumberOfBytes);
	long Write(const VARIANT& Buffer);
	VARIANT Seek(const VARIANT& Position, long Origin);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechFileStream wrapper class

class ISpeechFileStream : public COleDispatchDriver
{
public:
	ISpeechFileStream() {}		// Calls COleDispatchDriver default constructor
	ISpeechFileStream(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechFileStream(const ISpeechFileStream& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetFormat();
	void SetRefFormat(LPDISPATCH newValue);
	long Read(VARIANT* Buffer, long NumberOfBytes);
	long Write(const VARIANT& Buffer);
	VARIANT Seek(const VARIANT& Position, long Origin);
	void Open(LPCTSTR FileName, long FileMode, BOOL DoEvents);
	void Close();
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechMemoryStream wrapper class

class ISpeechMemoryStream : public COleDispatchDriver
{
public:
	ISpeechMemoryStream() {}		// Calls COleDispatchDriver default constructor
	ISpeechMemoryStream(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechMemoryStream(const ISpeechMemoryStream& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetFormat();
	void SetRefFormat(LPDISPATCH newValue);
	long Read(VARIANT* Buffer, long NumberOfBytes);
	long Write(const VARIANT& Buffer);
	VARIANT Seek(const VARIANT& Position, long Origin);
	void SetData(const VARIANT& Data);
	VARIANT GetData();
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechCustomStream wrapper class

class ISpeechCustomStream : public COleDispatchDriver
{
public:
	ISpeechCustomStream() {}		// Calls COleDispatchDriver default constructor
	ISpeechCustomStream(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechCustomStream(const ISpeechCustomStream& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetFormat();
	void SetRefFormat(LPDISPATCH newValue);
	long Read(VARIANT* Buffer, long NumberOfBytes);
	long Write(const VARIANT& Buffer);
	VARIANT Seek(const VARIANT& Position, long Origin);
	LPUNKNOWN GetBaseStream();
	void SetRefBaseStream(LPUNKNOWN newValue);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechAudio wrapper class

class ISpeechAudio : public COleDispatchDriver
{
public:
	ISpeechAudio() {}		// Calls COleDispatchDriver default constructor
	ISpeechAudio(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechAudio(const ISpeechAudio& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetFormat();
	void SetRefFormat(LPDISPATCH newValue);
	long Read(VARIANT* Buffer, long NumberOfBytes);
	long Write(const VARIANT& Buffer);
	VARIANT Seek(const VARIANT& Position, long Origin);
	LPDISPATCH GetStatus();
	LPDISPATCH GetBufferInfo();
	LPDISPATCH GetDefaultFormat();
	long GetVolume();
	void SetVolume(long nNewValue);
	long GetBufferNotifySize();
	void SetBufferNotifySize(long nNewValue);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechMMSysAudio wrapper class

class ISpeechMMSysAudio : public COleDispatchDriver
{
public:
	ISpeechMMSysAudio() {}		// Calls COleDispatchDriver default constructor
	ISpeechMMSysAudio(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechMMSysAudio(const ISpeechMMSysAudio& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetFormat();
	void SetRefFormat(LPDISPATCH newValue);
	long Read(VARIANT* Buffer, long NumberOfBytes);
	long Write(const VARIANT& Buffer);
	VARIANT Seek(const VARIANT& Position, long Origin);
	LPDISPATCH GetStatus();
	LPDISPATCH GetBufferInfo();
	LPDISPATCH GetDefaultFormat();
	long GetVolume();
	void SetVolume(long nNewValue);
	long GetBufferNotifySize();
	void SetBufferNotifySize(long nNewValue);
	long GetDeviceId();
	void SetDeviceId(long nNewValue);
	long GetLineId();
	void SetLineId(long nNewValue);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechVoice wrapper class

class ISpeechVoice : public COleDispatchDriver
{
public:
	ISpeechVoice() {}		// Calls COleDispatchDriver default constructor
	ISpeechVoice(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISpeechVoice(const ISpeechVoice& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetStatus();
	LPDISPATCH GetVoice();
	void SetRefVoice(LPDISPATCH newValue);
	LPDISPATCH GetAudioOutput();
	void SetRefAudioOutput(LPDISPATCH newValue);
	LPDISPATCH GetAudioOutputStream();
	void SetRefAudioOutputStream(LPDISPATCH newValue);
	long GetRate();
	void SetRate(long nNewValue);
	long GetVolume();
	void SetVolume(long nNewValue);
	long GetEventInterests();
	void SetEventInterests(long nNewValue);
	void SetPriority(long nNewValue);
	long GetPriority();
	void SetAlertBoundary(long nNewValue);
	long GetAlertBoundary();
	void SetSynchronousSpeakTimeout(long nNewValue);
	long GetSynchronousSpeakTimeout();
	long Speak(LPCTSTR Text, long Flags);
	long SpeakStream(LPDISPATCH Stream, long Flags);
	void Pause();
	void Resume();
	long Skip(LPCTSTR Type, long NumItems);
	LPDISPATCH GetVoices(LPCTSTR RequiredAttributes, LPCTSTR OptionalAttributes);
	LPDISPATCH GetAudioOutputs(LPCTSTR RequiredAttributes, LPCTSTR OptionalAttributes);
	BOOL WaitUntilDone(long msTimeout);
	BOOL IsUISupported(LPCTSTR TypeOfUI, VARIANT* ExtraData);
	void DisplayUI(long hWndParent, LPCTSTR Title, LPCTSTR TypeOfUI, VARIANT* ExtraData);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechVoiceStatus wrapper class

class ISpeechVoiceStatus : public COleDispatchDriver
{
public:
	ISpeechVoiceStatus() {}		// Calls COleDispatchDriver default constructor
	ISpeechVoiceStatus(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}