| // Licensed under the Apache License, Version 2.0 |
| // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license |
| // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option. |
| // All files in the project carrying such notice may not be copied, modified, or distributed |
| // except according to those terms. |
| use ctypes::{c_char, c_float, c_long, c_void}; |
| use shared::guiddef::{CLSID, GUID, IID, REFGUID}; |
| use shared::minwindef::{BOOL, BYTE, DWORD, ULONG, USHORT, WORD}; |
| use shared::mmreg::WAVEFORMATEX; |
| use shared::windef::HWND; |
| use um::oaidl::VARIANT; |
| use um::objidlbase::IStream; |
| use um::sapi::*; |
| use um::unknwnbase::{IUnknown, IUnknownVtbl}; |
| use um::winnt::{HANDLE, HRESULT, LONG, LPCWSTR, LPWSTR, PVOID, ULONGLONG, WCHAR}; |
| pub const SPRECOEXTENSION: &'static str = "RecoExtension"; |
| pub const SPALTERNATESCLSID: &'static str = "AlternatesCLSID"; |
| RIDL!{#[uuid(0xf8e690f0, 0x39cb, 0x4843, 0xb8, 0xd7, 0xc8, 0x46, 0x96, 0xe1, 0x11, 0x9d)] |
| interface ISpTokenUI(ISpTokenUIVtbl): IUnknown(IUnknownVtbl) { |
| fn IsUISupported( |
| pszTypeOfUI: LPCWSTR, |
| pvExtraData: *mut c_void, |
| cbExtraData: ULONG, |
| punkObject: *mut IUnknown, |
| pfSupported: *mut BOOL, |
| ) -> HRESULT, |
| fn DisplayUI( |
| hwndParent: HWND, |
| pszTitle: LPCWSTR, |
| pszTypeOfUI: LPCWSTR, |
| pvExtraData: *mut c_void, |
| cbExtraData: ULONG, |
| pToken: *mut ISpObjectToken, |
| punkObject: *mut IUnknown, |
| ) -> HRESULT, |
| }} |
| RIDL!{#[uuid(0x06b64f9f, 0x7fda, 0x11d2, 0xb4, 0xf2, 0x00, 0xc0, 0x4f, 0x79, 0x73, 0x96)] |
| interface ISpObjectTokenEnumBuilder(ISpObjectTokenEnumBuilderVtbl): |
| IEnumSpObjectTokens(IEnumSpObjectTokensVtbl) { |
| fn SetAttribs( |
| pszReqAttribs: LPCWSTR, |
| pszOptAttribs: LPCWSTR, |
| ) -> HRESULT, |
| fn AddTokens( |
| cTokens: ULONG, |
| pToken: *mut *mut ISpObjectToken, |
| ) -> HRESULT, |
| fn AddTokensFromDataKey( |
| pDataKey: *mut ISpDataKey, |
| pszSubKey: LPCWSTR, |
| pszCategoryId: LPCWSTR, |
| ) -> HRESULT, |
| fn AddTokensFromTokenEnum( |
| pTokenEnum: *mut IEnumSpObjectTokens, |
| ) -> HRESULT, |
| fn Sort( |
| pszTokenIdToListFirst: LPCWSTR, |
| ) -> HRESULT, |
| }} |
| DECLARE_HANDLE!{SPWORDHANDLE, SPWORDHANDLE__} |
| DECLARE_HANDLE!{SPRULEHANDLE, SPRULEHANDLE__} |
| DECLARE_HANDLE!{SPGRAMMARHANDLE, SPGRAMMARHANDLE__} |
| DECLARE_HANDLE!{SPRECOCONTEXTHANDLE, SPRECOCONTEXTHANDLE__} |
| DECLARE_HANDLE!{SPPHRASERULEHANDLE, SPPHRASERULEHANDLE__} |
| DECLARE_HANDLE!{SPPHRASEPROPERTYHANDLE, SPPHRASEPROPERTYHANDLE__} |
| DECLARE_HANDLE!{SPTRANSITIONID, SPTRANSITIONID__} |
| RIDL!{#[uuid(0xf4711347, 0xe608, 0x11d2, 0xa0, 0x86, 0x00, 0xc0, 0x4f, 0x8e, 0xf9, 0xb5)] |
| interface ISpErrorLog(ISpErrorLogVtbl): IUnknown(IUnknownVtbl) { |
| fn AddError( |
| lLineNumber: c_long, |
| hr: HRESULT, |
| pszDescription: LPCWSTR, |
| pszHelpFile: LPCWSTR, |
| dwHelpContext: DWORD, |
| ) -> HRESULT, |
| }} |
| RIDL!{#[uuid(0xb1e29d58, 0xa675, 0x11d2, 0x83, 0x02, 0x00, 0xc0, 0x4f, 0x8e, 0xe6, 0xc0)] |
| interface ISpGrammarCompiler(ISpGrammarCompilerVtbl): IUnknown(IUnknownVtbl) { |
| fn CompileStream( |
| pSource: *mut IStream, |
| pDest: *mut IStream, |
| pHeader: *mut IStream, |
| pReserved: *mut IUnknown, |
| pErrorLog: *mut ISpErrorLog, |
| dwFlags: DWORD, |
| ) -> HRESULT, |
| }} |
| RIDL!{#[uuid(0x3ddca27c, 0x665c, 0x4786, 0x9f, 0x97, 0x8c, 0x90, 0xc3, 0x48, 0x8b, 0x61)] |
| interface ISpGramCompBackend(ISpGramCompBackendVtbl): ISpGrammarBuilder(ISpGrammarBuilderVtbl) { |
| fn SetSaveObjects( |
| pStream: *mut IStream, |
| pErrorLog: *mut ISpErrorLog, |
| ) -> HRESULT, |
| fn InitFromBinaryGrammar( |
| pBinaryData: *const SPBINARYGRAMMAR, |
| ) -> HRESULT, |
| }} |
| RIDL!{#[uuid(0x12d7360f, 0xa1c9, 0x11d3, 0xbc, 0x90, 0x00, 0xc0, 0x4f, 0x72, 0xdf, 0x9f)] |
| interface ISpITNProcessor(ISpITNProcessorVtbl): IUnknown(IUnknownVtbl) { |
| fn LoadITNGrammar( |
| pszCLSID: LPWSTR, |
| ) -> HRESULT, |
| fn ITNPhrase( |
| pPhrase: *mut ISpPhraseBuilder, |
| ) -> HRESULT, |
| }} |
| RIDL!{#[uuid(0x88a3342a, 0x0bed, 0x4834, 0x92, 0x2b, 0x88, 0xd4, 0x31, 0x73, 0x16, 0x2f)] |
| interface ISpPhraseBuilder(ISpPhraseBuilderVtbl): ISpPhrase(ISpPhraseVtbl) { |
| fn InitFromPhrase( |
| pPhrase: *const SPPHRASE, |
| ) -> HRESULT, |
| fn InitFromSerializedPhrase( |
| pPhrase: *const SPSERIALIZEDPHRASE, |
| ) -> HRESULT, |
| fn AddElements( |
| cElements: ULONG, |
| pElement: *const SPPHRASEELEMENT, |
| ) -> HRESULT, |
| fn AddRules( |
| hParent: SPPHRASERULEHANDLE, |
| pRule: *const SPPHRASERULE, |
| phNewRule: *mut SPPHRASERULEHANDLE, |
| ) -> HRESULT, |
| fn AddProperties( |
| hParent: SPPHRASEPROPERTYHANDLE, |
| pProperty: *const SPPHRASEPROPERTY, |
| phNewProperty: *mut SPPHRASEPROPERTYHANDLE, |
| ) -> HRESULT, |
| fn AddReplacements( |
| cReplacements: ULONG, |
| pReplacements: *const SPPHRASEREPLACEMENT, |
| ) -> HRESULT, |
| }} |
| pub type ISpTask = *mut c_void; |
| pub type ISpThreadTask = *mut c_void; |
| RIDL!{#[uuid(0xa6be4d73, 0x4403, 0x4358, 0xb2, 0x2d, 0x03, 0x46, 0xe2, 0x3b, 0x17, 0x64)] |
| interface ISpThreadControl(ISpThreadControlVtbl): ISpNotifySink(ISpNotifySinkVtbl) { |
| fn StartThread( |
| dwFlags: DWORD, |
| phwnd: *mut HWND, |
| ) -> HRESULT, |
| fn WaitForThreadDone( |
| fForceStop: BOOL, |
| phrThreadResult: *mut HRESULT, |
| msTimeOut: ULONG, |
| ) -> HRESULT, |
| fn TerminateThread() -> HRESULT, |
| fn ThreadHandle() -> HANDLE, |
| fn ThreadId() -> DWORD, |
| fn NotifyEvent() -> HANDLE, |
| fn WindowHandle() -> HWND, |
| fn ThreadCompleteEvent() -> HANDLE, |
| fn ExitThreadEvent() -> HANDLE, |
| }} |
| STRUCT!{struct SPTMTHREADINFO { |
| lPoolSize: c_long, |
| lPriority: c_long, |
| ulConcurrencyLimit: ULONG, |
| ulMaxQuickAllocThreads: ULONG, |
| }} |
| RIDL!{#[uuid(0x2baeef81, 0x2ca3, 0x4331, 0x98, 0xf3, 0x26, 0xec, 0x5a, 0xbe, 0xfb, 0x03)] |
| interface ISpTaskManager(ISpTaskManagerVtbl): IUnknown(IUnknownVtbl) { |
| fn SetThreadPoolInfo( |
| pPoolInfo: *const SPTMTHREADINFO, |
| ) -> HRESULT, |
| fn GetThreadPoolInfo( |
| pPoolInfo: *mut SPTMTHREADINFO, |
| ) -> HRESULT, |
| fn QueueTask( |
| pTask: *mut ISpTask, |
| pvTaskData: *mut c_void, |
| hCompEvent: HANDLE, |
| pdwGroupId: *mut DWORD, |
| pTaskID: *mut DWORD, |
| ) -> HRESULT, |
| fn CreateReoccurringTask( |
| pTask: *mut ISpTask, |
| pvTaskData: *mut c_void, |
| hCompEvent: HANDLE, |
| ppTaskCtrl: *mut *mut ISpNotifySink, |
| ) -> HRESULT, |
| fn CreateThreadControl( |
| pTask: *mut ISpThreadTask, |
| pvTaskData: *mut c_void, |
| nPriority: c_long, |
| ppTaskCtrl: *mut *mut ISpThreadControl, |
| ) -> HRESULT, |
| fn TerminateTask( |
| dwGroupId: DWORD, |
| ulWaitPeriod: ULONG, |
| ) -> HRESULT, |
| }} |
| ENUM!{enum SPVSKIPTYPE { |
| SPVST_SENTENCE = 1 << 0, |
| }} |
| ENUM!{enum SPVESACTIONS { |
| SPVES_CONTINUE = 0, |
| SPVES_ABORT = 1 << 0, |
| SPVES_SKIP = 1 << 1, |
| SPVES_RATE = 1 << 2, |
| SPVES_VOLUME = 1 << 3, |
| }} |
| RIDL!{#[uuid(0x9880499b, 0xcce9, 0x11d2, 0xb5, 0x03, 0x00, 0xc0, 0x4f, 0x79, 0x73, 0x96)] |
| interface ISpTTSEngineSite(ISpTTSEngineSiteVtbl): ISpEventSink(ISpEventSinkVtbl) { |
| fn GetActions() -> DWORD, |
| fn Write( |
| pBuff: *const c_void, |
| cb: ULONG, |
| pcbWritten: *mut ULONG, |
| ) -> HRESULT, |
| fn GetRate( |
| pRateAdjust: *mut c_long, |
| ) -> HRESULT, |
| fn GetVolume(pusVolume: *mut USHORT, |
| ) -> HRESULT, |
| fn GetSkipInfo( |
| peType: *mut SPVSKIPTYPE, |
| plNumItems: *mut c_long, |
| ) -> HRESULT, |
| fn CompleteSkip( |
| ulNumSkipped: c_long, |
| ) -> HRESULT, |
| }} |
| STRUCT!{struct SPVTEXTFRAG { |
| pNext: *mut SPVTEXTFRAG, |
| State: SPVSTATE, |
| pTextStart: LPCWSTR, |
| ulTextLen: ULONG, |
| ulTextSrcOffset: ULONG, |
| }} |
| RIDL!{#[uuid(0xa74d7c8e, 0x4cc5, 0x4f2f, 0xa6, 0xeb, 0x80, 0x4d, 0xee, 0x18, 0x50, 0x0e)] |
| interface ISpTTSEngine(ISpTTSEngineVtbl): IUnknown(IUnknownVtbl) { |
| fn Speak( |
| dwSpeakFlags: DWORD, |
| rguidFormatId: REFGUID, |
| pWaveFormatEx: *const WAVEFORMATEX, |
| pTextFragList: *const SPVTEXTFRAG, |
| pOutputSite: *mut ISpTTSEngineSite, |
| ) -> HRESULT, |
| fn GetOutputFormat( |
| pTargetFmtId: *const GUID, |
| pTargetWaveFormatEx: *const WAVEFORMATEX, |
| pOutputFormatId: *mut GUID, |
| ppCoMemOutputWaveFormatEx: *mut WAVEFORMATEX, |
| ) -> HRESULT, |
| }} |
| STRUCT!{struct SPWORDENTRY { |
| hWord: SPWORDHANDLE, |
| LangID: WORD, |
| pszDisplayText: *mut WCHAR, |
| pszLexicalForm: *mut WCHAR, |
| aPhoneId: *mut SPPHONEID, |
| pvClientContext: *mut c_void, |
| }} |
| STRUCT!{struct SPRULEENTRY { |
| hRule: SPRULEHANDLE, |
| hInitialState: SPSTATEHANDLE, |
| Attributes: DWORD, |
| pvClientRuleContext: *mut c_void, |
| pvClientGrammarContext: *mut c_void, |
| }} |
| ENUM!{enum SPTRANSITIONTYPE { |
| SPTRANSEPSILON = 0, |
| SPTRANSWORD, |
| SPTRANSRULE, |
| SPTRANSTEXTBUF, |
| SPTRANSWILDCARD, |
| SPTRANSDICTATION, |
| }} |
| STRUCT!{struct SPTRANSITIONENTRY_u_s1 { |
| hRuleInitialState: SPSTATEHANDLE, |
| hRule: SPRULEHANDLE, |
| pvClientRuleContext: *mut c_void, |
| }} |
| STRUCT!{struct SPTRANSITIONENTRY_u_s2 { |
| hWord: SPWORDHANDLE, |
| pvClientWordContext: *mut c_void, |
| }} |
| UNION!{union SPTRANSITIONENTRY_u { |
| [usize; 3], |
| s1 s1_mut: SPTRANSITIONENTRY_u_s1, |
| s2 s2_mut: SPTRANSITIONENTRY_u_s2, |
| pvGrammarCookie pvGrammarCookie_mut: *mut c_void, |
| }} |
| STRUCT!{struct SPTRANSITIONENTRY { |
| ID: SPTRANSITIONID, |
| hNextState: SPSTATEHANDLE, |
| Type: BYTE, |
| RequiredConfidence: c_char, |
| fHasProperty: DWORD, |
| Weight: c_float, |
| u: SPTRANSITIONENTRY_u, |
| }} |
| STRUCT!{struct SPTRANSITIONPROPERTY { |
| pszName: LPCWSTR, |
| ulId: ULONG, |
| pszValue: LPCWSTR, |
| vValue: VARIANT, |
| }} |
| STRUCT!{struct SPSTATEINFO { |
| cAllocatedEntries: ULONG, |
| pTransitions: *mut SPTRANSITIONENTRY, |
| cEpsilons: ULONG, |
| cRules: ULONG, |
| cWords: ULONG, |
| cSpecialTransitions: ULONG, |
| }} |
| STRUCT!{struct SPPATHENTRY { |
| hTransition: SPTRANSITIONID, |
| elem: SPPHRASEELEMENT, |
| }} |
| RIDL!{#[uuid(0x6a6ffad8, 0x78b6, 0x473d, 0xb8, 0x44, 0x98, 0x15, 0x2e, 0x4f, 0xb1, 0x6b)] |
| interface ISpCFGInterpreterSite(ISpCFGInterpreterSiteVtbl): IUnknown(IUnknownVtbl) { |
| fn AddTextReplacement( |
| pReplace: *mut SPPHRASEREPLACEMENT, |
| ) -> HRESULT, |
| fn AddProperty( |
| pProperty: *const SPPHRASEPROPERTY, |
| ) -> HRESULT, |
| fn GetResourceValue( |
| pszResourceName: LPCWSTR, |
| ppCoMemResource: *mut LPWSTR, |
| ) -> HRESULT, |
| }} |
| RIDL!{#[uuid(0xf3d3f926, 0x11fc, 0x11d3, 0xbb, 0x97, 0x00, 0xc0, 0x4f, 0x8e, 0xe6, 0xc0)] |
| interface ISpCFGInterpreter(ISpCFGInterpreterVtbl): IUnknown(IUnknownVtbl) { |
| fn InitGrammar( |
| pszGrammarName: LPCWSTR, |
| pvGrammarData: *mut *const c_void, |
| ) -> HRESULT, |
| fn Interpret( |
| pPhrase: *mut ISpPhraseBuilder, |
| ulFirstElement: *const ULONG, |
| ulCountOfElements: *const ULONG, |
| pSite: *mut ISpCFGInterpreterSite, |
| ) -> HRESULT, |
| }} |
| ENUM!{enum SPCFGNOTIFY { |
| SPCFGN_ADD, |
| SPCFGN_REMOVE, |
| SPCFGN_INVALIDATE, |
| SPCFGN_ACTIVATE, |
| SPCFGN_DEACTIVATE, |
| }} |
| ENUM!{enum SPRESULTTYPE { |
| SPRT_CFG = 0, |
| SPRT_SLM = 1, |
| SPRT_PROPRIETARY = 2, |
| SPRT_FALSE_RECOGNITION = 1 << 2, |
| }} |
| STRUCT!{struct SPPHRASEALT { |
| pPhrase: *mut ISpPhraseBuilder, |
| ulStartElementInParent: ULONG, |
| cElementsInParent: ULONG, |
| cElementsInAlternate: ULONG, |
| pvAltExtra: *mut c_void, |
| cbAltExtra: ULONG, |
| }} |
| STRUCT!{struct SPRECORESULTINFO { |
| cbSize: ULONG, |
| eResultType: SPRESULTTYPE, |
| fHypothesis: BOOL, |
| fProprietaryAutoPause: BOOL, |
| ullStreamPosStart: ULONGLONG, |
| ullStreamPosEnd: ULONGLONG, |
| hGrammar: SPGRAMMARHANDLE, |
| ulSizeEngineData: ULONG, |
| pvEngineData: *mut c_void, |
| pPhrase: *mut ISpPhraseBuilder, |
| aPhraseAlts: *mut SPPHRASEALT, |
| ulNumAlts: ULONG, |
| }} |
| ENUM!{enum SPWORDINFOOPT { |
| SPWIO_NONE = 0, |
| SPWIO_WANT_TEXT = 1, |
| }} |
| ENUM!{enum SPRULEINFOOPT { |
| SPRIO_NONE = 0, |
| }} |
| STRUCT!{struct SPPARSEINFO { |
| cbSize: ULONG, |
| hRule: SPRULEHANDLE, |
| ullAudioStreamPosition: ULONGLONG, |
| ulAudioSize: ULONG, |
| cTransitions: ULONG, |
| pPath: *mut SPPATHENTRY, |
| SREngineID: GUID, |
| ulSREnginePrivateDataSize: ULONG, |
| pSREnginePrivateData: *const BYTE, |
| fHypothesis: BOOL, |
| }} |
| RIDL!{#[uuid(0x3b414aec, 0x720c, 0x4883, 0xb9, 0xef, 0x17, 0x8c, 0xd3, 0x94, 0xfb, 0x3a)] |
| interface ISpSREngineSite(ISpSREngineSiteVtbl): IUnknown(IUnknownVtbl) { |
| fn Read( |
| pv: *mut c_void, |
| cb: ULONG, |
| pcbRead: *mut ULONG, |
| ) -> HRESULT, |
| fn DataAvailable( |
| pcb: *mut ULONG, |
| ) -> HRESULT, |
| fn SetBufferNotifySize( |
| cbSize: ULONG, |
| ) -> HRESULT, |
| fn ParseFromTransitions( |
| pParseInfo: *const SPPARSEINFO, |
| ppNewPhrase: *mut *mut ISpPhraseBuilder, |
| ) -> HRESULT, |
| fn Recognition( |
| pResultInfo: *const SPRECORESULTINFO, |
| ) -> HRESULT, |
| fn AddEvent( |
| pEvent: *const SPEVENT, |
| hSAPIRecoContext: SPRECOCONTEXTHANDLE, |
| ) -> HRESULT, |
| fn Synchronize( |
| ullProcessedThruPos: ULONGLONG, |
| ) -> HRESULT, |
| fn GetWordInfo( |
| pWordEntry: *mut SPWORDENTRY, |
| Options: SPWORDINFOOPT, |
| ) -> HRESULT, |
| fn SetWordClientContext( |
| hWord: SPWORDHANDLE, |
| pvClientContext: *mut c_void, |
| ) -> HRESULT, |
| fn GetRuleInfo( |
| pRuleEntry: *mut SPRULEENTRY, |
| Options: SPRULEINFOOPT, |
| ) -> HRESULT, |
| fn SetRuleClientContext( |
| hRule: SPRULEHANDLE, |
| pvClientContext: *mut c_void, |
| ) -> HRESULT, |
| fn GetStateInfo( |
| hState: SPSTATEHANDLE, |
| pStateInfo: *mut SPSTATEINFO, |
| ) -> HRESULT, |
| fn GetResource( |
| hRule: SPRULEHANDLE, |
| pszResourceName: LPCWSTR, |
| ppCoMemResource: *mut LPWSTR, |
| ) -> HRESULT, |
| fn GetTransitionProperty( |
| ID: SPTRANSITIONID, |
| ppCoMemProperty: *mut *mut SPTRANSITIONPROPERTY, |
| ) -> HRESULT, |
| fn IsAlternate( |
| hRule: SPRULEHANDLE, |
| hAltRule: SPRULEHANDLE, |
| ) -> HRESULT, |
| fn GetMaxAlternates( |
| hRule: SPRULEHANDLE, |
| pulNumAlts: *mut ULONG, |
| ) -> HRESULT, |
| fn GetContextMaxAlternates( |
| hContext: SPRECOCONTEXTHANDLE, |
| pulNumAlts: *mut ULONG, |
| ) -> HRESULT, |
| fn UpdateRecoPos( |
| ullCurrentRecoPos: ULONGLONG, |
| ) -> HRESULT, |
| }} |
| ENUM!{enum SPPROPSRC { |
| SPPROPSRC_RECO_INST, |
| SPPROPSRC_RECO_CTX, |
| SPPROPSRC_RECO_GRAMMAR, |
| }} |
| RIDL!{#[uuid(0x2f472991, 0x854b, 0x4465, 0xb6, 0x13, 0xfb, 0xaf, 0xb3, 0xad, 0x8e, 0xd8)] |
| interface ISpSREngine(ISpSREngineVtbl): IUnknown(IUnknownVtbl) { |
| fn SetSite( |
| pSite: *mut ISpSREngineSite, |
| ) -> HRESULT, |
| fn GetInputAudioFormat( |
| pguidSourceFormatId: *const GUID, |
| pSourceWaveFormatEx: *const WAVEFORMATEX, |
| pguidDesiredFormatId: *mut GUID, |
| ppCoMemDesiredWaveFormatEx: *mut WAVEFORMATEX, |
| ) -> HRESULT, |
| fn RecognizeStream( |
| rguidFmtId: REFGUID, |
| pWaveFormatEx: *const WAVEFORMATEX, |
| hRequestSync: HANDLE, |
| hDataAvailable: HANDLE, |
| hExit: HANDLE, |
| fNewAudioStream: BOOL, |
| fRealTimeAudio: BOOL, |
| pAudioObjectToken: *mut ISpObjectToken, |
| ) -> HRESULT, |
| fn SetRecoProfile( |
| pProfile: *mut ISpObjectToken, |
| ) -> HRESULT, |
| fn OnCreateGrammar( |
| pvEngineRecoContext: *mut c_void, |
| hSAPIGrammar: SPGRAMMARHANDLE, |
| ppvEngineGrammarContext: *mut *mut c_void, |
| ) -> HRESULT, |
| fn OnDeleteGrammar( |
| pvEngineGrammar: *mut c_void, |
| ) -> HRESULT, |
| fn LoadProprietaryGrammar( |
| pvEngineGrammar: *mut c_void, |
| rguidParam: REFGUID, |
| pszStringParam: LPCWSTR, |
| pvDataParam: *const c_void, |
| ulDataSize: ULONG, |
| Options: SPLOADOPTIONS, |
| ) -> HRESULT, |
| fn UnloadProprietaryGrammar( |
| pvEngineGrammar: *mut c_void, |
| ) -> HRESULT, |
| fn SetProprietaryRuleState( |
| pvEngineGrammar: *mut c_void, |
| pszName: LPCWSTR, |
| pReserved: *mut c_void, |
| NewState: SPRULESTATE, |
| pcRulesChanged: *mut ULONG, |
| ) -> HRESULT, |
| fn SetProprietaryRuleIdState( |
| pvEngineGrammar: *mut c_void, |
| dwRuleId: DWORD, |
| NewState: SPRULESTATE, |
| ) -> HRESULT, |
| fn LoadSLM( |
| pvEngineGrammar: *mut c_void, |
| pszTopicName: LPCWSTR, |
| ) -> HRESULT, |
| fn UnloadSLM( |
| pvEngineGrammar: *mut c_void, |
| ) -> HRESULT, |
| fn SetSLMState( |
| pvEngineGrammar: *mut c_void, |
| NewState: SPRULESTATE, |
| ) -> HRESULT, |
| fn SetWordSequenceData( |
| pvEngineGrammar: *mut c_void, |
| pText: *const WCHAR, |
| cchText: ULONG, |
| pInfo: *const SPTEXTSELECTIONINFO, |
| ) -> HRESULT, |
| fn SetTextSelection( |
| pvEngineGrammar: *mut c_void, |
| pInfo: *const SPTEXTSELECTIONINFO, |
| ) -> HRESULT, |
| fn IsPronounceable( |
| pvEngineGrammar: *mut c_void, |
| pszWord: LPCWSTR, |
| pWordPronounceable: *mut SPWORDPRONOUNCEABLE, |
| ) -> HRESULT, |
| fn OnCreateRecoContext( |
| hSAPIRecoContext: SPRECOCONTEXTHANDLE, |
| ppvEngineContext: *mut *mut c_void, |
| ) -> HRESULT, |
| fn OnDeleteRecoContext( |
| pvEngineContext: *mut c_void, |
| ) -> HRESULT, |
| fn OnPrivateCall( |
| pvEngineContext: *mut c_void, |
| pCallFrame: PVOID, |
| ulCallFrameSize: ULONG, |
| ) -> HRESULT, |
| fn SetAdaptationData( |
| pvEngineContext: *mut c_void, |
| pAdaptationData: *const WCHAR, |
| cch: ULONG, |
| ) -> HRESULT, |
| fn SetPropertyNum( |
| eSrc: SPPROPSRC, |
| pvSrcObj: *mut c_void, |
| pName: *const WCHAR, |
| lValue: LONG, |
| ) -> HRESULT, |
| fn GetPropertyNum( |
| eSrc: SPPROPSRC, |
| pvSrcObj: *mut c_void, |
| pName: *const WCHAR, |
| lValue: *mut LONG, |
| ) -> HRESULT, |
| fn SetPropertyString( |
| eSrc: SPPROPSRC, |
| pvSrcObj: *mut c_void, |
| pName: LPCWSTR, |
| pValue: LPCWSTR, |
| ) -> HRESULT, |
| fn GetPropertyString( |
| eSrc: SPPROPSRC, |
| pvSrcObj: *mut c_void, |
| pName: LPCWSTR, |
| ppCoMemValue: *mut LPWSTR, |
| ) -> HRESULT, |
| fn SetGrammarState( |
| pvEngineGrammar: *mut c_void, |
| eGrammarState: SPGRAMMARSTATE, |
| ) -> HRESULT, |
| fn WordNotify( |
| Action: SPCFGNOTIFY, |
| cWords: ULONG, |
| pWords: *const SPWORDENTRY, |
| ) -> HRESULT, |
| fn RuleNotify( |
| Action: SPCFGNOTIFY, |
| cRules: ULONG, |
| pRules: *const SPRULEENTRY, |
| ) -> HRESULT, |
| fn PrivateCallEx( |
| pvEngineContext: *mut c_void, |
| pInCallFrame: *const c_void, |
| ulInCallFrameSize: ULONG, |
| ppvCoMemResponse: *mut *mut c_void, |
| pulResponseSize: *mut ULONG, |
| ) -> HRESULT, |
| fn SetContextState( |
| pvEngineContext: *mut c_void, |
| eContextState: SPCONTEXTSTATE, |
| ) -> HRESULT, |
| }} |
| STRUCT!{struct SPPHRASEALTREQUEST { |
| ulStartElement: ULONG, |
| cElements: ULONG, |
| ulRequestAltCount: ULONG, |
| pvResultExtra: *mut c_void, |
| cbResultExtra: ULONG, |
| pPhrase: *mut ISpPhrase, |
| pRecoContext: *mut ISpRecoContext, |
| }} |
| RIDL!{#[uuid(0x8e7c791e, 0x4467, 0x11d3, 0x97, 0x23, 0x00, 0xc0, 0x4f, 0x72, 0xdb, 0x08)] |
| interface _ISpPrivateEngineCall(_ISpPrivateEngineCallVtbl): IUnknown(IUnknownVtbl) { |
| fn CallEngine( |
| pCallFrame: *mut c_void, |
| ulCallFrameSize: ULONG, |
| ) -> HRESULT, |
| fn CallEngineEx( |
| pInFrame: *const c_void, |
| ulInFrameSize: ULONG, |
| ppCoMemOutFrame: *mut *mut c_void, |
| pulOutFrameSize: *mut ULONG, |
| ) -> HRESULT, |
| }} |
| extern { |
| pub static LIBID_SpeechDDKLib: IID; |
| pub static CLSID_SpDataKey: CLSID; |
| } |
| RIDL!{#[uuid(0xd9f6ee60, 0x58c9, 0x458b, 0x88, 0xe1, 0x2f, 0x90, 0x8f, 0xd7, 0xf8, 0x7c)] |
| class SpDataKey;} |
| extern { |
| pub static CLSID_SpObjectTokenEnum: CLSID; |
| pub static CLSID_SpPhraseBuilder: CLSID; |
| pub static CLSID_SpITNProcessor: CLSID; |
| pub static CLSID_SpGrammarCompiler: CLSID; |
| pub static CLSID_SpGramCompBackend: CLSID; |
| } |
