sapi.cpp

盲人输入法

	static BYTE parms[] =
		VTS_BSTR VTS_BSTR;
	InvokeHelper(0x13, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		RequiredAttributes, OptionalAttributes);
	return result;
}

LPDISPATCH ISpeechRecognizer::GetProfiles(LPCTSTR RequiredAttributes, LPCTSTR OptionalAttributes)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR;
	InvokeHelper(0x14, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		RequiredAttributes, OptionalAttributes);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechRecognizerStatus properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechRecognizerStatus operations

LPDISPATCH ISpeechRecognizerStatus::GetAudioStatus()
{
	LPDISPATCH result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

VARIANT ISpeechRecognizerStatus::GetCurrentStreamPosition()
{
	VARIANT result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
	return result;
}

long ISpeechRecognizerStatus::GetCurrentStreamNumber()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long ISpeechRecognizerStatus::GetNumberOfActiveRules()
{
	long result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

CString ISpeechRecognizerStatus::GetClsidEngine()
{
	CString result;
	InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

VARIANT ISpeechRecognizerStatus::GetSupportedLanguages()
{
	VARIANT result;
	InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechRecoContext properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechRecoContext operations

LPDISPATCH ISpeechRecoContext::GetRecognizer()
{
	LPDISPATCH result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

long ISpeechRecoContext::GetAudioInputInterferenceStatus()
{
	long result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

CString ISpeechRecoContext::GetRequestedUIType()
{
	CString result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

void ISpeechRecoContext::SetRefVoice(LPDISPATCH newValue)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x4, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
		 newValue);
}

LPDISPATCH ISpeechRecoContext::GetVoice()
{
	LPDISPATCH result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

void ISpeechRecoContext::SetVoicePurgeEvent(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long ISpeechRecoContext::GetVoicePurgeEvent()
{
	long result;
	InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechRecoContext::SetEventInterests(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long ISpeechRecoContext::GetEventInterests()
{
	long result;
	InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechRecoContext::SetCmdMaxAlternates(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long ISpeechRecoContext::GetCmdMaxAlternates()
{
	long result;
	InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechRecoContext::SetState(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long ISpeechRecoContext::GetState()
{
	long result;
	InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechRecoContext::SetRetainedAudio(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long ISpeechRecoContext::GetRetainedAudio()
{
	long result;
	InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechRecoContext::SetRefRetainedAudioFormat(LPDISPATCH newValue)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0xb, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
		 newValue);
}

LPDISPATCH ISpeechRecoContext::GetRetainedAudioFormat()
{
	LPDISPATCH result;
	InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

void ISpeechRecoContext::Pause()
{
	InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ISpeechRecoContext::Resume()
{
	InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH ISpeechRecoContext::CreateGrammar(const VARIANT& GrammarId)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0xe, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&GrammarId);
	return result;
}

LPDISPATCH ISpeechRecoContext::CreateResultFromMemory(VARIANT* ResultBlock)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_PVARIANT;
	InvokeHelper(0xf, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		ResultBlock);
	return result;
}

void ISpeechRecoContext::Bookmark(long Options, const VARIANT& StreamPos, const VARIANT& BookmarkId)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Options, &StreamPos, &BookmarkId);
}

void ISpeechRecoContext::SetAdaptationData(LPCTSTR AdaptationString)
{
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 AdaptationString);
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechRecoGrammar properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechRecoGrammar operations

VARIANT ISpeechRecoGrammar::GetId()
{
	VARIANT result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechRecoGrammar::GetRecoContext()
{
	LPDISPATCH result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

void ISpeechRecoGrammar::SetState(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long ISpeechRecoGrammar::GetState()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechRecoGrammar::GetRules()
{
	LPDISPATCH result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

void ISpeechRecoGrammar::Reset(long NewLanguage)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 NewLanguage);
}

void ISpeechRecoGrammar::CmdLoadFromFile(LPCTSTR FileName, long LoadOption)
{
	static BYTE parms[] =
		VTS_BSTR VTS_I4;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 FileName, LoadOption);
}

void ISpeechRecoGrammar::CmdLoadFromObject(LPCTSTR ClassId, LPCTSTR GrammarName, long LoadOption)
{
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_I4;
	InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ClassId, GrammarName, LoadOption);
}

void ISpeechRecoGrammar::CmdLoadFromResource(long hModule, const VARIANT& ResourceName, const VARIANT& ResourceType, long LanguageId, long LoadOption)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT VTS_VARIANT VTS_I4 VTS_I4;
	InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 hModule, &ResourceName, &ResourceType, LanguageId, LoadOption);
}

void ISpeechRecoGrammar::CmdLoadFromMemory(const VARIANT& GrammarData, long LoadOption)
{
	static BYTE parms[] =
		VTS_VARIANT VTS_I4;
	InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 &GrammarData, LoadOption);
}

void ISpeechRecoGrammar::CmdLoadFromProprietaryGrammar(LPCTSTR ProprietaryGuid, LPCTSTR ProprietaryString, const VARIANT& ProprietaryData, long LoadOption)
{
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_VARIANT VTS_I4;
	InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ProprietaryGuid, ProprietaryString, &ProprietaryData, LoadOption);
}

void ISpeechRecoGrammar::CmdSetRuleState(LPCTSTR Name, long State)
{
	static BYTE parms[] =
		VTS_BSTR VTS_I4;
	InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Name, State);
}

void ISpeechRecoGrammar::CmdSetRuleIdState(long RuleId, long State)
{
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 RuleId, State);
}

void ISpeechRecoGrammar::DictationLoad(LPCTSTR TopicName, long LoadOption)
{
	static BYTE parms[] =
		VTS_BSTR VTS_I4;
	InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 TopicName, LoadOption);
}

void ISpeechRecoGrammar::DictationUnload()
{
	InvokeHelper(0xf, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ISpeechRecoGrammar::DictationSetState(long State)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 State);
}

void ISpeechRecoGrammar::SetWordSequenceData(LPCTSTR Text, long TextLength, LPDISPATCH Info)
{
	static BYTE parms[] =
		VTS_BSTR VTS_I4 VTS_DISPATCH;
	InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Text, TextLength, Info);
}

void ISpeechRecoGrammar::SetTextSelection(LPDISPATCH Info)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x12, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Info);
}

long ISpeechRecoGrammar::IsPronounceable(LPCTSTR Word)
{
	long result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x13, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		Word);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechGrammarRules properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechGrammarRules operations

long ISpeechGrammarRules::GetCount()
{
	long result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechGrammarRules::FindRule(const VARIANT& RuleNameOrId)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&RuleNameOrId);
	return result;
}

LPDISPATCH ISpeechGrammarRules::Item(long Index)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Index);
	return result;
}

BOOL ISpeechGrammarRules::GetDynamic()
{
	BOOL result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechGrammarRules::Add(LPCTSTR RuleName, long Attributes, long RuleId)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR VTS_I4 VTS_I4;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		RuleName, Attributes, RuleId);
	return result;
}

void ISpeechGrammarRules::Commit()
{
	InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

VARIANT ISpeechGrammarRules::CommitAndSave(BSTR* ErrorText)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_PBSTR;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		ErrorText);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechGrammarRule properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechGrammarRule operations

long ISpeechGrammarRule::GetAttributes()
{
	long result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechGrammarRule::GetInitialState()
{
	LPDISPATCH result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

CString ISpeechGrammarRule::GetName()
{
	CString result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

long ISpeechGrammarRule::GetId()
{
	long result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechGrammarRule::Clear()
{
	InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ISpeechGrammarRule::AddResource(LPCTSTR ResourceName, LPCTSTR ResourceValue)
{
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ResourceName, ResourceValue);
}