www.pudn.com > speech1.rar > 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) {} 
	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(); 
	VARIANT SaveToMemory(); 
	CString GetText(long StartElement, long Elements, BOOL UseReplacements); 
	long GetDisplayAttributes(long StartElement, long Elements, BOOL UseReplacements); 
}; 
///////////////////////////////////////////////////////////////////////////// 
// ISpeechPhraseRule wrapper class 
 
class ISpeechPhraseRule : public COleDispatchDriver 
{ 
public: 
	ISpeechPhraseRule() {}		// Calls COleDispatchDriver default constructor 
	ISpeechPhraseRule(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	ISpeechPhraseRule(const ISpeechPhraseRule& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
 
// Operations 
public: 
	CString GetName(); 
	long GetId(); 
	long GetFirstElement(); 
	long GetNumberOfElements(); 
	LPDISPATCH GetParent(); 
	LPDISPATCH GetChildren(); 
	long GetConfidence(); 
	float GetEngineConfidence(); 
}; 
///////////////////////////////////////////////////////////////////////////// 
// ISpeechPhraseRules wrapper class 
 
class ISpeechPhraseRules : public COleDispatchDriver 
{ 
public: 
	ISpeechPhraseRules() {}		// Calls COleDispatchDriver default constructor 
	ISpeechPhraseRules(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	ISpeechPhraseRules(const ISpeechPhraseRules& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
 
// Operations 
public: 
	long GetCount(); 
	LPDISPATCH Item(long Index); 
}; 
///////////////////////////////////////////////////////////////////////////// 
// ISpeechPhraseProperties wrapper class 
 
class ISpeechPhraseProperties : public COleDispatchDriver 
{ 
public: 
	ISpeechPhraseProperties() {}		// Calls COleDispatchDriver default constructor 
	ISpeechPhraseProperties(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	ISpeechPhraseProperties(const ISpeechPhraseProperties& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
 
// Operations 
public: 
	long GetCount(); 
	LPDISPATCH Item(long Index); 
}; 
///////////////////////////////////////////////////////////////////////////// 
// ISpeechPhraseProperty wrapper class 
 
class ISpeechPhraseProperty : public COleDispatchDriver 
{ 
public: 
	ISpeechPhraseProperty() {}		// Calls COleDispatchDriver default constructor 
	ISpeechPhraseProperty(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	ISpeechPhraseProperty(const ISpeechPhraseProperty& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
 
// Operations 
public: 
	CString GetName(); 
	long GetId(); 
	VARIANT GetValue(); 
	long GetFirstElement(); 
	long GetNumberOfElements(); 
	float GetEngineConfidence(); 
	long GetConfidence(); 
	LPDISPATCH GetParent(); 
	LPDISPATCH GetChildren(); 
}; 
///////////////////////////////////////////////////////////////////////////// 
// ISpeechPhraseElements wrapper class 
 
class ISpeechPhraseElements : public COleDispatchDriver 
{ 
public: 
	ISpeechPhraseElements() {}		// Calls COleDispatchDriver default constructor 
	ISpeechPhraseElements(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	ISpeechPhraseElements(const ISpeechPhraseElements& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
 
// Operations 
public: 
	long GetCount(); 
	LPDISPATCH Item(long Index); 
}; 
///////////////////////////////////////////////////////////////////////////// 
// ISpeechPhraseElement wrapper class 
 
class ISpeechPhraseElement : public COleDispatchDriver 
{ 
public: 
	ISpeechPhraseElement() {}		// Calls COleDispatchDriver default constructor 
	ISpeechPhraseElement(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	ISpeechPhraseElement(const ISpeechPhraseElement& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
 
// Operations 
public: 
	long GetAudioTimeOffset(); 
	long GetAudioSizeTime(); 
	long GetAudioStreamOffset(); 
	long GetAudioSizeBytes(); 
	long GetRetainedStreamOffset(); 
	long GetRetainedSizeBytes(); 
	CString GetDisplayText(); 
	CString GetLexicalForm(); 
	VARIANT GetPronunciation(); 
	long GetDisplayAttributes(); 
	long GetRequiredConfidence(); 
	long GetActualConfidence(); 
	float GetEngineConfidence(); 
}; 
///////////////////////////////////////////////////////////////////////////// 
// ISpeechPhraseReplacements wrapper class 
 
class ISpeechPhraseReplacements : public COleDispatchDriver 
{ 
public: 
	ISpeechPhraseReplacements() {}		// Calls COleDispatchDriver default constructor 
	ISpeechPhraseReplacements(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	ISpeechPhraseReplacements(const ISpeechPhraseReplacements& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
 
// Operations 
public: 
	long GetCount(); 
	LPDISPATCH Item(long Index); 
}; 
///////////////////////////////////////////////////////////////////////////// 
// ISpeechPhraseReplacement wrapper class 
 
class ISpeechPhraseReplacement : public COleDispatchDriver 
{ 
public: 
	ISpeechPhraseReplacement() {}		// Calls COleDispatchDriver default constructor 
	ISpeechPhraseReplacement(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	ISpeechPhraseReplacement(const ISpeechPhraseReplacement& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
 
// Operations 
public: 
	long GetDisplayAttributes(); 
	CString GetText(); 
	long GetFirstElement(); 
	long GetNumberOfElements(); 
}; 
///////////////////////////////////////////////////////////////////////////// 
// ISpeechPhraseAlternates wrapper class 
 
class ISpeechPhraseAlternates : public COleDispatchDriver 
{ 
public: 
	ISpeechPhraseAlternates() {}		// Calls COleDispatchDriver default constructor 
	ISpeechPhraseAlternates(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	ISpeechPhraseAlternates(const ISpeechPhraseAlternates& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
 
// Operations 
public: 
	long GetCount(); 
	LPDISPATCH Item(long Index); 
}; 
///////////////////////////////////////////////////////////////////////////// 
// ISpeechPhraseAlternate wrapper class 
 
class ISpeechPhraseAlternate : public COleDispatchDriver 
{ 
public: 
	ISpeechPhraseAlternate() {}		// Calls COleDispatchDriver default constructor 
	ISpeechPhraseAlternate(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	ISpeechPhraseAlternate(const ISpeechPhraseAlternate& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
 
// Operations 
public: 
	LPDISPATCH GetRecoResult(); 
	long GetStartElementInResult(); 
	long GetNumberOfElementsInResult(); 
	LPDISPATCH GetPhraseInfo(); 
	void Commit(); 
}; 
///////////////////////////////////////////////////////////////////////////// 
// _ISpeechRecoContextEvents wrapper class 
 
class _ISpeechRecoContextEvents : public COleDispatchDriver 
{ 
public: 
	_ISpeechRecoContextEvents() {}		// Calls COleDispatchDriver default constructor 
	_ISpeechRecoContextEvents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	_ISpeechRecoContextEvents(const _ISpeechRecoContextEvents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
 
// Operations 
public: 
	void StartStream(long StreamNumber, const VARIANT& StreamPosition); 
	void EndStream(long StreamNumber, const VARIANT& StreamPosition, BOOL StreamReleased); 
	void Bookmark(long StreamNumber, const VARIANT& StreamPosition, const VARIANT& BookmarkId, long Options); 
	void SoundStart(long StreamNumber, const VARIANT& StreamPosition); 
	void SoundEnd(long StreamNumber, const VARIANT& StreamPosition); 
	void PhraseStart(long StreamNumber, const VARIANT& StreamPosition); 
	void Recognition(long StreamNumber, const VARIANT& StreamPosition, long RecognitionType, LPDISPATCH Result); 
	void Hypothesis(long StreamNumber, const VARIANT& StreamPosition, LPDISPATCH Result); 
	void PropertyNumberChange(long StreamNumber, const VARIANT& StreamPosition, LPCTSTR PropertyName, long NewNumberValue); 
	void PropertyStringChange(long StreamNumber, const VARIANT& StreamPosition, LPCTSTR PropertyName, LPCTSTR NewStringValue); 
	void FalseRecognition(long StreamNumber, const VARIANT& StreamPosition, LPDISPATCH Result); 
	void Interference(long StreamNumber, const VARIANT& StreamPosition, long Interference); 
	void RequestUI(long StreamNumber, const VARIANT& StreamPosition, LPCTSTR UIType); 
	void RecognizerStateChange(long StreamNumber, const VARIANT& StreamPosition, long NewState); 
	void Adaptation(long StreamNumber, const VARIANT& StreamPosition); 
	void RecognitionForOtherContext(long StreamNumber, const VARIANT& StreamPosition); 
	void AudioLevel(long StreamNumber, const VARIANT& StreamPosition, long AudioLevel); 
	void EnginePrivate(long StreamNumber, const VARIANT& StreamPosition, const VARIANT& EngineData); 
}; 
///////////////////////////////////////////////////////////////////////////// 
// ISpeechLexicon wrapper class 
 
class ISpeechLexicon : public COleDispatchDriver 
{ 
public: 
	ISpeechLexicon() {}		// Calls COleDispatchDriver default constructor 
	ISpeechLexicon(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	ISpeechLexicon(const ISpeechLexicon& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
 
// Operations 
public: 
	LPDISPATCH GetWords(long Flags, long* GenerationId); 
	void AddPronunciation(LPCTSTR bstrWord, long LangId, long PartOfSpeech, LPCTSTR bstrPronunciation); 
	void RemovePronunciation(LPCTSTR bstrWord, long LangId, long PartOfSpeech, LPCTSTR bstrPronunciation); 
	LPDISPATCH GetPronunciations(LPCTSTR bstrWord, long LangId, long TypeFlags); 
}; 
///////////////////////////////////////////////////////////////////////////// 
// ISpeechLexiconWords wrapper class 
 
class ISpeechLexiconWords : public COleDispatchDriver 
{ 
public: 
	ISpeechLexiconWords() {}		// Calls COleDispatchDriver default constructor 
	ISpeechLexiconWords(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	ISpeechLexiconWords(const ISpeechLexiconWords& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
 
// Operations 
public: 
	long GetCount(); 
	LPDISPATCH Item(long Index); 
}; 
///////////////////////////////////////////////////////////////////////////// 
// ISpeechLexiconWord wrapper class 
 
class ISpeechLexiconWord : public COleDispatchDriver 
{ 
public: 
	ISpeechLexiconWord() {}		// Calls COleDispatchDriver default constructor 
	ISpeechLexiconWord(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	ISpeechLexiconWord(const ISpeechLexiconWord& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
 
// Operations 
public: 
	long GetLangId(); 
	long GetType(); 
	CString GetWord(); 
	LPDISPATCH GetPronunciations(); 
}; 
///////////////////////////////////////////////////////////////////////////// 
// ISpeechLexiconPronunciations wrapper class 
 
class ISpeechLexiconPronunciations : public COleDispatchDriver 
{ 
public: 
	ISpeechLexiconPronunciations() {}		// Calls COleDispatchDriver default constructor 
	ISpeechLexiconPronunciations(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	ISpeechLexiconPronunciations(const ISpeechLexiconPronunciations& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
 
// Operations 
public: 
	long GetCount(); 
	LPDISPATCH Item(long Index); 
}; 
///////////////////////////////////////////////////////////////////////////// 
// ISpeechLexiconPronunciation wrapper class 
 
class ISpeechLexiconPronunciation : public COleDispatchDriver 
{ 
public: 
	ISpeechLexiconPronunciation() {}		// Calls COleDispatchDriver default constructor 
	ISpeechLexiconPronunciation(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	ISpeechLexiconPronunciation(const ISpeechLexiconPronunciation& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
 
// Operations 
public: 
	long GetType(); 
	long GetLangId(); 
	long GetPartOfSpeech(); 
	VARIANT GetPhoneIds(); 
	CString GetSymbolic(); 
}; 
///////////////////////////////////////////////////////////////////////////// 
// ISpeechPhraseInfoBuilder wrapper class 
 
class ISpeechPhraseInfoBuilder : public COleDispatchDriver 
{ 
public: 
	ISpeechPhraseInfoBuilder() {}		// Calls COleDispatchDriver default constructor 
	ISpeechPhraseInfoBuilder(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	ISpeechPhraseInfoBuilder(const ISpeechPhraseInfoBuilder& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
 
// Operations 
public: 
	LPDISPATCH RestorePhraseFromMemory(VARIANT* PhraseInMemory); 
}; 
///////////////////////////////////////////////////////////////////////////// 
// ISpeechPhoneConverter wrapper class 
 
class ISpeechPhoneConverter : public COleDispatchDriver 
{ 
public: 
	ISpeechPhoneConverter() {}		// Calls COleDispatchDriver default constructor 
	ISpeechPhoneConverter(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	ISpeechPhoneConverter(const ISpeechPhoneConverter& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
 
// Operations 
public: 
	long GetLanguageId(); 
	void SetLanguageId(long nNewValue); 
	VARIANT PhoneToId(LPCTSTR Phonemes); 
	CString IdToPhone(const VARIANT& IdArray); 
};