sapi.h

盲人输入法

	ISpeechVoiceStatus(const ISpeechVoiceStatus& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	long GetCurrentStreamNumber();
	long GetLastStreamNumberQueued();
	long GetLastHResult();
	long GetRunningState();
	long GetInputWordPosition();
	long GetInputWordLength();
	long GetInputSentencePosition();
	long GetInputSentenceLength();
	CString GetLastBookmark();
	short GetPhonemeId();
	short GetVisemeId();
};
/////////////////////////////////////////////////////////////////////////////
// _ISpeechVoiceEvents wrapper class

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

// Attributes
public:

// Operations
public:
	void StartStream(long StreamNumber, const VARIANT& StreamPosition);
	void EndStream(long StreamNumber, const VARIANT& StreamPosition);
	void VoiceChange(long StreamNumber, const VARIANT& StreamPosition, LPDISPATCH VoiceObjectToken);
	void Bookmark(long StreamNumber, const VARIANT& StreamPosition, LPCTSTR Bookmark, long BookmarkId);
	void Word(long StreamNumber, const VARIANT& StreamPosition, long CharacterPosition, long Length);
	void Sentence(long StreamNumber, const VARIANT& StreamPosition, long CharacterPosition, long Length);
	void Phoneme(long StreamNumber, const VARIANT& StreamPosition, long Duration, short NextPhoneId, long Feature, short CurrentPhoneId);
	void Viseme(long StreamNumber, const VARIANT& StreamPosition, long Duration, long NextVisemeId, long Feature, long CurrentVisemeId);
	void AudioLevel(long StreamNumber, const VARIANT& StreamPosition, long AudioLevel);
	void EnginePrivate(long StreamNumber, long StreamPosition, const VARIANT& EngineData);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechRecognizer wrapper class

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

// Attributes
public:

// Operations
public:
	void SetRefRecognizer(LPDISPATCH newValue);
	LPDISPATCH GetRecognizer();
	void SetRefAudioInput(LPDISPATCH newValue);
	LPDISPATCH GetAudioInput();
	void SetRefAudioInputStream(LPDISPATCH newValue);
	LPDISPATCH GetAudioInputStream();
	BOOL GetIsShared();
	void SetState(long nNewValue);
	long GetState();
	LPDISPATCH GetStatus();
	void SetRefProfile(LPDISPATCH newValue);
	LPDISPATCH GetProfile();
	void EmulateRecognition(const VARIANT& TextElements, VARIANT* ElementDisplayAttributes, long LanguageId);
	LPDISPATCH CreateRecoContext();
	LPDISPATCH GetFormat(long Type);
	BOOL IsUISupported(LPCTSTR TypeOfUI, VARIANT* ExtraData);
	void DisplayUI(long hWndParent, LPCTSTR Title, LPCTSTR TypeOfUI, VARIANT* ExtraData);
	LPDISPATCH GetRecognizers(LPCTSTR RequiredAttributes, LPCTSTR OptionalAttributes);
	LPDISPATCH GetAudioInputs(LPCTSTR RequiredAttributes, LPCTSTR OptionalAttributes);
	LPDISPATCH GetProfiles(LPCTSTR RequiredAttributes, LPCTSTR OptionalAttributes);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechRecognizerStatus wrapper class

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

// Attributes
public:

// Operations
public:
	LPDISPATCH GetAudioStatus();
	VARIANT GetCurrentStreamPosition();
	long GetCurrentStreamNumber();
	long GetNumberOfActiveRules();
	CString GetClsidEngine();
	VARIANT GetSupportedLanguages();
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechRecoContext wrapper class

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

// Attributes
public:

// Operations
public:
	LPDISPATCH GetRecognizer();
	long GetAudioInputInterferenceStatus();
	CString GetRequestedUIType();
	void SetRefVoice(LPDISPATCH newValue);
	LPDISPATCH GetVoice();
	void SetVoicePurgeEvent(long nNewValue);
	long GetVoicePurgeEvent();
	void SetEventInterests(long nNewValue);
	long GetEventInterests();
	void SetCmdMaxAlternates(long nNewValue);
	long GetCmdMaxAlternates();
	void SetState(long nNewValue);
	long GetState();
	void SetRetainedAudio(long nNewValue);
	long GetRetainedAudio();
	void SetRefRetainedAudioFormat(LPDISPATCH newValue);
	LPDISPATCH GetRetainedAudioFormat();
	void Pause();
	void Resume();
	LPDISPATCH CreateGrammar(const VARIANT& GrammarId);
	LPDISPATCH CreateResultFromMemory(VARIANT* ResultBlock);
	void Bookmark(long Options, const VARIANT& StreamPos, const VARIANT& BookmarkId);
	void SetAdaptationData(LPCTSTR AdaptationString);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechRecoGrammar wrapper class

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

// Attributes
public:

// Operations
public:
	VARIANT GetId();
	LPDISPATCH GetRecoContext();
	void SetState(long nNewValue);
	long GetState();
	LPDISPATCH GetRules();
	void Reset(long NewLanguage);
	void CmdLoadFromFile(LPCTSTR FileName, long LoadOption);
	void CmdLoadFromObject(LPCTSTR ClassId, LPCTSTR GrammarName, long LoadOption);
	void CmdLoadFromResource(long hModule, const VARIANT& ResourceName, const VARIANT& ResourceType, long LanguageId, long LoadOption);
	void CmdLoadFromMemory(const VARIANT& GrammarData, long LoadOption);
	void CmdLoadFromProprietaryGrammar(LPCTSTR ProprietaryGuid, LPCTSTR ProprietaryString, const VARIANT& ProprietaryData, long LoadOption);
	void CmdSetRuleState(LPCTSTR Name, long State);
	void CmdSetRuleIdState(long RuleId, long State);
	void DictationLoad(LPCTSTR TopicName, long LoadOption);
	void DictationUnload();
	void DictationSetState(long State);
	void SetWordSequenceData(LPCTSTR Text, long TextLength, LPDISPATCH Info);
	void SetTextSelection(LPDISPATCH Info);
	long IsPronounceable(LPCTSTR Word);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechGrammarRules wrapper class

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

// Attributes
public:

// Operations
public:
	long GetCount();
	LPDISPATCH FindRule(const VARIANT& RuleNameOrId);
	LPDISPATCH Item(long Index);
	BOOL GetDynamic();
	LPDISPATCH Add(LPCTSTR RuleName, long Attributes, long RuleId);
	void Commit();
	VARIANT CommitAndSave(BSTR* ErrorText);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechGrammarRule wrapper class

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

// Attributes
public:

// Operations
public:
	long GetAttributes();
	LPDISPATCH GetInitialState();
	CString GetName();
	long GetId();
	void Clear();
	void AddResource(LPCTSTR ResourceName, LPCTSTR ResourceValue);
	LPDISPATCH AddState();
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechGrammarRuleState wrapper class

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

// Attributes
public:

// Operations
public:
	LPDISPATCH GetRule();
	LPDISPATCH GetTransitions();
	void AddWordTransition(LPDISPATCH DestState, LPCTSTR Words, LPCTSTR Separators, long Type, LPCTSTR PropertyName, long PropertyId, VARIANT* PropertyValue, float Weight);
	void AddRuleTransition(LPDISPATCH DestinationState, LPDISPATCH Rule, LPCTSTR PropertyName, long PropertyId, VARIANT* PropertyValue, float Weight);
	void AddSpecialTransition(LPDISPATCH DestinationState, long Type, LPCTSTR PropertyName, long PropertyId, VARIANT* PropertyValue, float Weight);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechGrammarRuleStateTransitions wrapper class

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

// Attributes
public:

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

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

// Attributes
public:

// Operations
public:
	long GetType();
	CString GetText();
	LPDISPATCH GetRule();
	VARIANT GetWeight();
	CString GetPropertyName();
	long GetPropertyId();
	VARIANT GetPropertyValue();
	LPDISPATCH GetNextState();
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechTextSelectionInformation wrapper class

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

// Attributes
public:

// Operations
public:
	void SetActiveOffset(long nNewValue);
	long GetActiveOffset();
	void SetActiveLength(long nNewValue);
	long GetActiveLength();
	void SetSelectionOffset(long nNewValue);
	long GetSelectionOffset();
	void SetSelectionLength(long nNewValue);
	long GetSelectionLength();
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechRecoResult wrapper class

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

// Attributes
public:

// Operations
public:
	LPDISPATCH GetRecoContext();
	LPDISPATCH GetTimes();
	void SetRefAudioFormat(LPDISPATCH newValue);
	LPDISPATCH GetAudioFormat();
	LPDISPATCH GetPhraseInfo();
	LPDISPATCH Alternates(long RequestCount, long StartElement, long Elements);
	LPDISPATCH Audio(long StartElement, long Elements);
	long SpeakAudio(long StartElement, long Elements, long Flags);
	VARIANT SaveToMemory();
	void DiscardResultInfo(long ValueTypes);
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechRecoResultTimes wrapper class

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

// Attributes
public:

// Operations
public:
	VARIANT GetStreamTime();
	VARIANT GetLength();
	long GetTickCount();
	VARIANT GetOffsetFromStart();
};
/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseInfo wrapper class

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

// Attributes
public:

// Operations
public:
	long GetLanguageId();
	VARIANT GetGrammarId();
	VARIANT GetStartTime();
	VARIANT GetAudioStreamPosition();
	long GetAudioSizeBytes();
	long GetRetainedSizeBytes();
	long GetAudioSizeTime();
	LPDISPATCH GetRule();
	LPDISPATCH GetProperties();
	LPDISPATCH GetElements();
	LPDISPATCH GetReplacements();
	CString GetEngineId();
	VARIANT GetEnginePrivateData();