diff --git a/.clang-format b/.clang-format new file mode 100755 index 0000000..1323933 --- /dev/null +++ b/.clang-format @@ -0,0 +1,44 @@ +BasedOnStyle: Google + +# force T* or T& +DerivePointerAlignment: false +PointerAlignment: Left + +TabWidth: 4 +IndentWidth: 4 +UseTab: Always +IndentPPDirectives: BeforeHash + +AllowAllParametersOfDeclarationOnNextLine: true +AllowShortBlocksOnASingleLine: false +AllowShortFunctionsOnASingleLine: InlineOnly +AllowShortIfStatementsOnASingleLine: Never +AllowShortLoopsOnASingleLine: false +AllowShortCaseLabelsOnASingleLine: true + +BinPackArguments: true +BinPackParameters: true +BreakConstructorInitializers: BeforeColon +BreakStringLiterals: false + +ColumnLimit: 150 +CompactNamespaces: false + +ConstructorInitializerAllOnOneLineOrOnePerLine: true +ContinuationIndentWidth: 0 + +# turning this on causes major issues with initializer lists +Cpp11BracedListStyle: false +SpaceBeforeCpp11BracedList: true + +FixNamespaceComments: true + +NamespaceIndentation: All +ReflowComments: true + +SortIncludes: CaseInsensitive +SortUsingDeclarations: true + +SpacesInSquareBrackets: false +SpaceBeforeParens: Never +SpacesBeforeTrailingComments: 1 diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..0b53eb8 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,11 @@ +root = true + +[*] +end_of_line = lf +insert_final_newline = true +indent_style = tab +indent_size = 4 + +# specifically for YAML +[{yml, yaml}] +indent_style = space diff --git a/.gitignore b/.gitignore index 9491a2f..0ce16da 100644 --- a/.gitignore +++ b/.gitignore @@ -1,363 +1,7 @@ -## Ignore Visual Studio temporary files, build results, and -## files generated by popular Visual Studio add-ons. -## -## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore +# ccls/clangd +.cache/ +**/bin/ +**/obj/ -# User-specific files -*.rsuser -*.suo -*.user -*.userosscache -*.sln.docstates - -# User-specific files (MonoDevelop/Xamarin Studio) -*.userprefs - -# Mono auto generated files -mono_crash.* - -# Build results -[Dd]ebug/ -[Dd]ebugPublic/ -[Rr]elease/ -[Rr]eleases/ -x64/ -x86/ -[Ww][Ii][Nn]32/ -[Aa][Rr][Mm]/ -[Aa][Rr][Mm]64/ -bld/ -[Bb]in/ -[Oo]bj/ -[Oo]ut/ -[Ll]og/ -[Ll]ogs/ - -# Visual Studio 2015/2017 cache/options directory -.vs/ -# Uncomment if you have tasks that create the project's static files in wwwroot -#wwwroot/ - -# Visual Studio 2017 auto generated files -Generated\ Files/ - -# MSTest test Results -[Tt]est[Rr]esult*/ -[Bb]uild[Ll]og.* - -# NUnit -*.VisualState.xml -TestResult.xml -nunit-*.xml - -# Build Results of an ATL Project -[Dd]ebugPS/ -[Rr]eleasePS/ -dlldata.c - -# Benchmark Results -BenchmarkDotNet.Artifacts/ - -# .NET Core -project.lock.json -project.fragment.lock.json -artifacts/ - -# ASP.NET Scaffolding -ScaffoldingReadMe.txt - -# StyleCop -StyleCopReport.xml - -# Files built by Visual Studio -*_i.c -*_p.c -*_h.h -*.ilk -*.meta -*.obj -*.iobj -*.pch -*.pdb -*.ipdb -*.pgc -*.pgd -*.rsp -*.sbr -*.tlb -*.tli -*.tlh -*.tmp -*.tmp_proj -*_wpftmp.csproj -*.log -*.vspscc -*.vssscc -.builds -*.pidb -*.svclog -*.scc - -# Chutzpah Test files -_Chutzpah* - -# Visual C++ cache files -ipch/ -*.aps -*.ncb -*.opendb -*.opensdf -*.sdf -*.cachefile -*.VC.db -*.VC.VC.opendb - -# Visual Studio profiler -*.psess -*.vsp -*.vspx -*.sap - -# Visual Studio Trace Files -*.e2e - -# TFS 2012 Local Workspace -$tf/ - -# Guidance Automation Toolkit -*.gpState - -# ReSharper is a .NET coding add-in -_ReSharper*/ -*.[Rr]e[Ss]harper -*.DotSettings.user - -# TeamCity is a build add-in -_TeamCity* - -# DotCover is a Code Coverage Tool -*.dotCover - -# AxoCover is a Code Coverage Tool -.axoCover/* -!.axoCover/settings.json - -# Coverlet is a free, cross platform Code Coverage Tool -coverage*.json -coverage*.xml -coverage*.info - -# Visual Studio code coverage results -*.coverage -*.coveragexml - -# NCrunch -_NCrunch_* -.*crunch*.local.xml -nCrunchTemp_* - -# MightyMoose -*.mm.* -AutoTest.Net/ - -# Web workbench (sass) -.sass-cache/ - -# Installshield output folder -[Ee]xpress/ - -# DocProject is a documentation generator add-in -DocProject/buildhelp/ -DocProject/Help/*.HxT -DocProject/Help/*.HxC -DocProject/Help/*.hhc -DocProject/Help/*.hhk -DocProject/Help/*.hhp -DocProject/Help/Html2 -DocProject/Help/html - -# Click-Once directory -publish/ - -# Publish Web Output -*.[Pp]ublish.xml -*.azurePubxml -# Note: Comment the next line if you want to checkin your web deploy settings, -# but database connection strings (with potential passwords) will be unencrypted -*.pubxml -*.publishproj - -# Microsoft Azure Web App publish settings. Comment the next line if you want to -# checkin your Azure Web App publish settings, but sensitive information contained -# in these scripts will be unencrypted -PublishScripts/ - -# NuGet Packages -*.nupkg -# NuGet Symbol Packages -*.snupkg -# The packages folder can be ignored because of Package Restore -**/[Pp]ackages/* -# except build/, which is used as an MSBuild target. -!**/[Pp]ackages/build/ -# Uncomment if necessary however generally it will be regenerated when needed -#!**/[Pp]ackages/repositories.config -# NuGet v3's project.json files produces more ignorable files -*.nuget.props -*.nuget.targets - -# Microsoft Azure Build Output -csx/ -*.build.csdef - -# Microsoft Azure Emulator -ecf/ -rcf/ - -# Windows Store app package directories and files -AppPackages/ -BundleArtifacts/ -Package.StoreAssociation.xml -_pkginfo.txt -*.appx -*.appxbundle -*.appxupload - -# Visual Studio cache files -# files ending in .cache can be ignored -*.[Cc]ache -# but keep track of directories ending in .cache -!?*.[Cc]ache/ - -# Others -ClientBin/ -~$* -*~ -*.dbmdl -*.dbproj.schemaview -*.jfm -*.pfx -*.publishsettings -orleans.codegen.cs - -# Including strong name files can present a security risk -# (https://github.com/github/gitignore/pull/2483#issue-259490424) -#*.snk - -# Since there are multiple workflows, uncomment next line to ignore bower_components -# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622) -#bower_components/ - -# RIA/Silverlight projects -Generated_Code/ - -# Backup & report files from converting an old project file -# to a newer Visual Studio version. Backup files are not needed, -# because we have git ;-) -_UpgradeReport_Files/ -Backup*/ -UpgradeLog*.XML -UpgradeLog*.htm -ServiceFabricBackup/ -*.rptproj.bak - -# SQL Server files -*.mdf -*.ldf -*.ndf - -# Business Intelligence projects -*.rdl.data -*.bim.layout -*.bim_*.settings -*.rptproj.rsuser -*- [Bb]ackup.rdl -*- [Bb]ackup ([0-9]).rdl -*- [Bb]ackup ([0-9][0-9]).rdl - -# Microsoft Fakes -FakesAssemblies/ - -# GhostDoc plugin setting file -*.GhostDoc.xml - -# Node.js Tools for Visual Studio -.ntvs_analysis.dat -node_modules/ - -# Visual Studio 6 build log -*.plg - -# Visual Studio 6 workspace options file -*.opt - -# Visual Studio 6 auto-generated workspace file (contains which files were open etc.) -*.vbw - -# Visual Studio LightSwitch build output -**/*.HTMLClient/GeneratedArtifacts -**/*.DesktopClient/GeneratedArtifacts -**/*.DesktopClient/ModelManifest.xml -**/*.Server/GeneratedArtifacts -**/*.Server/ModelManifest.xml -_Pvt_Extensions - -# Paket dependency manager -.paket/paket.exe -paket-files/ - -# FAKE - F# Make -.fake/ - -# CodeRush personal settings -.cr/personal - -# Python Tools for Visual Studio (PTVS) -__pycache__/ -*.pyc - -# Cake - Uncomment if you are using it -# tools/** -# !tools/packages.config - -# Tabs Studio -*.tss - -# Telerik's JustMock configuration file -*.jmconfig - -# BizTalk build output -*.btp.cs -*.btm.cs -*.odx.cs -*.xsd.cs - -# OpenCover UI analysis results -OpenCover/ - -# Azure Stream Analytics local run output -ASALocalRun/ - -# MSBuild Binary and Structured Log -*.binlog - -# NVidia Nsight GPU debugger configuration file -*.nvuser - -# MFractors (Xamarin productivity tool) working folder -.mfractor/ - -# Local History for Visual Studio -.localhistory/ - -# BeatPulse healthcheck temp database -healthchecksdb - -# Backup folder for Package Reference Convert tool in Visual Studio 2017 -MigrationBackup/ - -# Ionide (cross platform F# VS Code tools) working folder -.ionide/ - -# Fody - auto-generated XML schema -FodyWeavers.xsd \ No newline at end of file +# on your own machine, please. +/speech2/compile_commands.json diff --git a/Justfile b/Justfile new file mode 100644 index 0000000..81de9d8 --- /dev/null +++ b/Justfile @@ -0,0 +1,7 @@ +build: + dotnet build + make -C speech2 -j$(nproc) + +clean: + rm -rf SAPIServer/bin SAPIServer/obj + make -C speech2 clean diff --git a/README.md b/README.md index 3e51ba4..3de629f 100644 --- a/README.md +++ b/README.md @@ -2,6 +2,14 @@ Simple HTTP frontend API for Microsoft Speech API +## Building + +Requirements +- .NET SDK +- mingw-w64 toolchain built with `win32` thread model (`pthread` won't work) + +`just` should do the trick. + ## Running ``` @@ -27,4 +35,4 @@ Content-Type: application/json {"text":"Lorem ipsum doler sit amet...","voice":"Microsoft Sam"} ``` -Returns synthesized TTS audio as a wave-form file. \ No newline at end of file +Returns synthesized TTS audio as a wave-form file. diff --git a/SAPIServer/SAPIServer.csproj b/SAPIServer/SAPIServer.csproj index f0994c4..c3c4251 100644 --- a/SAPIServer/SAPIServer.csproj +++ b/SAPIServer/SAPIServer.csproj @@ -1,58 +1,15 @@ - - - + + - Debug - AnyCPU - {BF824074-4C4E-4DE1-8DCA-F022682B00E1} - Exe - SAPIServer - SAPIServer - v4.0 - 512 - true - publish\ - true - Disk - false - Foreground - 7 - Days - false - false - true - 0 - 1.0.0.%2a - false - false - true + + false + Exe + net40 - - AnyCPU - true - full - false - bin\Debug\ - DEBUG;TRACE - prompt - 4 - - - AnyCPU - pdbonly - true - bin\Release\ - TRACE - prompt - 4 - - - app.manifest - - - - ..\packages\Newtonsoft.Json.13.0.3\lib\net40\Newtonsoft.Json.dll - + + + @@ -62,23 +19,5 @@ - - - - - - - - - - - - - - False - .NET Framework 3.5 SP1 - false - - - - \ No newline at end of file + + diff --git a/SAPIServer/SAPIServer.vs.csproj b/SAPIServer/SAPIServer.vs.csproj new file mode 100644 index 0000000..f0994c4 --- /dev/null +++ b/SAPIServer/SAPIServer.vs.csproj @@ -0,0 +1,84 @@ + + + + + Debug + AnyCPU + {BF824074-4C4E-4DE1-8DCA-F022682B00E1} + Exe + SAPIServer + SAPIServer + v4.0 + 512 + true + publish\ + true + Disk + false + Foreground + 7 + Days + false + false + true + 0 + 1.0.0.%2a + false + false + true + + + AnyCPU + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + AnyCPU + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + app.manifest + + + + ..\packages\Newtonsoft.Json.13.0.3\lib\net40\Newtonsoft.Json.dll + + + + + + + + + + + + + + + + + + + + + + + + False + .NET Framework 3.5 SP1 + false + + + + \ No newline at end of file diff --git a/speech2/Makefile b/speech2/Makefile new file mode 100644 index 0000000..0886749 --- /dev/null +++ b/speech2/Makefile @@ -0,0 +1,36 @@ +include build/arch.mk +include build/configs.mk + +NAME = sapiserver + +BINDIR = bin/$(ARCH)/$(CONFIG) +OBJDIR = obj/$(ARCH)/$(CONFIG) + +# Any C++ file in src/ is automatically picked up. +CXXSRCS = $(wildcard src/*.cpp) $(wildcard src/*/*.cpp) +VPATH = $(dir $(CXXSRCS)) +OBJS = $(addprefix $(OBJDIR)/,$(notdir $(CXXSRCS:.cpp=.o))) + +.PHONY: all dumpinfo clean matrix + +all: $(BINDIR)/$(NAME).exe + +# dir rules +$(BINDIR)/: + echo -e "\e[95mMKDIR $@\e[0m" + mkdir -p $(BINDIR) + +$(OBJDIR)/: + echo -e "\e[95mMKDIR $@\e[0m" + mkdir -p $(OBJDIR) + +include build/rules.mk + +clean: + echo -e "\e[91mCleaning... \e[0m" + rm -rf $(BINDIR)/ $(OBJS) + +$V.SILENT: + +# Include dependency files. +-include $(OBJS:.o=.d) diff --git a/speech2/README.md b/speech2/README.md new file mode 100644 index 0000000..9a0412c --- /dev/null +++ b/speech2/README.md @@ -0,0 +1,3 @@ +# speech2 + +speech dll thing diff --git a/speech2/build/arch.mk b/speech2/build/arch.mk new file mode 100644 index 0000000..ab3078a --- /dev/null +++ b/speech2/build/arch.mk @@ -0,0 +1,19 @@ +x86_Valid=yes +x86_TRIPLET=i686-w64-mingw32 + +#x64_Valid=yes +#x64_TRIPLET=x86_64-w64-mingw32 + + +ifeq ($(ARCH),) +ARCH = x86 +endif + +ifneq ($($(ARCH)_Valid),yes) +$(error Please select a valid target) +endif + +# if we really need C +CC = $($(ARCH)_TRIPLET)-gcc +CXX = $($(ARCH)_TRIPLET)-g++ +WINDRES = $($(ARCH)_TRIPLET)-windres diff --git a/speech2/build/configs.mk b/speech2/build/configs.mk new file mode 100644 index 0000000..793dfbb --- /dev/null +++ b/speech2/build/configs.mk @@ -0,0 +1,23 @@ +# Base compiler flags. Only change if you *explicitly* know what you're doing. +BASE_CCFLAGS = -MMD -std=gnu17 -fpermissive -fno-pic -fno-pie -msse -Iinclude -Isrc -D_UCRT -D_WIN32_WINNT=0x0501 +BASE_CXXFLAGS = -MMD -std=c++20 -fpermissive -fno-pic -fno-pie -fno-rtti -msse -Iinclude -Isrc -Ithird_party -D_UCRT -D_WIN32_WINNT=0x0501 +BASE_LDFLAGS = -mwindows -static -static-libgcc -lkernel32 -lshell32 -luser32 -luuid -lole32 + +Release_Valid = yes +Release_CCFLAGS = -O3 -ffast-math -fomit-frame-pointer -DNDEBUG +Release_CXXFLAGS = -O3 -ffast-math -fomit-frame-pointer -DNDEBUG +Release_LDFLAGS = -s + +Debug_Valid = yes +Debug_CCFLAGS = -O0 -g -DDEBUG +Debug_CXXFLAGS = -O0 -g -DDEBUG +Debug_LDFLAGS = + +# select a default configuration or validate configuration +ifeq ($(CONFIG),) +CONFIG = Release +endif + +ifneq ($($(CONFIG)_Valid),yes) +$(error Please select a valid configuration) +endif diff --git a/speech2/build/rules.mk b/speech2/build/rules.mk new file mode 100644 index 0000000..2f3677b --- /dev/null +++ b/speech2/build/rules.mk @@ -0,0 +1,20 @@ +# TODO: Link DLL +$(BINDIR)/$(NAME).exe: $(BINDIR)/ $(OBJDIR)/ $(OBJS) + echo -e "\e[92mLinking binary $@\e[0m" + $(CXX) $(OBJS) $(BASE_LDFLAGS) $($(CONFIG)_LDFLAGS) -o $@ + +$(OBJDIR)/%.o: %.c + echo -e "\e[94mCompiling C source file $< ($@)\e[0m" + $(CC) -c $(BASE_CCFLAGS) $($(CONFIG)_CCFLAGS) $< -o $@ + +$(OBJDIR)/%.o: %.cpp + echo -e "\e[94mCompiling C++ source file $< ($@)\e[0m" + $(CC) -c $(BASE_CXXFLAGS) $($(CONFIG)_CXXFLAGS) $< -o $@ + +$(OBJDIR)/%.o: %.S + echo -e "\e[94mAssembling $< ($@)\e[0m" + $(CC) -xassembler-with-cpp -c $(BASE_CCFLAGS) $($(CONFIG)_CCFLAGS) $< -o $@ + +$(OBJDIR)/%.o: %.rc + echo -e "\e[94mCompiling Windows resource script $<\e[0m" + $(WINDRES) -Iinclude $< -o $@ diff --git a/speech2/compdb.sh b/speech2/compdb.sh new file mode 100755 index 0000000..0643774 --- /dev/null +++ b/speech2/compdb.sh @@ -0,0 +1,2 @@ +make clean +bear -- make diff --git a/speech2/src/base/BCondVar.cpp b/speech2/src/base/BCondVar.cpp new file mode 100644 index 0000000..45fb131 --- /dev/null +++ b/speech2/src/base/BCondVar.cpp @@ -0,0 +1,156 @@ +#include +#include +#include + +#include + +namespace base::osdep { + + enum class MemoryOrder { + Relaxed = __ATOMIC_RELAXED, + Consume = __ATOMIC_CONSUME, + Acquire = __ATOMIC_ACQUIRE, + Release = __ATOMIC_RELEASE, + AcqRel = __ATOMIC_ACQ_REL, + SeqCst = __ATOMIC_SEQ_CST + }; + + // TODO: public! + template + struct BAtomic { + BAtomic() = default; + BAtomic(const T value) : + value(value) { + + } + + inline T fetch_add(T val, MemoryOrder order = DefaultOrder) volatile noexcept { + return __atomic_fetch_add(&value, val, static_cast(order)); + } + + inline T fetch_sub(T val, MemoryOrder order = DefaultOrder) volatile noexcept { + volatile T* ptr = &value; + return __atomic_fetch_sub(ptr, val, static_cast(order)); + } + + void store(T desiredValue, MemoryOrder order = DefaultOrder) volatile noexcept { + __atomic_store_n(&value, desiredValue, order); + } + + T operator++() volatile noexcept { + return fetch_add(1) + 1; + } + + T operator++(int) volatile noexcept { + return fetch_add(1); + } + + T operator--() volatile noexcept { + return fetch_sub(1) - 1; + } + + T operator--(int) volatile noexcept { + return fetch_sub(1); + } + + T operator-=(T val) volatile noexcept { + return fetch_sub(val) - val; + } + + T operator+=(T val) volatile noexcept{ + return fetch_add(val) + val; + } + private: + T value; + }; + + struct BCondVar { + BCondVar() { + hNotifyAllEvent = CreateEventA(nullptr, TRUE, FALSE, nullptr); + hNotifyOneEvent = CreateEventA(nullptr, FALSE, FALSE, nullptr); + + waiterMutex = BMutex_Create(true); + } + + ~BCondVar() { + if(hNotifyAllEvent != INVALID_HANDLE_VALUE) + CloseHandle(hNotifyAllEvent); + if(hNotifyOneEvent != INVALID_HANDLE_VALUE) + CloseHandle(hNotifyOneEvent); + + BMutex_Destroy(waiterMutex); + } + + void SignalOne() { + SetEvent(hNotifyOneEvent); + } + + void SignalAll() { + SetEvent(hNotifyAllEvent); + } + + void Wait(bool(*predicate)(void* ctx), void* ctx) { + HANDLE handles[2] = { hNotifyAllEvent, hNotifyOneEvent }; + + BMutex_Lock(waiterMutex); + waiterSemaphore++; + BMutex_Unlock(waiterMutex); + + while(!predicate(ctx)) { + switch(WaitForMultipleObjects(2, &handles[0], FALSE, INFINITE)) { + + case WAIT_OBJECT_0: // hNotifyAllEvent + BMutex_Lock(waiterMutex); + if(waiterSemaphore-- == 0) { + ResetEvent(hNotifyAllEvent); + } + BMutex_Unlock(waiterMutex); + break; + + case WAIT_OBJECT_0 + 1: // hNotifyOneEvent + continue; + break; + + case WAIT_FAILED: + return; + break; + + default: + return; + break; + } + } + } + + HANDLE hNotifyAllEvent{}; + HANDLE hNotifyOneEvent{}; + + // Semaphore for SignalAll(). + BMutex* waiterMutex; + BAtomic waiterSemaphore{0}; + }; + + BCondVar* BCondVar_Create() { + return new BCondVar(); + } + + /// Signals one thread. + void BCondVar_SignalOne(BCondVar* cond) { + cond->SignalOne(); + } + + // Signals all threads. + void BCondVar_SignalAll(BCondVar* cond) { + cond->SignalAll(); + } + + + // Waits. Call this on all threads. + void BCondVar_Wait(BCondVar* condvar, bool(*predicate)(void* ctx), void* ctx) { + condvar->Wait(predicate, ctx); + } + + void BCondVar_Destroy(BCondVar* condvar) { + delete condvar; + } +} diff --git a/speech2/src/base/BMutex.cpp b/speech2/src/base/BMutex.cpp new file mode 100644 index 0000000..a7860b7 --- /dev/null +++ b/speech2/src/base/BMutex.cpp @@ -0,0 +1,53 @@ +#include +#include + +namespace base::osdep { + + struct BMutex { + CRITICAL_SECTION critSec {}; + bool recursive{}; + + BMutex(bool recursive = false) : recursive(recursive) { InitializeCriticalSection(&critSec); } + + ~BMutex() { + if(critSec.LockCount != 0) + Unlock(); + + DeleteCriticalSection(&critSec); + } + + inline void Lock() { + + // recursive lock check + if(!recursive) { + if(critSec.LockCount + 1 > 1) { + ExitProcess(0x69420); + return; + } + } + + EnterCriticalSection(&critSec); + } + + inline void Unlock() { LeaveCriticalSection(&critSec); } + }; + + BMutex* BMutex_Create(bool recursive) { + return new BMutex(recursive); + } + + void BMutex_Destroy(BMutex* mutex) { + delete mutex; + } + + void BMutex_Lock(BMutex* mutex) { + if(mutex) + mutex->Lock(); + } + + void BMutex_Unlock(BMutex* mutex) { + if(mutex) + mutex->Unlock(); + } + +} // namespace base::osdep diff --git a/speech2/src/base/BThread.cpp b/speech2/src/base/BThread.cpp new file mode 100644 index 0000000..8a811bd --- /dev/null +++ b/speech2/src/base/BThread.cpp @@ -0,0 +1,38 @@ +#include +#include + +namespace base::osdep { + + struct BThread { + HANDLE hThread; + unsigned dwId; + }; + + BThreadHandle BThread_Spawn(BThreadFunc ep, void* arg, unsigned stackSize) { + unsigned dwID{}; + auto res = _beginthreadex(nullptr, stackSize, static_cast<_beginthreadex_proc_type>(ep), arg, 0, &dwID); + + if(res == -1) + return nullptr; + + auto handle = new BThread(); + handle->hThread = reinterpret_cast(res); + handle->dwId = dwID; + + return handle; + } + + unsigned BThread_GetID(BThreadHandle handle) { + if(handle) + return handle->dwId; + + return -1; + } + + void BThread_Join(BThreadHandle handle) { + if(handle) { + auto res = WaitForSingleObject(handle->hThread, INFINITE); + return; + } + } +} // namespace base::osdep diff --git a/speech2/src/base/BThread.hpp b/speech2/src/base/BThread.hpp new file mode 100644 index 0000000..e560dee --- /dev/null +++ b/speech2/src/base/BThread.hpp @@ -0,0 +1,64 @@ +// BThread - it's like GThread, but mentally sane! +// (and without __, pthreads, and other smells.) +#pragma once + +#ifdef _WIN32 +#include +#else +#error BThread only supports Windows. +#endif + +namespace base::osdep { + + // Threads + + struct BThread; + + using BThreadHandle = BThread*; + +#ifdef _WIN32 + using BThreadNativeHandle = HANDLE; +#endif + + using BThreadFunc = + unsigned WINAPI (*)(void* argp); + + // Spawns a new thread, with the given entry point, argument, and stack size. + BThreadHandle BThread_Spawn(BThreadFunc ep, void* arg = nullptr, unsigned stackSize = 0); + + // TODO BThread_Native(BThreadHandle handle) + + unsigned BThread_GetID(BThreadHandle handle); + + // Joins (waits for this thread to terminate) this thread. + void BThread_Join(BThreadHandle handle); + + // Mutexes + + struct BMutex; + + // if recursive is true, this BMutex will be a recursive mutex, + // and multiple threads are allowed to lock it. + BMutex* BMutex_Create(bool recursive); + + void BMutex_Lock(BMutex* mutex); + void BMutex_Unlock(BMutex* mutex); + + void BMutex_Destroy(BMutex* mutex); + + struct BCondVar; + + BCondVar* BCondVar_Create(); + + /// Signals one thread. + void BCondVar_SignalOne(BCondVar* cond); + + // Signals all threads. + void BCondVar_SignalAll(BCondVar* cond); + + + // Waits. Call this on all threads. + void BCondVar_Wait(BCondVar* condvar, bool(*predicate)(void* ctx), void* ctx); + + void BCondVar_Destroy(BCondVar* condvar); +} diff --git a/speech2/src/base/Mutex.cpp b/speech2/src/base/Mutex.cpp new file mode 100644 index 0000000..9f9bb08 --- /dev/null +++ b/speech2/src/base/Mutex.cpp @@ -0,0 +1,21 @@ +#include + +namespace base { + + Mutex::Mutex() { + mutex = osdep::BMutex_Create(false); + } + + Mutex::~Mutex() { + osdep::BMutex_Destroy(mutex); + } + + void Mutex::Lock() { + osdep::BMutex_Lock(mutex); + } + + void Mutex::Unlock() { + osdep::BMutex_Unlock(mutex); + } + +} // namespace base diff --git a/speech2/src/base/Mutex.hpp b/speech2/src/base/Mutex.hpp new file mode 100644 index 0000000..3a335b7 --- /dev/null +++ b/speech2/src/base/Mutex.hpp @@ -0,0 +1,47 @@ +#pragma once +#include + +namespace base { + + /** + * A mutex. + */ + struct Mutex { + Mutex(); + ~Mutex(); + + Mutex(const Mutex&) = delete; + Mutex(Mutex&&) = default; + + void Lock(); + void Unlock(); + + // impl data. + private: + osdep::BMutex* mutex; + }; + + template + concept Lockable = requires(T t) { + { t.Lock() }; + { t.Unlock() }; + }; + + /** + * Scoped lock guard. + */ + template + struct LockGuard { + LockGuard(Mut& mtx) + : mutex(mtx) { + mutex.Lock(); + } + + ~LockGuard() { + mutex.Unlock(); + } + private: + Mut& mutex; + }; + +} diff --git a/speech2/src/base/README.md b/speech2/src/base/README.md new file mode 100644 index 0000000..ae85d4e --- /dev/null +++ b/speech2/src/base/README.md @@ -0,0 +1,10 @@ +# base/ + +This basically contains replacements of stuff from the standard library that we can't use on Windows XP because mingw sucks: + +- Mutex +- Thread +- ManualResetEvent +- AutoResetEvent + +Oh and some stuff for dealing with COM diff --git a/speech2/src/base/SaneWin.hpp b/speech2/src/base/SaneWin.hpp new file mode 100644 index 0000000..70c22e9 --- /dev/null +++ b/speech2/src/base/SaneWin.hpp @@ -0,0 +1,6 @@ +// Sane windows.h +#pragma once +#define _WIN32_LEAN_AND_MEAN +#include +#include +#undef _WIN32_LEAN_AND_MEAN diff --git a/speech2/src/base/Thread.cpp b/speech2/src/base/Thread.cpp new file mode 100644 index 0000000..1fe6bcf --- /dev/null +++ b/speech2/src/base/Thread.cpp @@ -0,0 +1,53 @@ +#include + +namespace base { + + /*static*/ unsigned Thread::EntryFunc(void* argp) { + auto invocable = static_cast(argp); + (*invocable)(); + + // Usually cross thread frees are a no-no, but the thread effectively + // owns the invocable once it has been passed to it, so /shrug. + delete invocable; + return 0; + } + + Thread::~Thread() { + // Join thread on destruction, unless + // it has already been detached. + if(Joinable()) + Join(); + } + + unsigned Thread::Id() const { + return osdep::BThread_GetID(threadHandle); + } + + bool Thread::Joinable() const { + if(!threadHandle) + return false; + + return joinable; + } + + void Thread::Detach() { + threadHandle = nullptr; + joinable = false; + } + + void Thread::Join() { + if(Joinable()) + osdep::BThread_Join(threadHandle); + } + + + void Thread::SpawnImpl(ThreadInvocable* pInvocable) { + threadHandle = osdep::BThread_Spawn(&Thread::EntryFunc, static_cast(pInvocable), 0); + if(threadHandle != nullptr) + joinable = true; + else { + // Thread failed to create, delete the invocable so we don't leak memory. + delete pInvocable; + } + } +} diff --git a/speech2/src/base/Thread.hpp b/speech2/src/base/Thread.hpp new file mode 100644 index 0000000..aa9c576 --- /dev/null +++ b/speech2/src/base/Thread.hpp @@ -0,0 +1,70 @@ +#pragma once +#include +#include +#include + +namespace base { + +// TODO: Put this in a bits header. +#define __BASE_FWD(T) static_cast + + /// A thread. + struct Thread { + using NativeHandle = osdep::BThreadHandle; + + Thread() = default; + + template + explicit Thread(Func&& func, Args&&... args) { + struct FuncInvocable final : ThreadInvocable { + Func&& func; + std::tuple args; + + constexpr FuncInvocable(Func&& func, Args&&... args) : func(__BASE_FWD(Func)(func)), args({ __BASE_FWD(Args)(args)... }) {} + + constexpr void operator()() override { + std::apply([&](auto&&... argt) { func(__BASE_FWD(Args)(argt)...); }, args); + } + }; + + SpawnImpl(new FuncInvocable(__BASE_FWD(Func)(func), __BASE_FWD(Args)(args)...)); + } + + Thread(const Thread&) = delete; + Thread(Thread&&) = default; + + ~Thread(); + + // TODO: Actually return a OS native thread handle, instead of a BThreads handle. + NativeHandle Native() const { return threadHandle; } + + unsigned Id() const; + + bool Joinable() const; + + // Detaches the native thread. + // Once this function is called the thread + // will no longer be joinable. + void Detach(); + + void Join(); + + private: + // For type erasure. I know it's bad or whatever, but generally, + // it shouldn't be a big enough deal. + struct ThreadInvocable { + virtual ~ThreadInvocable() = default; + virtual void operator()() = 0; + }; + + // Takes the invocable and spawns le epic heckin thread. + void SpawnImpl(ThreadInvocable* pInvocable); + + // Actually recieves a pointer to a [ThreadInvocable] on the heap, + // synthesized from a given function. + static unsigned WINAPI EntryFunc(void* args); + + NativeHandle threadHandle {}; + bool joinable { false }; // implicitly false if there's no thread. + }; +} // namespace base diff --git a/speech2/src/base/comptr.hpp b/speech2/src/base/comptr.hpp new file mode 100644 index 0000000..97cbbab --- /dev/null +++ b/speech2/src/base/comptr.hpp @@ -0,0 +1,71 @@ +#pragma once +#include + +#include + +namespace base { + + // A relatively sane (non-intrinsic) COM smart pointer + // TODO: Allow downcasting to ComPtr (all COM objects implement this anyways) + // + template + struct ComPtr { + //constexpr ComPtr() = default; + + //explicit ComPtr(T* t) : interface_ptr(t) {} + constexpr ComPtr() : interface_ptr(nullptr) {} + + // Assignment won't require AddRef() because most COM interfaces + // will automatically AddRef() upon querying them. + ComPtr& operator=(T* interface_) { + // Release an existing interface. + if(interface_ptr) { + printf("ComPtr::operator= releasing %p (guid %08x)\n", interface_ptr, *iid); + interface_ptr->Release(); + } + + interface_ptr = interface_; + return *this; + } + + ComPtr(const ComPtr& copy) { + if(interface_ptr) { + interface_ptr->AddRef(); + interface_ptr = copy.interface_ptr; + } + } + + ~ComPtr() { + if(interface_ptr) { + printf("ComPtr::~ComPtr releasing %p (guid %08x)\n", interface_ptr, *iid); + interface_ptr->Release(); + } + } + + // Helper to CoCreateInstance() on this pointer + HRESULT CreateInstance(REFCLSID clsid, DWORD ctx) { + return CoCreateInstance(clsid, nullptr, CLSCTX_ALL, *iid, reinterpret_cast(&interface_ptr)); + } + + // smart pointer overrides + + constexpr T** operator&() { return &interface_ptr; } + constexpr T* operator->() { return interface_ptr; } + constexpr operator T*() const { return interface_ptr; } + + T* Get() { return interface_ptr; } + const T* Get() const { return interface_ptr; } + + // release pointer - you need to manage it yourself or put it + // into another ComSmartPtr then + T* ReleasePtr() { + auto old = interface_ptr; + interface_ptr = nullptr; + return old; + } + + private: + T* interface_ptr { nullptr }; + }; + +} // namespace base diff --git a/speech2/src/base/comresult.hpp b/speech2/src/base/comresult.hpp new file mode 100644 index 0000000..a927a1a --- /dev/null +++ b/speech2/src/base/comresult.hpp @@ -0,0 +1,17 @@ +#pragma once + +#include +#include + +template +struct ComResult { + +private: + + using VariantType = std::variant< + HRESULT, + T + >; + + VariantType storage; +}; diff --git a/speech2/src/main.cpp b/speech2/src/main.cpp new file mode 100644 index 0000000..134d7b7 --- /dev/null +++ b/speech2/src/main.cpp @@ -0,0 +1,120 @@ +#include +#include + +#include +#include +#include + +#include "speechapi.hpp" + +// args +// -v (voice to use) +// -s 4|5 (what SAPI version to use) +// -p 0..100 (pitch) +// -s 0..100 +// [message] + +int main(int argc, char** argv) { +#if 1 + if(FAILED(CoInitialize(nullptr))) { + printf("Couldn't initalize COM\n"); + return 1; + } + + auto api = ISpeechAPI::CreateSapi4(); + if(!api) { + printf("Couldn't allocate memory for speech API\n"); + return 1; + } + + if(auto hRes = api->Initialize(); FAILED(hRes)) { + printf("Couldn't initalize SAPI 4 (hr: %08x)\n", hRes); + return 1; + } + + #if 1 + auto voices = api->GetVoices(); + printf("Available voices:\n"); + for(auto& voice : voices) { + auto& guid = voice.guid; + + printf("%s (GUID {%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X})\n", voice.voiceName.c_str(), guid.Data1, guid.Data2, guid.Data3, + guid.Data4[0], guid.Data4[1], guid.Data4[2], guid.Data4[3], guid.Data4[4], guid.Data4[5], guid.Data4[6], guid.Data4[7]); + } + #endif + + if(auto hRes = api->SelectVoice("Sam"); FAILED(hRes)) { + printf("Test: Couldn't select Microsoft Sam\n"); + return 1; + } else { + printf("Test: Selected Microsoft Sam\n"); + } + + #if 1 + if(auto hRes = api->SelectVoice("Mike"); FAILED(hRes)) { + printf("Test: Couldn't select Microsoft Mike\n"); + return 1; + } else { + printf("Test: Seleced Microsoft Mike\n"); + } + #endif + + printf("Test: Selected voices successfully\n"); + + printf("Test: Destroying voice\n"); + delete api; + + CoUninitialize(); +#endif + +// condvar/threading tests +#if 0 + static auto cv = base::osdep::BCondVar_Create(); + static auto PrintMutex = base::Mutex{}; + static auto n = 0; + //auto n = 0; + + Sleep(100); + + base::Thread t([]() { + base::osdep::BCondVar_Wait(cv, [](void* ctx) { + base::LockGuard lk(PrintMutex); + printf("t: wait predicate called %d\n", *static_cast(ctx)); + return *static_cast(ctx) == 4; + }, static_cast(&n)); + + { + base::LockGuard lk(PrintMutex); + printf("t: condvar exited wait!\n"); + } + + }); + + base::Thread t2([]() { + base::osdep::BCondVar_Wait(cv, [](void* ctx) { + base::LockGuard lk(PrintMutex); + printf("t2: wait predicate called %d\n", *static_cast(ctx)); + return *static_cast(ctx) == 4; + }, static_cast(&n)); + + { + base::LockGuard lk(PrintMutex); + printf("t2: condvar exited wait!\n"); + } + + }); + + for(auto i = 0; i < 4; ++i) { + base::osdep::BCondVar_SignalOne(cv); + n++; + Sleep(100); + } + + t2.Join(); + t.Join(); + base::osdep::BCondVar_Destroy(cv); + +#endif + + return 0; +} diff --git a/speech2/src/sapi4/api_sapi4.cpp b/speech2/src/sapi4/api_sapi4.cpp new file mode 100644 index 0000000..532ce01 --- /dev/null +++ b/speech2/src/sapi4/api_sapi4.cpp @@ -0,0 +1,84 @@ +#include + +#include + +#include "sapi4/audio_buffer.hpp" +#include "sapi4/include/speech.h" +#include "speechapi.hpp" + +struct SpeechAPI_SAPI4 : public ISpeechAPI { + virtual ~SpeechAPI_SAPI4() { + printf("~SpeechAPI_SAPI4\n"); + // if(pAudioOut) + // pAudioOut->AddRef(); + + if(pCentral) + pCentral->Release(); + }; + + HRESULT Initialize() override { + HRESULT hRes; + + hRes = pEnum.CreateInstance(CLSID_TTSEnumerator, CLSCTX_INPROC); + if(FAILED(hRes)) + return hRes; + + return S_OK; + } + + std::vector GetVoices() override { + TTSMODEINFO found {}; + std::vector ret; + + while(!pEnum->Next(1, &found, nullptr)) { + ret.push_back({ .guid = found.gModeID, .voiceName = found.szModeName }); + } + + pEnum->Reset(); + return ret; + } + + HRESULT SelectVoiceImpl(const GUID& guid) { + pAudioOut = new AudioOutBuffer(); + + if(pCentral) + pCentral->Release(); + + ITTSCentral* central; + if(auto hr = pEnum->Select(guid, ¢ral, static_cast(pAudioOut)); FAILED(hr)) + return hr; + + pCentral = central; + + // From Microsoft Speech SDK 4.0 documentation: + // The engine will AddRef the interface, and release the interface when the engine is destroyed. + // Because of this the application will need to call Release on the audio object after the select call or audio objects will be leaked. + pAudioOut->Release(); + return S_OK; + } + + HRESULT SelectVoice(std::string_view voiceName) override { + TTSMODEINFO found {}; + + while(!pEnum->Next(1, &found, nullptr)) { + if(voiceName == found.szModeName) { + return SelectVoiceImpl(found.gModeID); + } + } + + pEnum->Reset(); + + return S_OK; + } + + private: + base::ComPtr pEnum; + ITTSCentral* pCentral { nullptr }; + + // The above comment is also why this isn't a ComPtr. + AudioOutBuffer* pAudioOut { nullptr }; +}; + +ISpeechAPI* ISpeechAPI::CreateSapi4() { + return new SpeechAPI_SAPI4(); +} diff --git a/speech2/src/sapi4/audio_buffer.cpp b/speech2/src/sapi4/audio_buffer.cpp new file mode 100644 index 0000000..c618054 --- /dev/null +++ b/speech2/src/sapi4/audio_buffer.cpp @@ -0,0 +1,185 @@ +#include "audio_buffer.hpp" + +#include +#include + +// Implements IAudioDest. +struct AudioOutBuffer::Dest : public IAudioDest { + Dest(AudioOutBuffer* pOut) : pOut(pOut) {} + ~Dest() = default; + + // IUnknown + STDMETHODIMP QueryInterface(const IID& riid, LPVOID* ppvObj) noexcept override { return pOut->QueryInterface(riid, ppvObj); } + + STDMETHODIMP_(ULONG) AddRef() noexcept override { + m_iRefCount++; + return pOut->AddRef(); + } + + STDMETHODIMP_(ULONG) Release() noexcept override { + m_iRefCount--; + return pOut->Release(); + } + + // IAudioDest + + STDMETHODIMP FreeSpace(DWORD* pFree, BOOL* pEOF) noexcept override { return E_NOTIMPL; } + + STDMETHODIMP DataSet(PVOID pBuffer, DWORD dwSize) noexcept override { + // TODO + printf("AudioOutBuffer::Dest::DataSet()\n"); + return E_NOTIMPL; + } + + STDMETHODIMP BookMark(DWORD pos) noexcept override { + // Ignored + return S_OK; + } + + private: + AudioOutBuffer* pOut; + ULONG m_iRefCount{}; +}; + +// Implements IAudio. +struct AudioOutBuffer::Audio : public IAudio { + Audio(AudioOutBuffer* pOut) : pOut(pOut) {} + ~Audio() { + }; + + // IUnknown + STDMETHODIMP QueryInterface(const IID& riid, LPVOID* ppvObj) noexcept override { return pOut->QueryInterface(riid, ppvObj); } + + STDMETHODIMP_(ULONG) AddRef() noexcept override { + m_iRefCount++; + return pOut->AddRef(); + } + + STDMETHODIMP_(ULONG) Release() noexcept override { + m_iRefCount--; + return pOut->Release(); + } + + // IAudio + + STDMETHODIMP Flush() noexcept override { return S_OK; } + + STDMETHODIMP LevelGet(DWORD* pLevel) noexcept override { return E_NOTIMPL; } + + STDMETHODIMP LevelSet(DWORD level) noexcept override { return E_NOTIMPL; } + + STDMETHODIMP PassNotify(PVOID pSink, IID iid) noexcept override { + printf("AudioOutBuffer::Audio::PassNotify() %p\n", pSink); + if(pSink == nullptr) { + return E_INVALIDARG; + } + + if(iid != IID_IAudioDestNotifySink) + return AUDERR_INVALIDNOTIFYSINK; + + pOut->m_pDestNotifySink = static_cast(pSink); + return S_OK; + } + + STDMETHODIMP PosnGet(PQWORD pos) noexcept override { + if(!pos) + return E_POINTER; + *pos = pOut->m_BufferWritten; + return S_OK; + } + + STDMETHODIMP Claim() noexcept override { return S_OK; } + + STDMETHODIMP UnClaim() noexcept override { return S_OK; } + + STDMETHODIMP Start() noexcept override { + // TODO + return S_OK; + } + + STDMETHODIMP Stop() noexcept override { + // TODO + return S_OK; + } + + STDMETHODIMP TotalGet(PQWORD total) noexcept override { return PosnGet(total); } + + STDMETHODIMP ToFileTime(PQWORD time, FILETIME* out) noexcept override { return E_NOTIMPL; } + + STDMETHODIMP WaveFormatGet(SDATA* pOut) noexcept override { + // TODO + + //IMalloc* pMalloc { nullptr }; + //if(auto hr = CoGetMalloc(1, &pMalloc); FAILED(hr)) + // return hr; + return S_OK; + } + + STDMETHODIMP WaveFormatSet(SDATA data) noexcept override { + if(!data.pData) + return E_INVALIDARG; + return S_OK; + } + + private: + AudioOutBuffer* pOut; + + ULONG m_iRefCount{}; +}; + +AudioOutBuffer::AudioOutBuffer() { + printf("AudioOutBuffer() %p\n", this); + m_Audio = new AudioOutBuffer::Audio(this); + m_AudioDestBuffer = new AudioOutBuffer::Dest(this); +} + +AudioOutBuffer::~AudioOutBuffer() { + printf("~AudioOutBuffer() %p\n", this); + if(m_AudioDestBuffer) + delete m_AudioDestBuffer; + + if(m_Audio) + delete m_Audio; +} + +// IUnknown +STDMETHODIMP AudioOutBuffer::QueryInterface(const IID& riid, LPVOID* ppvObj) noexcept { + if(!ppvObj) + return E_NOINTERFACE; + + *ppvObj = nullptr; + + // This object only directly implements IUnknown, and proxies + // to other implementation objects for other interfaces. + if(riid == IID_IUnknown) { + *ppvObj = static_cast(this); + AddRef(); + return S_OK; + } + + // Return implementations + if(riid == IID_IAudio) { + *ppvObj = static_cast(m_Audio); + //m_Audio->AddRef(); + return S_OK; + } else if(riid == IID_IAudioDest) { + *ppvObj = static_cast(m_AudioDestBuffer); + //m_AudioDestBuffer->AddRef(); + return S_OK; + } + + return E_NOINTERFACE; +} + +STDMETHODIMP_(ULONG) AudioOutBuffer::AddRef() { + return InterlockedIncrement(&m_iRefCount); +} + +STDMETHODIMP_(ULONG) AudioOutBuffer::Release() { + auto ulRefCount = InterlockedDecrement(&m_iRefCount); + if(ulRefCount == 0) { + printf("Deleting release AudioOutBuffer\n"); + delete this; + } + return ulRefCount; +} diff --git a/speech2/src/sapi4/audio_buffer.hpp b/speech2/src/sapi4/audio_buffer.hpp new file mode 100644 index 0000000..9747311 --- /dev/null +++ b/speech2/src/sapi4/audio_buffer.hpp @@ -0,0 +1,43 @@ +#pragma once +#include +#include "base/comptr.hpp" +#include "sapi4/include/speech.h" + +// Implementation of SAPI 4 IAudio(Dest) to spit out wave format data to a buffer +// TODO: out-line definition so other components can call methods they need +struct AudioOutBuffer : public IUnknown { + + // Implements IAudioDest. + struct Dest; + struct Audio; + + AudioOutBuffer(); + virtual ~AudioOutBuffer(); + + AudioOutBuffer(const AudioOutBuffer&) = delete; + AudioOutBuffer(AudioOutBuffer&&) = delete; + + // IUnknown + STDMETHODIMP QueryInterface(const IID& riid, LPVOID* ppvObj) noexcept override; + STDMETHODIMP_(ULONG) AddRef() override; + STDMETHODIMP_(ULONG) Release() override; + + private: + ULONG m_iRefCount{}; + + Dest* m_AudioDestBuffer{}; + Audio* m_Audio{}; + + enum class State { + Clear, + WroteHeader, + WritingWaveData, + Done + }; + + //base::ComPtr m_pDestNotifySink{}; + IAudioDestNotifySink* m_pDestNotifySink{nullptr}; + + QWORD m_BufferWritten{}; + +}; diff --git a/speech2/src/sapi4/guid_sapi4.cpp b/speech2/src/sapi4/guid_sapi4.cpp new file mode 100644 index 0000000..ef122a4 --- /dev/null +++ b/speech2/src/sapi4/guid_sapi4.cpp @@ -0,0 +1,6 @@ +// This file declares all the SAPI 4.0 GUID's. + +#include +#include + +#include "sapi4/include/speech.h" diff --git a/speech2/src/speechapi.hpp b/speech2/src/speechapi.hpp new file mode 100644 index 0000000..854d6a7 --- /dev/null +++ b/speech2/src/speechapi.hpp @@ -0,0 +1,29 @@ +#include +#include +#include + +/// base class for access to text-to-speech APIs. +struct ISpeechAPI { + + struct VoiceInfo { + GUID guid{}; // Optional. May not be filled out if th e + std::string voiceName; + }; + + virtual ~ISpeechAPI() = default; + + /// Creates a implementation of SpeechAPI for SAPI 4. + /// COM must be initalized before calling this function. + static ISpeechAPI* CreateSapi4(); + + /// Performs the bare level of initalization required to use the speech API + virtual HRESULT Initialize() = 0; + + virtual std::vector GetVoices() = 0; + + /// Selects a voice. + virtual HRESULT SelectVoice(std::string_view voiceName) = 0; + + + //virtual HRESULT Speak(LPCSTR text, char** pOutputBuffer, size_t* pOutSize) = 0; +}; diff --git a/speech2/third_party/README.md b/speech2/third_party/README.md new file mode 100644 index 0000000..dd74b52 --- /dev/null +++ b/speech2/third_party/README.md @@ -0,0 +1,4 @@ +Files in this directory are the intellectual property of: + +- sapi4: Microsoft Speech SDK 4.0.4.2512 +- sapi5: Microsoft Speech SDK 5.1 diff --git a/speech2/third_party/sapi4/include/buildnum.h b/speech2/third_party/sapi4/include/buildnum.h new file mode 100644 index 0000000..48faca0 --- /dev/null +++ b/speech2/third_party/sapi4/include/buildnum.h @@ -0,0 +1,63 @@ +/* buildnum.h*/ + + +#ifndef BUILDNUM_H +#define BUILDNUM_H +/* NOTE: To change build number, change the definitions + * of both BN_BN and BUILD_NUMBER. The rest will use + * the BN_BN definition. + * + * Change log: + */ +#define BN_BN 2512 +#define BN_MAJOR 4 +#define BN_STR "2512" +#ifndef BUILD_NUMBER +#define BUILD_NUMBER "4.0.4." BN_STR "\0" +#endif + +#ifndef JUSTDEFINES +char gszBuildNumber[] = "@(#) Microsoft Speech Build " BUILD_NUMBER; +#endif + +#ifndef BN_PRODUCT_VERSION +#define BN_PRODUCT_VERSION 4,0,4,BN_BN +#endif + +#ifndef BN_FILE_VER +#define BN_FILE_VERSION BN_PRODUCT_VERSION +#else +#define BN_FILE_VERSION BN_FILE_VER,BN_BN +#endif//BN_FILE_VER + +#ifndef BN_FILE_STR +#define BN_FILE_VERSION_STR BUILD_NUMBER +#else +#define BN_FILE_VERSION_STR BN_FILE_STR " " BN_STR "\0" +#endif + +#ifndef BN_FLAGS + #ifdef _DEBUG + #define BN_FLAGS VS_FF_DEBUG + #else + #ifdef TEST + #define BN_FLAGS VS_FF_PRERELEASE + #else + #define BN_FLAGS 0 + #endif + #endif +#endif + +#ifndef BN_FLAGSMASK +#define BN_FLAGSMASK VS_FF_PRERELEASE | VS_FF_DEBUG +#endif//BN_FLAGSMASK + +#ifndef BN_PRODUCTNAME +#define BN_PRODUCTNAME "Microsoft Speech\0" +#endif//BN_PRODUCTNAME + +#ifndef BN_COPYRIGHT +#define BN_COPYRIGHT "Copyright © 1991-1998 Microsoft Corporation\0" +#endif//BN_COPYRIGHT + +#endif // BUILDNUM_H diff --git a/speech2/third_party/sapi4/include/buildnum.rc b/speech2/third_party/sapi4/include/buildnum.rc new file mode 100644 index 0000000..6479e61 --- /dev/null +++ b/speech2/third_party/sapi4/include/buildnum.rc @@ -0,0 +1,69 @@ +/* Each RC file that includes this file for version + * stamping, must define the following items: + * + * #define VER_FILE_TYPE VFT_ // VFT_APP, VFT_DLL, VFT_DRV, VFT_VXD + * #define VER_FILE_DESC "Your app name\0" // don't forget the explicit null. + * #define VER_FILE_SUBTYPE 0 // All but driver should be 0 + * #define VER_FILE_INTNAME "\0" //don't forget the null. + * + * Change Log: + * 8/31/93 - benm - Tweaked to handle internal name correctly. + */ +#ifndef BUILDNUM_RC +#define BUILDNUM_RC + +#include +#ifndef VS_FF_DEBUG + #include +#endif + +// Default internal name to be same as file desc. +#ifndef VER_INTERNAL_NAME +#define VER_INTERNAL_NAME VER_FILE_DESC +#endif + +VS_VERSION_INFO VERSIONINFO +FILEVERSION BN_FILE_VERSION +PRODUCTVERSION BN_PRODUCT_VERSION +FILEFLAGSMASK BN_FLAGSMASK +FILEFLAGS BN_FLAGS +FILEOS VOS_NT_WINDOWS32 + +FILETYPE VER_FILE_TYPE +FILESUBTYPE VER_FILE_SUBTYPE + +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904E4" + BEGIN + VALUE "CompanyName", "Microsoft Corporation\0" + VALUE "FileDescription", VER_FILE_DESC + VALUE "FileVersion", BN_FILE_VERSION_STR + VALUE "InternalName", VER_INTERNAL_NAME + VALUE "LegalCopyright", BN_COPYRIGHT + VALUE "ProductName", BN_PRODUCTNAME + VALUE "ProductVersion", BUILD_NUMBER + VALUE "OriginalFilename", VER_ORIGINAL_FILENAME + END + + BLOCK "040904B0" + BEGIN + VALUE "CompanyName", "Microsoft Corporation\0" + VALUE "FileDescription", VER_FILE_DESC + VALUE "FileVersion", BN_FILE_VERSION_STR + VALUE "InternalName", VER_INTERNAL_NAME + VALUE "LegalCopyright", BN_COPYRIGHT + VALUE "ProductName", BN_PRODUCTNAME + VALUE "ProductVersion", BUILD_NUMBER + VALUE "OriginalFilename", VER_ORIGINAL_FILENAME + END + END + + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 1252 + END +END + +#endif // BUILDNUM_RC diff --git a/speech2/third_party/sapi4/include/spchtel.h b/speech2/third_party/sapi4/include/spchtel.h new file mode 100644 index 0000000..71a6166 --- /dev/null +++ b/speech2/third_party/sapi4/include/spchtel.h @@ -0,0 +1,313 @@ +/***************************************************************** +Spchtel.H - Header file to use the Microsoft Speech telephony controls. + +Copyright 1998 by Microsoft corporation.All rights reserved. +*/ + +#ifndef _SPCHTEL_H_ +#define _SPCHTEL_H_ + +// Flag values for the ITelControl::TypeSet call +#define INFOTYPE_PC 0x00000001 +#define INFOTYPE_TAPI20 0x00000002 +#define INFOTYPE_TAPI30 0x00000004 + +// Common return codes from controls +// not usually handled, often returned +#define TCR_ABORT ((DWORD)-1L) // the user has hung up +#define TCR_NORESPONSE ((DWORD)-2L) // the user hasn't repsonded to the questions +#define TCR_ASKOPERATOR ((DWORD)-3L) // the user has asked for an operator (often control just auto replies) +#define TCR_ASKHANGUP ((DWORD)-4L) // the user has asked to hang up. App must handle +#define TCR_ASKBACK ((DWORD)-5L) // the user has asked to go back and redo the previous thing + +// usually handled by control, unless overrided +#define TCR_ASKWHERE ((DWORD)-10L) // the user has asked where he/she is (usualy handled by control) +#define TCR_ASKHELP ((DWORD)-11L) // the user has asked for help (usually handled by control) +#define TCR_ASKREPEAT ((DWORD)-12L) // the user has asked for the question to be repeated (usually handled by the control) +#define TCR_ASKSPEAKFASTER ((DWORD)-13L) // the user has asked to speak faster. usually handled by the control +#define TCR_ASKSPEAKSLOWER ((DWORD)-14L) // the user has asked to speak slower. Usually handled by the control + + + +// {F9D18BF8-E0ED-11d0-AB8B-08002BE4E3B7} +DEFINE_GUID (CLSID_TelInfo, +0xf9d18bf8, 0xe0ed, 0x11d0, 0xab, 0x8b, 0x8, 0x0, 0x2b, 0xe4, 0xe3, 0xb7); + +/* + * ITelNotifySink + */ +#undef INTERFACE +#define INTERFACE ITelNotifySink + +// {CD0C7D7C-E1CD-11d0-AB8B-08002BE4E3B7} +DEFINE_GUID(IID_ITelNotifySink, +0xcd0c7d7c, 0xe1cd, 0x11d0, 0xab, 0x8b, 0x8, 0x0, 0x2b, 0xe4, 0xe3, 0xb7); + +DECLARE_INTERFACE_ (ITelNotifySink, IUnknown) { + // IUnkown members + STDMETHOD (QueryInterface) (THIS_ REFIID, LPVOID FAR *) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ITelNotifySink members + STDMETHOD (DTMF) (THIS_ WCHAR) PURE; + STDMETHOD (Abort) (THIS_ DWORD) PURE; +}; +typedef ITelNotifySink FAR *PITELNOTIFYSINK; + + +/* + * ITelControlNotifySink + */ +#undef INTERFACE +#define INTERFACE ITelControlNotifySink + +// {A55E2436-E297-11d0-AB8B-08002BE4E3B7} +DEFINE_GUID(IID_ITelControlNotifySink, +0xa55e2436, 0xe297, 0x11d0, 0xab, 0x8b, 0x8, 0x0, 0x2b, 0xe4, 0xe3, 0xb7); + +DECLARE_INTERFACE_ (ITelControlNotifySink, IUnknown) { + // IUnkown members + STDMETHOD (QueryInterface) (THIS_ REFIID, LPVOID FAR *) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ITelControlNotifySink members + STDMETHOD (Finish) (THIS_ DWORD, PVOID, DWORD) PURE; + STDMETHOD (Info) (THIS_ DWORD, PVOID, DWORD) PURE; +}; +typedef ITelControlNotifySink FAR *PITELCONTROLNOTIFYSINK; + + +/* + * ITelInfo + */ +#undef INTERFACE +#define INTERFACE ITelInfo + +// {250F0433-E0EB-11d0-AB8B-08002BE4E3B7} +DEFINE_GUID(IID_ITelInfo, +0x250f0433, 0xe0eb, 0x11d0, 0xab, 0x8b, 0x8, 0x0, 0x2b, 0xe4, 0xe3, 0xb7); + +DECLARE_INTERFACE_ (ITelInfo, IUnknown) { + // IUnkown members + STDMETHOD (QueryInterface) (THIS_ REFIID, LPVOID FAR *) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ITelInfo members + STDMETHOD (ObjectGet) (THIS_ GUID, LPUNKNOWN *) PURE; + STDMETHOD (ObjectSet) (THIS_ GUID, LPUNKNOWN) PURE; + STDMETHOD (DWORDGet) (THIS_ GUID, DWORD *) PURE; + STDMETHOD (DWORDSet) (THIS_ GUID, DWORD) PURE; + STDMETHOD (MemoryGet) (THIS_ GUID, PVOID *, DWORD *) PURE; + STDMETHOD (MemorySet) (THIS_ GUID, PVOID, DWORD) PURE; + STDMETHOD (SendDTMF) (THIS_ WCHAR) PURE; + STDMETHOD (SendAbort) (THIS_ DWORD) PURE; + STDMETHOD (TypeSet) (THIS_ DWORD) PURE; + STDMETHOD (WaveDeviceSet) (THIS_ DWORD, DWORD) PURE; + STDMETHOD (AudioSourceCreate) (THIS_ LPUNKNOWN *) PURE; + STDMETHOD (AudioDestCreate) (THIS_ LPUNKNOWN *) PURE; + STDMETHOD (QuickCreate) (THIS_ HMODULE, PSRMODEINFOW, PTTSMODEINFOW, + PCWSTR, BOOL) PURE; +}; +typedef ITelInfo FAR *PITELINFO; + + +/* + * ITelControl + */ +#undef INTERFACE +#define INTERFACE ITelControl + +// {17674DEB-E298-11d0-AB8B-08002BE4E3B7} +DEFINE_GUID(IID_ITelControl, +0x17674deb, 0xe298, 0x11d0, 0xab, 0x8b, 0x8, 0x0, 0x2b, 0xe4, 0xe3, 0xb7); + +DECLARE_INTERFACE_ (ITelControl, IUnknown) { + // IUnkown members + STDMETHOD (QueryInterface) (THIS_ REFIID, LPVOID FAR *) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ITelControl members + STDMETHOD (FromMemory) (THIS_ PVOID, DWORD) PURE; + STDMETHOD (FromStream) (THIS_ IStream *) PURE; +#ifdef STRICT + STDMETHOD (FromResource) (THIS_ PVOID, DWORD) PURE; +#else + STDMETHOD (FromResource) (THIS_ HINSTANCE, DWORD) PURE; +#endif + STDMETHOD (FromFile) (THIS_ PCWSTR) PURE; + STDMETHOD (Compile) (THIS_ LPWSTR*, DWORD*) PURE; + STDMETHOD (IsCompiled) (THIS_ BOOL*) PURE; + STDMETHOD (LanguageGet) (THIS_ LANGUAGEW*) PURE; + STDMETHOD (ToMemory) (THIS_ PVOID*, DWORD*) PURE; + STDMETHOD (ToStream) (THIS_ IStream *) PURE; + STDMETHOD (ToFile) (THIS_ PCWSTR) PURE; + STDMETHOD (TextGet) (THIS_ LPWSTR*, DWORD*) PURE; + STDMETHOD (TextDefaultGet) (THIS_ LPWSTR*, DWORD*) PURE; + STDMETHOD (ObjectSet) (THIS_ PITELINFO) PURE; + STDMETHOD (Start) (THIS_ PITELCONTROLNOTIFYSINK) PURE; + STDMETHOD (Abort) (THIS) PURE; +}; +typedef ITelControl FAR *PITELCONTROL; + + +// +// GUID identifiers for objects +// +// {44DB6739-E10E-11d0-AB8B-08002BE4E3B7} +DEFINE_GUID(TELOBJ_SPEECHRECOG, +0x44db6739, 0xe10e, 0x11d0, 0xab, 0x8b, 0x8, 0x0, 0x2b, 0xe4, 0xe3, 0xb7); + +// {44DB673B-E10E-11d0-AB8B-08002BE4E3B7} +DEFINE_GUID(TELOBJ_TTSQUEUE, +0x44db673b, 0xe10e, 0x11d0, 0xab, 0x8b, 0x8, 0x0, 0x2b, 0xe4, 0xe3, 0xb7); + +// {44DB673C-E10E-11d0-AB8B-08002BE4E3B7} +DEFINE_GUID(TELOBJ_LOGGING, +0x44db673c, 0xe10e, 0x11d0, 0xab, 0x8b, 0x8, 0x0, 0x2b, 0xe4, 0xe3, 0xb7); + +// {44DB673D-E10E-11d0-AB8B-08002BE4E3B7} +DEFINE_GUID(TELOBJ_TAPI30, +0x44db673d, 0xe10e, 0x11d0, 0xab, 0x8b, 0x8, 0x0, 0x2b, 0xe4, 0xe3, 0xb7); + +// {44DB673E-E10E-11d0-AB8B-08002BE4E3B7} +DEFINE_GUID(TELOBJ_NOTIFYSINK, +0x44db673e, 0xe10e, 0x11d0, 0xab, 0x8b, 0x8, 0x0, 0x2b, 0xe4, 0xe3, 0xb7); + + +// hcall for TAPI +// {F40CC4C0-0D0A-11d2-BEF0-006008317CE8} +DEFINE_GUID(TELDWORD_HCALL, +0xf40cc4c0, 0xd0a, 0x11d2, 0xbe, 0xf0, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +// hline for tapi +// {F40CC4C1-0D0A-11d2-BEF0-006008317CE8} +DEFINE_GUID(TELDWORD_HLINE, +0xf40cc4c1, 0xd0a, 0x11d2, 0xbe, 0xf0, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +// If this is set to TRUE, then beeps on a recognition are enabled. +// Disabling speeds up the response time of the system, but some people +// will speak before the beep. It's a tradeoff. +// {DB7F6130-0D2D-11d2-BEF1-006008317CE8} +DEFINE_GUID(TELDWORD_EnableRecognizeBeeps, +0xdb7f6130, 0xd2d, 0x11d2, 0xbe, 0xf1, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +// if set to true, and we're using tapi, then we should use tapi +// beeps rather than recordings for recognition acknowledgement +// beeps. This doesn't work properly on most telephony cards, and there's no +// way to tell, so be careful about using it +// {F40CC4C2-0D0A-11d2-BEF0-006008317CE8} +DEFINE_GUID(TELDWORD_UseTAPIBeep, +0xf40cc4c2, 0xd0a, 0x11d2, 0xbe, 0xf0, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +// disable the ability for a user to change the speed +// {59596FBE-F936-11d0-8FAD-08002BE4E62A} +DEFINE_GUID(TELDWORD_DisableSpeedChange, +0x59596fbe, 0xf936, 0x11d0, 0x8f, 0xad, 0x8, 0x0, 0x2b, 0xe4, 0xe6, 0x2a); + +// enable the ability for the user to ask for an operator +// {59596FBF-F936-11d0-8FAD-08002BE4E62A} +DEFINE_GUID(TELDWORD_EnableOperator, +0x59596fbf, 0xf936, 0x11d0, 0x8f, 0xad, 0x8, 0x0, 0x2b, 0xe4, 0xe6, 0x2a); + +// eanble the user to ask to hang up. If TRUE application must handle +// {59596FC0-F936-11d0-8FAD-08002BE4E62A} +DEFINE_GUID(TELDWORD_EnableAskHangUp, +0x59596fc0, 0xf936, 0x11d0, 0x8f, 0xad, 0x8, 0x0, 0x2b, 0xe4, 0xe6, 0x2a); + +// if TRUE, then the system supports full duplex +// both full duplex and echo cancelling must be TRUE for telephony controls to have barge in +// {10FEF992-343F-11d1-BE71-006008317CE8} +DEFINE_GUID(TELDWORD_FullDuplex, +0x10fef992, 0x343f, 0x11d1, 0xbe, 0x71, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +// if TRUE, then the system has echo cancelling built in. +// both full duplex and echo cancelling must be TRUE for telephony controls to have barge in +// {10FEF991-343F-11d1-BE71-006008317CE8} +DEFINE_GUID(TELDWORD_EchoCancel, +0x10fef991, 0x343f, 0x11d1, 0xbe, 0x71, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +/************************************************************************** +Telephon controls in spchtel.dll. */ + +// {53961A01-459B-11d1-BE77-006008317CE8} +DEFINE_GUID(CLSID_YesNoControl, +0x53961a01, 0x459b, 0x11d1, 0xbe, 0x77, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +// {53961A02-459B-11d1-BE77-006008317CE8} +DEFINE_GUID(CLSID_ExtensionControl, +0x53961a02, 0x459b, 0x11d1, 0xbe, 0x77, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +// {53961A03-459B-11d1-BE77-006008317CE8} +DEFINE_GUID(CLSID_PhoneNumControl, +0x53961a03, 0x459b, 0x11d1, 0xbe, 0x77, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +// {53961A04-459B-11d1-BE77-006008317CE8} +DEFINE_GUID(CLSID_GrammarControl, +0x53961a04, 0x459b, 0x11d1, 0xbe, 0x77, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +// {53961A05-459B-11d1-BE77-006008317CE8} +DEFINE_GUID(CLSID_DateControl, +0x53961a05, 0x459b, 0x11d1, 0xbe, 0x77, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +// {53961A06-459B-11d1-BE77-006008317CE8} +DEFINE_GUID(CLSID_TimeControl, +0x53961a06, 0x459b, 0x11d1, 0xbe, 0x77, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +// {53961A07-459B-11d1-BE77-006008317CE8} +DEFINE_GUID(CLSID_RecordControl, +0x53961a07, 0x459b, 0x11d1, 0xbe, 0x77, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +// {53961A08-459B-11d1-BE77-006008317CE8} +DEFINE_GUID(CLSID_SpellingControl, +0x53961a08, 0x459b, 0x11d1, 0xbe, 0x77, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +// {53961A09-459B-11d1-BE77-006008317CE8} +DEFINE_GUID(CLSID_NameControl, +0x53961a09, 0x459b, 0x11d1, 0xbe, 0x77, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + + + +/************************************************************************** +Sample telephony controls GUIDs. These samples appear in the SDK. */ +// {C869F0DE-EF29-11d0-8FAD-08002BE4E62A} +DEFINE_GUID(CLSID_SampleYesNoControl, +0xc869f0de, 0xef29, 0x11d0, 0x8f, 0xad, 0x8, 0x0, 0x2b, 0xe4, 0xe6, 0x2a); + +// {9DE44BA9-F94A-11d0-8FAD-08002BE4E62A} +DEFINE_GUID(CLSID_SampleExtensionControl, +0x9de44ba9, 0xf94a, 0x11d0, 0x8f, 0xad, 0x8, 0x0, 0x2b, 0xe4, 0xe6, 0x2a); + +// {9DE44BAA-F94A-11d0-8FAD-08002BE4E62A} +DEFINE_GUID(CLSID_SamplePhoneNumControl, +0x9de44baa, 0xf94a, 0x11d0, 0x8f, 0xad, 0x8, 0x0, 0x2b, 0xe4, 0xe6, 0x2a); + +// {9DE44BAB-F94A-11d0-8FAD-08002BE4E62A} +DEFINE_GUID(CLSID_SampleGrammarControl, +0x9de44bab, 0xf94a, 0x11d0, 0x8f, 0xad, 0x8, 0x0, 0x2b, 0xe4, 0xe6, 0x2a); + +// {9DE44BAC-F94A-11d0-8FAD-08002BE4E62A} +DEFINE_GUID(CLSID_SampleDateControl, +0x9de44bac, 0xf94a, 0x11d0, 0x8f, 0xad, 0x8, 0x0, 0x2b, 0xe4, 0xe6, 0x2a); + +// {9DE44BAD-F94A-11d0-8FAD-08002BE4E62A} +DEFINE_GUID(CLSID_SampleTimeControl, +0x9de44bad, 0xf94a, 0x11d0, 0x8f, 0xad, 0x8, 0x0, 0x2b, 0xe4, 0xe6, 0x2a); + +// {275931C6-FD27-11d0-8FAE-08002BE4E62A} +DEFINE_GUID(CLSID_SampleRecordControl, +0x275931c6, 0xfd27, 0x11d0, 0x8f, 0xae, 0x8, 0x0, 0x2b, 0xe4, 0xe6, 0x2a); + +// {9DE44BAE-F94A-11d0-8FAD-08002BE4E62A} +DEFINE_GUID(CLSID_SampleSpellingControl, +0x9de44bae, 0xf94a, 0x11d0, 0x8f, 0xad, 0x8, 0x0, 0x2b, 0xe4, 0xe6, 0x2a); + +// {9DE44BAF-F94A-11d0-8FAD-08002BE4E62A} +DEFINE_GUID(CLSID_SampleNameControl, +0x9de44baf, 0xf94a, 0x11d0, 0x8f, 0xad, 0x8, 0x0, 0x2b, 0xe4, 0xe6, 0x2a); + + +#endif // _SPCHTEL_H_ \ No newline at end of file diff --git a/speech2/third_party/sapi4/include/spchwrap.h b/speech2/third_party/sapi4/include/spchwrap.h new file mode 100644 index 0000000..24bfb6c --- /dev/null +++ b/speech2/third_party/sapi4/include/spchwrap.h @@ -0,0 +1,2456 @@ +/********************************************************************** +SpchWrap.h - Speech API header for the C++ wrapper objects. +*/ + +#ifndef _SPCHWRAP_H +#define _SPCHWRAP_H + +#define TAPI_VERSION_1_4 0x00010004 +#define TAPI_VERSION_2_0 0x00020000 +#define TAPI_CURRENT_VERSION TAPI_VERSION_1_4 + +#include +#include +#include + +#ifdef STRICT //libary is compiled without strict, so hwnd types dont match up +HRESULT ChooseEngineDialog(void *hwnd); +#else +HRESULT ChooseEngineDialog(HWND hwnd); +#endif + +// so it compiles with old directsound 4.0, which is included with VC 5.0 +#ifndef DSCBSTATUS_CAPTURING +// DirectSound Capture Component GUID {B0210780-89CD-11d0-AF08-00A0C925CD16} +DEFINE_GUID(CLSID_DirectSoundCapture, 0xb0210780, 0x89cd, 0x11d0, 0xaf, 0x8, 0x0, 0xa0, 0xc9, 0x25, 0xcd, 0x16); + +// +// IDirectSoundCapture +// + +typedef struct _DSCCAPS +{ + DWORD dwSize; + DWORD dwFlags; + DWORD dwFormats; + DWORD dwChannels; +} DSCCAPS, *LPDSCCAPS; + +typedef const DSCCAPS *LPCDSCCAPS; + +typedef struct _DSCBUFFERDESC +{ + DWORD dwSize; + DWORD dwFlags; + DWORD dwBufferBytes; + DWORD dwReserved; + LPWAVEFORMATEX lpwfxFormat; +} DSCBUFFERDESC, *LPDSCBUFFERDESC; + +typedef const DSCBUFFERDESC *LPCDSCBUFFERDESC; +struct IDirectSoundCapture; +struct IDirectSoundCaptureBuffer; +typedef struct IDirectSoundCaptureBuffer *LPDIRECTSOUNDCAPTUREBUFFER; + +DEFINE_GUID(IID_IDirectSoundCapture, 0xb0210781, 0x89cd, 0x11d0, 0xaf, 0x8, 0x0, 0xa0, 0xc9, 0x25, 0xcd, 0x16); + +#undef INTERFACE +#define INTERFACE IDirectSoundCapture + +DECLARE_INTERFACE_(IDirectSoundCapture, IUnknown) +{ + // IUnknown methods + STDMETHOD(QueryInterface) (THIS_ REFIID, LPVOID *) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IDirectSoundCapture methods + STDMETHOD(CreateCaptureBuffer) (THIS_ LPCDSCBUFFERDESC, LPDIRECTSOUNDCAPTUREBUFFER *, LPUNKNOWN) PURE; + STDMETHOD(GetCaps) (THIS_ LPDSCCAPS ) PURE; + STDMETHOD(Initialize) (THIS_ LPGUID) PURE; +}; + + +#endif + +// #defines used so users don't have to include dsound.h +// These are exactly the same as the ones in dsound.h, but with different names +DEFINE_GUID(IID_IDirectSoundTTS,0x279AFA83,0x4981,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60); +DEFINE_GUID(CLSID_DirectSoundTTS, +0x47d4d946, 0x62e8, 0x11cf, 0x93, 0xbc, 0x44, 0x45, 0x53, 0x54, 0x0, 0x0); + + +class CSRGram; +class CSRGramComp; +class CVoiceMenu; +class CTelControl; + + +/********************************************************************** +ctools */ + + +typedef struct { + PVOID pElem; // pointer to the element + DWORD dwElemSize; // size of the element in bytes + } LISTELEM, * PLISTELEM; + +class CSWList { + private: + DWORD dwNumElems; // number of elements stored away + DWORD dwBufSize; // allocated paElem buffer size in bytes + LISTELEM *paElems; // pointer to the memory containing the + // pointers to the list elements + BOOL MakeListMemoryThisBig (DWORD dwNumElems); + + public: + CSWList (void); + ~CSWList (void); + DWORD GetNumElems(void); + BOOL AddElem (PVOID pData, DWORD dwSize); + BOOL InsertElem (DWORD dwElemNum, PVOID pData, DWORD dwSize); + BOOL RemoveElem (DWORD dwElemNum); + DWORD GetElemSize (DWORD dwElemNum); + PVOID GetElem (DWORD dwElemNum); + BOOL SetElem (DWORD dwElemNum, PVOID pData, DWORD dwSize); + CSWList *Clone (); // clones the current list object + }; + +typedef CSWList * PCSWList; + +/* Combination of tree and list so the data can be searched through + by word, or by ID */ +class CTreeList { +private: + CSWList m_list; // list + +public: + CTreeList (void); + ~CTreeList (void); + DWORD NameToNumber (PCWSTR pszName); + PCWSTR NumberToName (DWORD dwElemNum); + DWORD GetNumElems(void); + BOOL AddElem (PCWSTR szName, PVOID pData, DWORD dwSize); + DWORD GetElemSize (DWORD dwElemNum); + PVOID GetElem (DWORD dwElemNum); + BOOL SetElem (DWORD dwElemNum, PVOID pData, DWORD dwSize); + + BOOL m_fCaseSens; // case sensative - defaults to false +}; +typedef CTreeList * PCTreeList; + + + +class CInfParse { + + private: + + public: + + CInfParse (LPCWSTR pszText, DWORD dwChars); + ~CInfParse (void); + SectionReset (void); + BOOL SectionQuery (LPWSTR pszSectionName, DWORD *pdwSectionNameSize); + BOOL SectionNext (void); + BOOL SectionFind (LPCWSTR pszSectionName); + ValueReset (void); + BOOL ValueQuery (LPWSTR pszValueName, DWORD *pdwValueNameSize, + LPWSTR pszValueValue, DWORD *pdwValueValueSize); + BOOL ValueQuery (LPWSTR pszValueName, DWORD *pdwValueNameSize, + LONG *plValue); + BOOL ValueNext (void); + BOOL ValueFind (LPCWSTR pszValueName); + + LPWSTR m_pszInf; // parse data + CSWList m_lines; // list of line + DWORD m_dwCurSection; // start of the current section + DWORD m_dwCurValue; // start of the current value within the section + }; + +typedef CInfParse * PCInfParse; + + +WCHAR * NextToken (WCHAR *pCur, WCHAR **ppStart, DWORD *pdwSize); +WCHAR ExtractToken (WCHAR *pStart, DWORD dwSize, WCHAR *pszCopyTo); + + +/********************************************************************** +low SR */ + +/* SR Mode */ +class CSRMode { + public: + CSRMode (void); + ~CSRMode (void); + + // specify the audio source + HRESULT InitAudioSourceMM (DWORD dwDeviceID); + HRESULT InitAudioSourceDirect (LPUNKNOWN lpUnkDirect); + HRESULT InitAudioSourceObject (LPUNKNOWN lpUnk); + + // specify the mode + HRESULT Init (void); + HRESULT Init (GUID gMode); + HRESULT Init (SRMODEINFOW *pSRModeInfo, SRMODEINFORANK *pSRModeInfoRank = NULL); + HRESULT Init (LPUNKNOWN lpUnk); + + // attributes + HRESULT AutoGainEnableGet (DWORD *pdwAutoGain); + DWORD AutoGainEnableGet (void); + HRESULT AutoGainEnableSet (DWORD dwAutoGain); + HRESULT EchoGet (BOOL *pfEcho); + BOOL EchoGet (void); + HRESULT EchoSet (BOOL fEcho); + HRESULT EnergyFloorGet (WORD *pwEnergy); + WORD EnergyFloorGet (void); + HRESULT EnergyFloorSet (WORD wEnergy); + HRESULT MicrophoneGet (WCHAR *pszMicrophone, DWORD dwMicrophoneSize, DWORD *pdwNeeded); + HRESULT MicrophoneSet (WCHAR *pszMicrophone); + HRESULT RealTimeGet (DWORD *pdwRealTime); + DWORD RealTimeGet (void); + HRESULT RealTimeSet (DWORD dwRealTime); + HRESULT SpeakerGet (WCHAR *pszSpeaker, DWORD dwSpeakerSize, DWORD *pdwNeeded); + HRESULT SpeakerSet (WCHAR *pszSpeaker); + HRESULT ThresholdGet (DWORD *pdwThreshold); + DWORD ThresholdGet (void); + HRESULT ThresholdSet (DWORD dwThreshold); + HRESULT TimeOutGet (DWORD *pdwIncomplete, DWORD *pdwComplete); + HRESULT TimeOutSet(DWORD dwIncomplete, DWORD dwComplete); + + // ISRCentral + HRESULT GrammarLoad (SRGRMFMT eFormat, + SDATA dData, + PVOID pNotifyInterface, IID IIDNotifyInterface, + LPUNKNOWN *ppiUnknown); + HRESULT GrammarLoad (SRGRMFMT eFormat, + PVOID pMem, DWORD dwSize, + PVOID pNotifyInterface, IID IIDNotifyInterface, + LPUNKNOWN *ppiUnknown); + HRESULT GrammarLoad (SRGRMFMT eFormat, + SDATA dData, + PISRGRAMNOTIFYSINKW pISRGramCommon, + LPUNKNOWN *ppiUnknown); + HRESULT GrammarLoad (SRGRMFMT eFormat, + PVOID pMem, DWORD dwSize, + PISRGRAMNOTIFYSINKW pISRGramCommon, + LPUNKNOWN *ppiUnknown); + CSRGram* GrammarLoad (SRGRMFMT eFormat, + PVOID pMem, DWORD dwSize, + PISRGRAMNOTIFYSINKW pISRGramCommon); + HRESULT ModeGet (PSRMODEINFOW pModeInfo); + HRESULT Pause (void); + HRESULT PosnGet (QWORD *pqwTimeStamp); + QWORD PosnGet (void); + HRESULT Register (PVOID pNotifyInterface, IID IIDNotifyInterface, DWORD *pdwKey); + HRESULT Register (PISRNOTIFYSINKW pISRNotifySink, DWORD *pdwKey); + HRESULT Resume (void); + HRESULT ToFileTime (PQWORD pqWord, FILETIME *pFT); + HRESULT UnRegister (DWORD dwKey); + + + // Create a grammar and load based upon data + CSRGramComp *Grammar (PISRGRAMNOTIFYSINKW pISRGramNotifySink); + CSRGramComp *GrammarFromMemory (PISRGRAMNOTIFYSINKW pISRGramNotifySink, PVOID pMem, DWORD dwSize); +#ifdef STRICT //library is compiled without strict, so hinstance type does not match up under strict + CSRGramComp *GrammarFromResource (PISRGRAMNOTIFYSINKW pISRGramNotifySink, void * hInst, DWORD dwResID); +#else + CSRGramComp *GrammarFromResource (PISRGRAMNOTIFYSINKW pISRGramNotifySink, HINSTANCE hInst, DWORD dwResID); +#endif + CSRGramComp *GrammarFromFile (PISRGRAMNOTIFYSINKW pISRGramNotifySink, PCWSTR pszFile); + CSRGramComp *GrammarFromStream (PISRGRAMNOTIFYSINKW pISRGramNotifySink, IStream *pIStream); + + // ISRDialogs +#ifdef STRICT //library is compiled without strict, so hwnd type does not match up under strict + HRESULT AboutDlg (void * hWndParent, PCWSTR pszTitle = NULL); + HRESULT GeneralDlg (void * hWndParent, PCWSTR pszTitle = NULL); + HRESULT LexiconDlg (void * hWndParent, PCWSTR pszTitle = NULL); + HRESULT TrainGeneralDlg (void * hWndParent, PCWSTR pszTitle = NULL); + HRESULT TrainMicDlg (void * hWndParent, PCWSTR pszTitle = NULL); + HRESULT TrainPhrasesDlg (void * hWndParent, PCWSTR pszTitle = NULL, PCWSTR pszText = NULL); +#else + HRESULT AboutDlg (HWND hWndParent, PCWSTR pszTitle = NULL); + HRESULT GeneralDlg (HWND hWndParent, PCWSTR pszTitle = NULL); + HRESULT LexiconDlg (HWND hWndParent, PCWSTR pszTitle = NULL); + HRESULT TrainGeneralDlg (HWND hWndParent, PCWSTR pszTitle = NULL); + HRESULT TrainMicDlg (HWND hWndParent, PCWSTR pszTitle = NULL); + HRESULT TrainPhrasesDlg (HWND hWndParent, PCWSTR pszTitle = NULL, PCWSTR pszText = NULL); +#endif + // ISRSpeaker + HRESULT Delete (WCHAR *pszSpeakerName); + HRESULT Enum (PWSTR *ppszBuffer, DWORD *pdwBufSize); + HRESULT Merge (WCHAR *pszSpeakerName, PVOID pSpeakerData, DWORD dwSpeakerData); + HRESULT New (WCHAR *pszSpeakerName); + HRESULT Query (WCHAR *pszSpeakerName, DWORD dwSize, DWORD *pdwNeeded); + HRESULT Read (WCHAR *pszSpeakerName, PVOID *ppBuffer, DWORD *pdwBufSize); + HRESULT Revert (WCHAR *pszSpeakerName); + HRESULT Select(WCHAR *pszSpeakerName, BOOL fLock = FALSE); + HRESULT Write (WCHAR *pszSpeakerName, PVOID pSpeakerData, DWORD dwSpeakerData); + + HRESULT Commit (void); + HRESULT Rename (PCWSTR, PCWSTR); + HRESULT GetChangedInfo (BOOL *, FILETIME*); + + // ILexPronounce + HRESULT Add(VOICECHARSET CharSet, WCHAR *pszText, WCHAR *pszPronounce, + VOICEPARTOFSPEECH PartOfSpeech, PVOID pEngineInfo, + DWORD dwEngineInfoSize); + HRESULT Get(VOICECHARSET CharSet, WCHAR *pszText, WORD wSense, + WCHAR *pszPronounce, DWORD dwPronounceSize, + DWORD *pdwPronounceNeeded, VOICEPARTOFSPEECH *pPartOfSpeech, + PVOID pEngineInfo, DWORD dwEngineInfoSize, + DWORD *pdwEngineInfoNeeded); + HRESULT Remove(WCHAR *pszText, WORD wSense); + + // ILexPronounce2 + HRESULT AddTo(DWORD dwLex, VOICECHARSET CharSet, WCHAR *pszText, WCHAR *pszPronounce, + VOICEPARTOFSPEECH PartOfSpeech, PVOID pEngineInfo, + DWORD dwEngineInfoSize); + HRESULT GetFrom(DWORD dwLex, VOICECHARSET CharSet, WCHAR *pszText, WORD wSense, + WCHAR *pszPronounce, DWORD dwPronounceSize, + DWORD *pdwPronounceNeeded, VOICEPARTOFSPEECH *pPartOfSpeech, + PVOID pEngineInfo, DWORD dwEngineInfoSize, + DWORD *pdwEngineInfoNeeded); + HRESULT RemoveFrom(DWORD dwLex, WCHAR *pszText, WORD wSense); + HRESULT QueryLexicons (BOOL f, DWORD *pdw); + HRESULT ChangeSpelling (DWORD dwLex, PCWSTR psz1, PCWSTR psz2); + + // IAttributes + HRESULT DWORDGet (DWORD, DWORD*); + HRESULT DWORDSet (DWORD, DWORD); + HRESULT StringGet (DWORD, PWSTR, DWORD, DWORD *); + HRESULT StringSet (DWORD, PCWSTR); + HRESULT MemoryGet (DWORD, PVOID*, DWORD*); + HRESULT MemorySet (DWORD, PVOID, DWORD); + + // member variables + LPUNKNOWN m_pUnkAudio; + PISRATTRIBUTESW m_pISRAttributes; + PIATTRIBUTESW m_pIAttributes; + PISRCENTRALW m_pISRCentral; + PISRDIALOGSW m_pISRDialogs; + PISRDIALOGS2W m_pISRDialogs2; + PISRSPEAKERW m_pISRSpeaker; + PISRSPEAKER2W m_pISRSpeaker2; + PILEXPRONOUNCEW m_pILexPronounce; + PILEXPRONOUNCE2W m_pILexPronounce2; + }; + +typedef CSRMode * PCSRMode; + + +/* SR Enum */ +class CSREnum { + public: + CSREnum (void); + ~CSREnum (void); + + HRESULT Init (void); + HRESULT Init (LPUNKNOWN lpUnkEnum); + + HRESULT Next (ULONG uNum, PSRMODEINFOW pSRModeInfo, ULONG *uFound = NULL); + HRESULT Next (PSRMODEINFOW pSRModeInfo); + HRESULT Skip (ULONG uNum = 1); + HRESULT Reset (void); + CSREnum* Clone (void); + HRESULT Select (GUID gModeID, PCSRMode *ppCSRMode, LPUNKNOWN pUnkAudio = NULL); + HRESULT Find (PSRMODEINFOW pSRFind, PSRMODEINFORANK pRank, PSRMODEINFOW pSRFound); + HRESULT Find (PSRMODEINFOW pSRFind, PSRMODEINFOW pSRFound); + + // variables + PISRENUMW m_pISREnum; + PISRFINDW m_pISRFind; + + }; + +typedef CSREnum * PCSREnum; + + +/* SRShare */ +class CSRShare { + public: + CSRShare (void); + ~CSRShare (void); + + HRESULT Init (void); + HRESULT Init (LPUNKNOWN lpUnkShare); + + HRESULT Next (ULONG uNum, PSRSHAREW pSRShare, ULONG *uFound = NULL); + HRESULT Next (PSRSHAREW pSRShare); + HRESULT Skip (ULONG uNum = 1); + HRESULT Reset (void); + CSRShare* Clone (void); + HRESULT New (DWORD dwDeviceID, GUID gModeID, PCSRMode *ppCSRMode, QWORD *pqwInstance); + HRESULT New (GUID gModeID, PCSRMode *ppCSRMode, QWORD *pqwInstance); + HRESULT Share (QWORD qwInstance, PCSRMode *ppCSRMode); + HRESULT Detach (QWORD qwInstance); + + // variables + PIENUMSRSHAREW m_pISRShare; + }; + +typedef CSRShare * PCSRShare; + + +/* SRGram */ +class CSRGram { + public: + CSRGram (void); + ~CSRGram (void); + + // initalization. Don't have to call if created by SR Engine + HRESULT Init (LPUNKNOWN pUnkGram); + + // ISRGramCommon +#ifdef STRICT //libary is compiled without strict, so hwnd types dont match up + HRESULT Activate (void * hWndListening = NULL, BOOL fAutoPause = FALSE, PCWSTR pszInfo = NULL); + HRESULT Activate (void *hWndListening, PCWSTR pszInfo); +#else + HRESULT Activate (HWND hWndListening = NULL, BOOL fAutoPause = FALSE, PCWSTR pszInfo = NULL); + HRESULT Activate (HWND hWndListening, PCWSTR pszInfo); +#endif + HRESULT Archive (BOOL fArchiveResults, PVOID pBuf, DWORD dwBufSize, + DWORD *pdwBufNeeded); + HRESULT BookMark (QWORD qwTime, DWORD dwBookMarkID); + HRESULT Deactivate(PCWSTR pszInfo = NULL); + HRESULT DeteriorationGet (DWORD *pdwMemory, DWORD *pdwTime, + DWORD *pdwObjects); + HRESULT DeteriorationSet(DWORD dwMemory, DWORD dwTime, DWORD dwObjects); +#ifdef STRICT //libary is compiled without strict, so hwnd types dont match up + HRESULT TrainDlg (void * hWndParent, PCWSTR pszTitle = NULL); +#else + HRESULT TrainDlg (HWND hWndParent, PCWSTR pszTitle = NULL); +#endif + HRESULT TrainPhrase (DWORD dwExtent, PSDATA pData); + HRESULT TrainQuery (DWORD *pdwFlags); + + // ISRGramCFG + HRESULT LinkQuery (WCHAR *pszLinkName, BOOL *pfExist); + BOOL LinkQuery (WCHAR *pszLinkName); + HRESULT ListAppend (WCHAR *pszListName, SDATA dWord); + HRESULT ListAppend (WCHAR *pszListName, PVOID pData, DWORD dwSize); + HRESULT ListGet (WCHAR *pszListName, PSDATA pdWord); + HRESULT ListQuery (WCHAR *pszListName, BOOL *fExist); + BOOL ListQuery (WCHAR *pszListName); + HRESULT ListRemove (WCHAR *pszListName, SDATA dWord); + HRESULT ListRemove (WCHAR *pszListName, PVOID pData, DWORD dwSize); + HRESULT ListSet (WCHAR *pszListName, SDATA dWord); + HRESULT ListSet (WCHAR *pszListName, PVOID pData, DWORD dwSize); + + // ISRGramDictation + HRESULT Context(PCWSTR pszPrior, PCWSTR pszAfter = NULL); + HRESULT Hint (PCWSTR pszHint); + HRESULT Words (PCWSTR pszWords); + + // ISRGramInsertionGUI + HRESULT Hide (void); + HRESULT Move (RECT rCursor); +#ifdef STRICT //libary is compiled without strict, so hwnd types dont match up + HRESULT Show (void * hWnd); +#else + HRESULT Show (HWND hWnd); +#endif + + // ILexPronounce + HRESULT Add(VOICECHARSET CharSet, WCHAR *pszText, WCHAR *pszPronounce, + VOICEPARTOFSPEECH PartOfSpeech, PVOID pEngineInfo, + DWORD dwEngineInfoSize); + HRESULT Get(VOICECHARSET CharSet, WCHAR *pszText, WORD wSense, + WCHAR *pszPronounce, DWORD dwPronounceSize, + DWORD *pdwPronounceNeeded, VOICEPARTOFSPEECH *pPartOfSpeech, + PVOID pEngineInfo, DWORD dwEngineInfoSize, + DWORD *pdwEngineInfoNeeded); + HRESULT Remove(WCHAR *pszText, WORD wSense); + + // ILexPronounce2 + HRESULT AddTo(DWORD dwLex, VOICECHARSET CharSet, WCHAR *pszText, WCHAR *pszPronounce, + VOICEPARTOFSPEECH PartOfSpeech, PVOID pEngineInfo, + DWORD dwEngineInfoSize); + HRESULT GetFrom(DWORD dwLex, VOICECHARSET CharSet, WCHAR *pszText, WORD wSense, + WCHAR *pszPronounce, DWORD dwPronounceSize, + DWORD *pdwPronounceNeeded, VOICEPARTOFSPEECH *pPartOfSpeech, + PVOID pEngineInfo, DWORD dwEngineInfoSize, + DWORD *pdwEngineInfoNeeded); + HRESULT RemoveFrom(DWORD dwLex, WCHAR *pszText, WORD wSense); + HRESULT QueryLexicons (BOOL f, DWORD *pdw); + HRESULT ChangeSpelling (DWORD dwLex, PCWSTR psz1, PCWSTR psz2); + + // IAttributes + HRESULT DWORDGet (DWORD, DWORD*); + HRESULT DWORDSet (DWORD, DWORD); + HRESULT StringGet (DWORD, PWSTR, DWORD, DWORD *); + HRESULT StringSet (DWORD, PCWSTR); + HRESULT MemoryGet (DWORD, PVOID*, DWORD*); + HRESULT MemorySet (DWORD, PVOID, DWORD); + + // variables + PISRGRAMCOMMONW m_pISRGramCommon; + PISRGRAMCFGW m_pISRGramCFG; + PISRGRAMDICTATIONW m_pISRGramDictation; + PISRGRAMINSERTIONGUI m_pISRGramInsertionGUI; + PILEXPRONOUNCEW m_pILexPronounce; + PILEXPRONOUNCE2W m_pILexPronounce2; + PIATTRIBUTESW m_pIAttributes; + + }; + +typedef CSRGram * PCSRGram; + + + +/* SRResult */ +class CSRResult { + public: + CSRResult (void); + ~CSRResult (void); + + // initalization. + HRESULT Init (LPUNKNOWN pUnkResult); + + // isrresaudio + HRESULT GetWAV (PSDATA pWav); + HRESULT GetWAV (PSDATA pWav, QWORD qwStart, QWORD qwEnd); + + // isrresbasic + HRESULT FlagsGet (DWORD dwRank, DWORD *pdwFlags); + DWORD FlagsGet (DWORD dwRank); + HRESULT Identify (GUID *pgIdentity); + HRESULT PhraseGet (DWORD dwRank, PSRPHRASEW pSRPhrase, + DWORD dwPhraseSize, DWORD *pdwPhraseNeeded); + HRESULT TimeGet (PQWORD pqTimeStampBegin, PQWORD pqTimeStampEnd); + + // isrrescorrection + HRESULT Correction (PSRPHRASEW pSRPhrase, WORD wConfidence = SRCORCONFIDENCE_SOME); + HRESULT Validate (WORD wConfidence = SRCORCONFIDENCE_SOME); + + // isrreseval + HRESULT ReEvaluate (BOOL *pfChanged); + + // isrresgraph + HRESULT BestPathPhoneme(DWORD dwRank, DWORD *padwPath, DWORD dwPathSize, + DWORD *pdwPathNeeded); + HRESULT BestPathWord(DWORD dwRank, DWORD *padwPath, + DWORD dwPathSize, DWORD *pdwPathNeeded); + HRESULT GetPhonemeNode (DWORD dwPhonemeNode, PSRRESPHONEMENODE pNode, + PWCHAR pcIPA, PWCHAR pcEngine); + HRESULT GetWordNode (DWORD dwWordNode, PSRRESWORDNODE pNode, + PSRWORDW pSRWord, DWORD dwMemSize, DWORD *pdwMemNeeded); + HRESULT PathScorePhoneme(DWORD *paNodes, DWORD dwNumNodes, + LONG *plScore); + HRESULT PathScoreWord (DWORD *paNodes, DWORD dwNumNodes, LONG *plScore); + + // isrresgraphex + HRESULT NodeStartGet(DWORD *pdw); + HRESULT NodeEndGet(DWORD *pdw); + HRESULT ArcEnum(DWORD dwNode, DWORD *pdwBuf, DWORD dwSize, + DWORD *pdwNum, BOOL fOutgoing); + HRESULT GetAllArcs(DWORD *padwArcID, DWORD dwSize, DWORD *pdwNumArcs, + DWORD *pdwNeeded); + HRESULT GetAllNodes(DWORD *padwArcID, DWORD dwSize, DWORD *pdwNumArcs, + DWORD *pdwNeeded); + HRESULT NodeGet(DWORD dwArcID, DWORD *pdwNode, BOOL fDestination); + HRESULT DWORDGet(DWORD dwID, GUID gAttrib, DWORD *pdwValue); + HRESULT DataGet(DWORD dwID, GUID gAttrib, SDATA *psData); + HRESULT ScoreGet(DWORD dwScoreType, DWORD *pdwPath, + DWORD dwPathSteps, DWORD dwPathIndexStart, + DWORD dwPathIndexCount, DWORD *pdwScore); + HRESULT BestPathEnum(DWORD dwRank, DWORD *pdwStartPath, + DWORD dwStartPathSteps, DWORD *padwEndPath, + DWORD dwEndPathSteps, BOOL fExactMatch, + PSDATA psData); + + // isrresmemory + HRESULT Free (DWORD dwKind); + HRESULT Get (DWORD *pdwKind, DWORD *pdwMemory); + HRESULT LockGet(BOOL *pfLock); + HRESULT LockSet(BOOL fLock); + + // isrresmerge + HRESULT Merge (LPUNKNOWN pIUnkAdjacent, LPUNKNOWN *ppIUnkMerge); + CSRResult* Merge(CSRResult * pAdjacent); + HRESULT Merge(CSRResult * pAdjacent, CSRResult **ppMerged); + HRESULT Split (QWORD qwSplitTime, LPUNKNOWN *ppIUnkLeft, + LPUNKNOWN *ppIUnkRight); + HRESULT Split (QWORD qwSplitTime, CSRResult **ppLeft, CSRResult **ppRight); + + // isrresmmodifygui + HRESULT Hide (void); + HRESULT Move (RECT * rSelection); +#ifdef STRICT //libary is compiled without strict, so hwnd types dont match up + HRESULT Show (void *hWnd); +#else + HRESULT Show (HWND hWnd); +#endif + + // isrresscore + HRESULT GetPhraseScore (DWORD dwRank, long *plScore); + HRESULT GetWordScores (DWORD dwRank, long *palScore, + DWORD dwWordScoreSize, DWORD *pdwWordScoreRequired); + + // isrresspeaker + HRESULT SpeakerCorrection (PCWSTR pszName, WORD wConfidence = SRCORCONFIDENCE_SOME); + HRESULT SpeakerIdentify (DWORD dwRank, WCHAR *pszName, DWORD dwNameSize, + DWORD *pdwNeeded, LONG *plScore); + HRESULT SpeakerIdentifyForFree (BOOL *pfFree); + HRESULT SpeakerValidate (WORD wConfidence = SRCORCONFIDENCE_SOME); + + // IAttributes + HRESULT DWORDGet (DWORD, DWORD*); + HRESULT DWORDSet (DWORD, DWORD); + HRESULT StringGet (DWORD, PWSTR, DWORD, DWORD *); + HRESULT StringSet (DWORD, PCWSTR); + HRESULT MemoryGet (DWORD, PVOID*, DWORD*); + HRESULT MemorySet (DWORD, PVOID, DWORD); + + // variable + PISRRESAUDIO m_pISRResAudio; + PISRRESAUDIOEX m_pISRResAudioEx; + PISRRESBASICW m_pISRResBasic; + PISRRESCORRECTIONW m_pISRResCorrection; + PISRRESEVAL m_pISRResEval; + PISRRESGRAPHW m_pISRResGraph; + PISRRESGRAPHEX m_pISRResGraphEx; + PISRRESMEMORY m_pISRResMemory; + PISRRESMERGE m_pISRResMerge; + PISRRESMODIFYGUI m_pISRResModifyGUI; + PISRRESSCORES m_pISRResScores; + PISRRESSPEAKERW m_pISRResSpeaker; + PIATTRIBUTESW m_pIAttributes; + + }; + +typedef CSRResult * PCSRResult; + +/* CSRNotifySink */ +#undef INTERFACE +#define INTERFACE CSRNotifySink + +DECLARE_INTERFACE_ (CSRNotifySink, ISRNotifySink2) { + unsigned long m_RefCount; + CSRNotifySink() + { + m_RefCount = 0; + } + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj); + STDMETHOD_(ULONG,AddRef) (THIS); + STDMETHOD_(ULONG,Release) (THIS); + + // ISRNotifySink members + STDMETHOD (AttribChanged) (THIS_ DWORD); + STDMETHOD (Interference) (THIS_ QWORD, QWORD, DWORD); + STDMETHOD (Sound) (THIS_ QWORD, QWORD); + STDMETHOD (UtteranceBegin) (THIS_ QWORD); + STDMETHOD (UtteranceEnd) (THIS_ QWORD, QWORD); + STDMETHOD (VUMeter) (THIS_ QWORD, WORD); + + // ISRNotifySink2 + STDMETHOD (Training) (THIS); + STDMETHOD (Error) (THIS_ LPUNKNOWN); + STDMETHOD (Warning) (THIS_ LPUNKNOWN); + }; + +typedef CSRNotifySink FAR *PCSRNotifySink; + +/* CSRGramNotifySink */ +#undef INTERFACE +#define INTERFACE CSRGramNotifySink + + +DECLARE_INTERFACE_ (CSRGramNotifySink, ISRGramNotifySinkW) { + unsigned long m_RefCount; + CSRGramNotifySink() + { + m_RefCount = 0; + } + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj); + STDMETHOD_(ULONG,AddRef) (THIS); + STDMETHOD_(ULONG,Release) (THIS); + + // ISRGramNotifySinkW members + STDMETHOD (BookMark) (THIS_ DWORD); + STDMETHOD (Paused) (THIS); + STDMETHOD (PhraseFinish) (THIS_ DWORD, QWORD, QWORD, PSRPHRASEW, LPUNKNOWN); + STDMETHOD (PhraseHypothesis)(THIS_ DWORD, QWORD, QWORD, PSRPHRASEW, LPUNKNOWN); + STDMETHOD (PhraseStart) (THIS_ QWORD); + STDMETHOD (ReEvaluate) (THIS_ LPUNKNOWN); + STDMETHOD (Training) (THIS_ DWORD); + STDMETHOD (UnArchive) (THIS_ LPUNKNOWN); + }; + +typedef CSRGramNotifySink FAR * PCSRGramNotifySink; + + + + +/********************************************************************** +low TTS */ + +/* TTSMode */ +class CTTSMode { + public: + CTTSMode (void); + ~CTTSMode (void); + + // specify the audio source + HRESULT InitAudioDestMM (DWORD dwDeviceID); + HRESULT InitAudioDestDirect (LPUNKNOWN lpUnkDirect); + HRESULT InitAudioDestObject (LPUNKNOWN lpUnk); + + // specify the mode + HRESULT Init (void); + HRESULT Init (GUID gMode); + HRESULT Init (TTSMODEINFOW *pTTSModeInfo, TTSMODEINFORANK *pTTSModeInfoRank = NULL); + HRESULT Init (LPUNKNOWN lpUnk); + + // ITTSAttributes + HRESULT PitchGet (WORD *pwPitch); + WORD PitchGet (void); + HRESULT PitchSet (WORD wPitch); + HRESULT RealTimeGet (DWORD *pdwRealTime); + DWORD RealTimeGet (void); + HRESULT RealTimeSet (DWORD dwRealTime); + HRESULT SpeedGet (DWORD *pdwSpeed); + DWORD SpeedGet (void); + HRESULT SpeedSet (DWORD dwSpeed); + HRESULT VolumeGet (DWORD *pdwVolume); + DWORD VolumeGet (void); + HRESULT VolumeSet (DWORD dwVolume); + + // ITTSCentral + HRESULT AudioPause (void); + HRESULT AudioReset (void); + HRESULT AudioResume (void); + HRESULT Inject (WCHAR *pszTag); + HRESULT ModeGet (PTTSMODEINFOW pttsInfo); + HRESULT Phoneme(VOICECHARSET eCharacterSet, DWORD dwFlags, + SDATA dText, PSDATA pdPhoneme); + HRESULT PosnGet (QWORD *pqwTimeStamp); + QWORD PosnGet (void); + HRESULT Register (PVOID pNotifyInterface, IID IIDNotifyInterface, + DWORD *pdwKey); + HRESULT Register (PITTSNOTIFYSINKW pNotifyInterface, DWORD *pdwKey); + HRESULT TextData (VOICECHARSET eCharacterSet, DWORD dwFlags, SDATA dText, + PVOID pNotifyInterface, IID IIDNotifyInterface); + HRESULT TextData (VOICECHARSET eCharacterSet, DWORD dwFlags, SDATA dText, + PITTSBUFNOTIFYSINKW pNotifyInterface = NULL); + HRESULT Speak (PCWSTR pszSpeak,BOOL fTagged = FALSE, + PITTSBUFNOTIFYSINKW pNotifyInterface = NULL); + HRESULT ToFileTime (PQWORD pqTimeStamp, FILETIME *pFT); + HRESULT UnRegister (DWORD dwKey); + + // ITTSDialogs +#ifdef STRICT //libary is compiled without strict, so hwnd types dont match up + HRESULT AboutDlg (void * hWndParent, PWSTR pszTitle = NULL); + HRESULT GeneralDlg (void * hWndParent, PWSTR pszTitle = NULL); + HRESULT LexiconDlg (void * hWndParent, PWSTR pszTitle = NULL); + HRESULT TranslateDlg (void * hWndParent, PWSTR pszTitle = NULL); +#else + HRESULT AboutDlg (HWND hWndParent, PWSTR pszTitle = NULL); + HRESULT GeneralDlg (HWND hWndParent, PWSTR pszTitle = NULL); + HRESULT LexiconDlg (HWND hWndParent, PWSTR pszTitle = NULL); + HRESULT TranslateDlg (HWND hWndParent, PWSTR pszTitle = NULL); +#endif + // ILexPronounce + HRESULT Add(VOICECHARSET CharSet, PCWSTR pszText, WCHAR *pszPronounce, + VOICEPARTOFSPEECH PartOfSpeech, PVOID pEngineInfo, + DWORD dwEngineInfoSize); + HRESULT Get(VOICECHARSET CharSet, PCWSTR pszText, WORD wSense, + WCHAR *pszPronounce, DWORD dwPronounceSize, + DWORD *pdwPronounceNeeded, VOICEPARTOFSPEECH *pPartOfSpeech, + PVOID pEngineInfo, DWORD dwEngineInfoSize, + DWORD *pdwEngineInfoNeeded); + HRESULT Remove(PCWSTR pszText, WORD wSense); + + // ILexPronounce2 + HRESULT AddTo(DWORD dwLex, VOICECHARSET CharSet, WCHAR *pszText, WCHAR *pszPronounce, + VOICEPARTOFSPEECH PartOfSpeech, PVOID pEngineInfo, + DWORD dwEngineInfoSize); + HRESULT GetFrom(DWORD dwLex, VOICECHARSET CharSet, WCHAR *pszText, WORD wSense, + WCHAR *pszPronounce, DWORD dwPronounceSize, + DWORD *pdwPronounceNeeded, VOICEPARTOFSPEECH *pPartOfSpeech, + PVOID pEngineInfo, DWORD dwEngineInfoSize, + DWORD *pdwEngineInfoNeeded); + HRESULT RemoveFrom(DWORD dwLex, WCHAR *pszText, WORD wSense); + HRESULT QueryLexicons (BOOL f, DWORD *pdw); + HRESULT ChangeSpelling (DWORD dwLex, PCWSTR psz1, PCWSTR psz2); + + // IAttributes + HRESULT DWORDGet (DWORD, DWORD*); + HRESULT DWORDSet (DWORD, DWORD); + HRESULT StringGet (DWORD, PWSTR, DWORD, DWORD *); + HRESULT StringSet (DWORD, PCWSTR); + HRESULT MemoryGet (DWORD, PVOID*, DWORD*); + HRESULT MemorySet (DWORD, PVOID, DWORD); + + // member variables + LPUNKNOWN m_pUnkAudio; + PITTSATTRIBUTESW m_pITTSAttributes; + PIATTRIBUTESW m_pIAttributes; + PITTSCENTRALW m_pITTSCentral; + PITTSDIALOGSW m_pITTSDialogs; + PILEXPRONOUNCEW m_pILexPronounce; + PILEXPRONOUNCE2W m_pILexPronounce2; + }; + +typedef CTTSMode * PCTTSMode; + +/* TTS Enum */ +class CTTSEnum { + public: + CTTSEnum (void); + ~CTTSEnum (void); + + HRESULT Init (void); + HRESULT Init (LPUNKNOWN lpUnkEnum); + + HRESULT Next (ULONG uNum, PTTSMODEINFOW pTTSModeInfo, ULONG *uFound = NULL); + HRESULT Next (PTTSMODEINFOW pTTSModeInfo); + HRESULT Skip (ULONG uNum = 1); + HRESULT Reset (void); + CTTSEnum* Clone (void); + HRESULT Select (GUID gModeID, PCTTSMode *ppCTTSMode, LPUNKNOWN pUnkAudio = NULL); + HRESULT Find (PTTSMODEINFOW pTTSFind, PTTSMODEINFORANK pRank, PTTSMODEINFOW pTTSFound); + HRESULT Find (PTTSMODEINFOW pTTSFind, PTTSMODEINFOW pTTSFound); + + // variables + PITTSENUMW m_pITTSEnum; + PITTSFINDW m_pITTSFind; + + }; + +typedef CTTSEnum * PCTTSEnum; + + +#undef INTERFACE +#define INTERFACE CTTSNotifySink + +DECLARE_INTERFACE_ (CTTSNotifySink, ITTSNotifySink2W) { + + unsigned long m_RefCount; + CTTSNotifySink() + { + m_RefCount = 0; + } +// IUnknown members + + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj); + STDMETHOD_(ULONG,AddRef) (THIS); + STDMETHOD_(ULONG,Release) (THIS); + +// CTTSNotifySinkW members + + STDMETHOD (AttribChanged) (THIS_ DWORD); + STDMETHOD (AudioStart) (THIS_ QWORD); + STDMETHOD (AudioStop) (THIS_ QWORD); + STDMETHOD (Visual) (THIS_ QWORD, WCHAR, WCHAR, DWORD, PTTSMOUTH); + + // Sink2 + STDMETHOD (Error) (THIS_ LPUNKNOWN); + STDMETHOD (Warning) (THIS_ LPUNKNOWN); + STDMETHOD (VisualFuture) (THIS_ DWORD, QWORD, WCHAR, WCHAR, DWORD, PTTSMOUTH); + }; + +typedef CTTSNotifySink FAR * PCTTSNotifySink; + + + +#undef INTERFACE +#define INTERFACE CTTSBufNotifySink + +DECLARE_INTERFACE_ (CTTSBufNotifySink, ITTSBufNotifySink) { + + unsigned long m_RefCount; + CTTSBufNotifySink() + { + m_RefCount = 0; + } +// IUnknown members + + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj); + STDMETHOD_(ULONG,AddRef) (THIS); + STDMETHOD_(ULONG,Release) (THIS); + +// CTTSBufNotifySink members + + STDMETHOD (TextDataDone) (THIS_ QWORD, DWORD); + STDMETHOD (TextDataStarted)(THIS_ QWORD); + STDMETHOD (BookMark) (THIS_ QWORD, DWORD); + STDMETHOD (WordPosition) (THIS_ QWORD, DWORD); + }; + +typedef CTTSBufNotifySink FAR * PCTTSBufNotifySink; + + + +/********************************************************************** +speech tools */ + +/* STGramComp */ +class CSTGramComp { + public: + CSTGramComp (void); + ~CSTGramComp (void); + + // intialization functions + HRESULT Init (void); + HRESULT Init (PISTGRAMCOMP pISTGramComp); + HRESULT Init (PVOID pMem, DWORD dwSize); // also loads +#ifdef STRICT //library is compiled without strict, so hinstance type does not match up under strict + HRESULT InitResource (void * hInst, DWORD dwResID); // also loads +#else + HRESULT InitResource (HINSTANCE hInst, DWORD dwResID); // also loads +#endif + HRESULT Init (PCWSTR pszFile); // also loads + HRESULT Init (IStream *pIStream); // also loads + + // gramcomp functions + HRESULT FromMemory (PVOID pMem, DWORD dwSize); +#ifdef STRICT //library is compiled without strict, so hinstance type does not match up under strict + HRESULT FromResource (void * hInst, DWORD dwResID); +#else + HRESULT FromResource (HINSTANCE hInst, DWORD dwResID); +#endif + HRESULT FromFile (PCWSTR pszFile); + HRESULT FromStream (IStream *pIStream); + HRESULT Compile (LPWSTR* ppszError = NULL, DWORD *pdwSize = NULL); + HRESULT IsCompiled (BOOL *pfCompiled); + BOOL IsCompiled (void); + HRESULT ToMemory (PVOID *ppMem, DWORD *pdwSize); + HRESULT ToFile (PCWSTR pszFile); + HRESULT ToStream (IStream *pIStream); + HRESULT TextGet (LPWSTR *pszText, DWORD *pdwSize); + HRESULT LanguageGet (LANGUAGEW *pLang); + LANGID LanguageGet (void); + HRESULT GrammarFormatGet (SRGRMFMT* pFmt); + SRGRMFMT GrammarFormatGet (void); + HRESULT GrammarDataGet (BOOL fEngine, PVOID *ppMem, DWORD *pdwSize); + HRESULT GrammarDataSet (PVOID pMem, DWORD dwSize); + HRESULT AutoList (PISRGRAMCFGW pISRGramCFG); + HRESULT AutoList (PCSRGram pCSRGram); + HRESULT PhraseParse (PSRPHRASEW pSRPhrase, DWORD *pdwCmdID = NULL, + LPWSTR *ppszParse = NULL, DWORD *pdwSize = NULL); + DWORD PhraseParse (PSRPHRASEW pSRPhrase, + LPWSTR *ppszParse = NULL, DWORD *pdwSize = NULL); + HRESULT GrammarLoad (LPUNKNOWN lpUnkMode, PVOID pNotifySink, + IID IIDGramNotifySink, LPUNKNOWN *ppIUnkGram); + PCSRGram GrammarLoad (PCSRMode pCSRMode, PISRGRAMNOTIFYSINKW pNotifySink); + + // variables + PISTGRAMCOMP m_pISTGramComp; + + }; + +typedef CSTGramComp * PCSTGramComp; + +/* SRGramComp - Multiple inheretence*/ +class CSRGramComp : public CSRGram, public CSTGramComp { + public: + CSRGramComp (void); + ~CSRGramComp (void); + + // intialization functions + HRESULT Init (PCSRMode pCSRMode, PISRGRAMNOTIFYSINKW pISRGramNotifySink); + + // Function do FromXXX, compile (if necessary), and GrammarLoad() + // If any of these fails then it's all freed + HRESULT GrammarFromMemory (PVOID pMem, DWORD dwSize); +#ifdef STRICT //library is compiled without strict, so hinstance type does not match up under strict + HRESULT GrammarFromResource (void * hInst, DWORD dwResID); +#else + HRESULT GrammarFromResource (HINSTANCE hInst, DWORD dwResID); +#endif + HRESULT GrammarFromFile (PCWSTR pszFile); + HRESULT GrammarFromStream (IStream *pIStream); + + // overloaded functions because now the grammar, central, or isrgramnotifysink + HRESULT AutoList (void); + HRESULT GrammarLoad (void); + HRESULT GrammarDataSet (short fArchiveResults = FALSE); + + // variables + PISRCENTRALW m_pISRCentral; + PISRGRAMNOTIFYSINKW m_pISRGramNotifySink; + + }; +typedef CSRGramComp * PCSRGramComp; + + +/* STMicWizard */ +class CSTMicWizard { + public: + CSTMicWizard (void); + ~CSTMicWizard (void); + + // initalization + HRESULT Init (void); + + // ISTMicWizard + HRESULT InfoGet (PMICWIZARDINFO pInfo); + HRESULT InfoSet (PMICWIZARDINFO pInfo); +#ifdef STRICT //library is compiled without strict, so hwnd type does not match up under strict + HRESULT Wizard (void * hWndParent, DWORD dwUse = STMWU_CNC, + DWORD dwWaveInDevice = WAVE_MAPPER, + DWORD dwSamplesPerSec = 16000, + DWORD dwFlags = 0); +#else + HRESULT Wizard (HWND hWndParent, DWORD dwUse = STMWU_CNC, + DWORD dwWaveInDevice = WAVE_MAPPER, + DWORD dwSamplesPerSec = 16000, + DWORD dwFlags = 0); +#endif + // variables + PISTMICWIZARD m_pISTMicWizard; + + }; +typedef CSTMicWizard * PCSTMicWizard; + +#ifdef STRICT +#define HWNDHACK void * +#else +#define HWNDHACK HWND +#endif + +/* STLexDlg */ +class CSTLexDlg { + public: + CSTLexDlg (void); + ~CSTLexDlg (void); + + // initalization + HRESULT Init (void); + + // ISTLexDlg + HRESULT LexDlg(HWNDHACK hWndParent, + PCWSTR pszWord, + DWORD dwFlags, + LANGID langID, + LPUNKNOWN pUnkLex, + LPUNKNOWN pUnkTTS = NULL, + LPUNKNOWN pUnkBackupLex = NULL, + PCWSTR pszPhonemes = NULL, + PCWSTR pszTitle = NULL); + + // variables + PISTLEXDLG m_pISTLexDlg; + + }; +typedef CSTLexDlg * PCSTLexDlg; + +/* STPhoneConv */ +class CSTPhoneConv { + public: + CSTPhoneConv (void); + ~CSTPhoneConv (void); + + // initalization + HRESULT Init (void); + + // ISTPhoneConv + HRESULT FromIPA (LPCWSTR pszFromIPA, DWORD *pdwFirstInvalid, + LPWSTR pszToSet, DWORD dwNumChars, DWORD *pdwCharsNeeded); + HRESULT Get (SDATA *pData); + HRESULT SetByLang (LANGID lang); + HRESULT SetByText (LPCWSTR pszText); + HRESULT ToIPA(LPCWSTR pszFromSet, DWORD *pdwFirstInvalid, + LPWSTR pszToIPA, DWORD dwNumChars, DWORD *pdwCharsNeeded); + + // variables + PISTPHONECONV m_pISTPhoneConv; + + }; +typedef CSTPhoneConv * PCSTPhoneConv; + + + +/* STLog */ +class CSTLog { + public: + CSTLog (void); + ~CSTLog (void); + + // initalization + HRESULT Init (void); + HRESULT Init (LPUNKNOWN lpUnk); + + // ISTLog + HRESULT ToFile (PCWSTR pszFile); + HRESULT ToStream (IStream *pIStream); + HRESULT Text (PCWSTR pszSource, PCWSTR pszMessage, WORD wDetail = 1); + HRESULT Data (PCWSTR pszSource, PCWSTR pszMessage, WORD wDetail, + PVOID pMem, DWORD dwSize); + HRESULT MaxDetailSet (WORD wDetail); + HRESULT MaxDetailGet (WORD *pwDetail); + WORD MaxDetailGet (void); + HRESULT ShowOutput (BOOL fShow); + + // variables + PISTLOG m_pISTLog; + + }; +typedef CSTLog * PCSTLog; + + + +/* STTTSQueue */ +class CSTTTSQueue { + public: + CSTTTSQueue (void); + ~CSTTTSQueue (void); + + // initalization + HRESULT Init (void); + HRESULT Init (LPUNKNOWN lpUnk); + + // ISTTTSQueue + HRESULT WaveAddFromFile (PCWSTR pszSpeakString, PCWSTR pszFile); + HRESULT WaveAddFromStream (PCWSTR pszSpeakString, IStream *pIStream); + HRESULT WaveAddFromMemory (PCWSTR pszSpeakString, PVOID pMem, DWORD dwSize); +#ifdef STRICT + HRESULT WaveAddFromResource (PCWSTR pszSpeakString, void *hModule, DWORD dwID); + HRESULT WaveAddFromList (PCWSTR pszString, void* hModule); + HRESULT WaveAddFromList (DWORD dwResourceID, void* hModule); +#else + HRESULT WaveAddFromResource (PCWSTR pszSpeakString, HMODULE hModule, DWORD dwID); + HRESULT WaveAddFromList (PCWSTR pszString, HMODULE hModule); + HRESULT WaveAddFromList (DWORD dwResourceID, HMODULE hModule); +#endif + HRESULT WaveRemove (PCWSTR pszSpeakString); + HRESULT WaveAudioDestSet (LPUNKNOWN pIUnk); + HRESULT WaveLevelSet (DWORD dwLevel); + HRESULT WaveLevelGet (DWORD *pdwLevel); + DWORD WaveLevelGet (void); + HRESULT TTSAdd (PCWSTR pszVoice, LPUNKNOWN pUnkTTS); + HRESULT TTSAdd (PCWSTR pszVoice, PCTTSMode pCTTSMode); + HRESULT TTSRemove (PCWSTR pszVoice); + HRESULT TTSGet (PCWSTR pszVoice, LPUNKNOWN *ppUnkTTS); + PCTTSMode TTSGet (PCWSTR pszVoice); + HRESULT Speak (PCWSTR pszSpeak, PCWSTR pszVoice = NULL, DWORD dwID = 0); + HRESULT TextData (VOICECHARSET eCharSet, DWORD dwFlags, + SDATA dData, PCWSTR pszVoice = NULL, DWORD dwID = 0); + HRESULT AudioPause (void); + HRESULT AudioResume (void); + HRESULT AudioReset (void); + HRESULT Register (PVOID pNotifySink, REFIID IIDNotifySink); + HRESULT Register (PISTTTSQUEUENOTIFYSINK pNotifySink); + HRESULT UseLogging (LPUNKNOWN pUnkLog); + HRESULT UseLogging (PCSTLog pLog); + HRESULT IsSpeaking (DWORD *pdwSpeak); + DWORD IsSpeaking (void); + + void WaitUntilDoneSpeaking (void); + + // variables + PISTTTSQUEUE m_pISTTTSQueue; + + }; +typedef CSTTTSQueue * PCSTTTSQueue; + + +// CSTTTSQueueNotifySink Interface + +#undef INTERFACE +#define INTERFACE CSTTTSQueueNotifySink + +DECLARE_INTERFACE_ (CSTTTSQueueNotifySink, IUnknown) { + unsigned long m_RefCount; + CSTTTSQueueNotifySink() + { + m_RefCount = 0; + } + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj); + STDMETHOD_(ULONG,AddRef) (THIS); + STDMETHOD_(ULONG,Release) (THIS); + + // CSTTTSQueueNotifySink members + STDMETHOD (Start) (THIS); + STDMETHOD (Stop) (THIS); + STDMETHOD (SpeakID) (THIS_ DWORD); + STDMETHOD (Error) (THIS_ HRESULT); + STDMETHOD (Bookmark) (THIS_ DWORD); + }; + +typedef CSTTTSQueueNotifySink FAR * PCSTTTSQueueNotifySink; + + + +/********************************************************************** +voice commands */ + +/* CVoiceCommands */ +class CVoiceCommands { + public: + CVoiceCommands (void); + ~CVoiceCommands (void); + + // initalization + HRESULT Init (void); + HRESULT Init (LPUNKNOWN pIUnkVCmd); + + // initialization and registration combined + HRESULT Init (PCWSTR pszSite, PVOID pNotifyInterface, + IID IIDNotifyInterface, DWORD dwFlags = VCMDRF_ALLBUTVUMETER, + PVCSITEINFOW pSiteInfo = NULL); + HRESULT Init (PIVCMDNOTIFYSINKW pNotifyInterface, PCWSTR pszSite = NULL, + DWORD dwFlags = VCMDRF_ALLBUTVUMETER, PVCSITEINFOW pSiteInfo = NULL); + + // IVoiceCommands + HRESULT CmdMimic (PVCMDNAMEW pMenu, PCWSTR pszCommand); + HRESULT CmdMimic (PCWSTR pszApplication, PCWSTR pszState, PCWSTR pszCommand); + HRESULT MenuCreate (PVCMDNAMEW pName, PLANGUAGEW pLanguage, DWORD dwFlags, + PIVCMDMENUW *ppIVCmdMenu); + HRESULT MenuCreate (PCWSTR pszApplication, PCWSTR pszState, + CVoiceMenu **ppCVoiceMenu, + DWORD dwFlags = VCMDMC_CREATE_TEMP); + CVoiceMenu* MenuCreate (PCWSTR pszApplication, PCWSTR pszState, + DWORD dwFlags = VCMDMC_CREATE_TEMP); + HRESULT MenuDelete (PVCMDNAMEW pName); + HRESULT MenuDelete (PCWSTR pszApplication, PCWSTR pszState); + HRESULT MenuEnum (DWORD dwFlags, PCWSTR pszApplicationFilter, + PCWSTR pszStateFilter, PIVCMDENUMW *ppiVCmdEnum); + HRESULT Register (PCWSTR pszSite, PVOID pNotifyInterface, + IID IIDNotifyInterface, DWORD dwFlags = VCMDRF_ALLBUTVUMETER, + PVCSITEINFOW pSiteInfo = NULL); + HRESULT Register (PIVCMDNOTIFYSINKW pNotifyInterface, PCWSTR pszSite = NULL, + DWORD dwFlags = VCMDRF_ALLBUTVUMETER, PVCSITEINFOW pSiteInfo = NULL); + + // IVCmdAttributes + HRESULT AutoGainEnableGet (DWORD *pdwAutoGain); + DWORD AutoGainEnableGet (void); + HRESULT AutoGainEnableSet (DWORD dwAutoGain); + HRESULT AwakeStateGet (DWORD *pdwAwakeState); + DWORD AwakeStateGet (void); + HRESULT AwakeStateSet (DWORD pdwAwakeState); + HRESULT DeviceGet (DWORD *pdwDevice); + DWORD DeviceGet (void); + HRESULT DeviceSet (DWORD pdwDevice); + HRESULT EnabledGet (DWORD *pdwEnabled); + DWORD EnabledGet (void); + HRESULT EnabledSet (DWORD pdwEnabled); + HRESULT MicrophoneGet (WCHAR *pszMicrophone, DWORD dwMicrophoneSize, DWORD *pdwNeeded); + HRESULT MicrophoneSet (WCHAR *pszMicrophone); + HRESULT SpeakerGet (WCHAR *pszSpeaker, DWORD dwSpeakerSize, DWORD *pdwNeeded); + HRESULT SpeakerSet (WCHAR *pszSpeaker); + HRESULT SRModeGet (GUID *pgMode); + HRESULT SRModeSet (GUID gMode); + HRESULT ThresholdGet (DWORD *pdwThreshold); + DWORD ThresholdGet (void); + HRESULT ThresholdSet (DWORD dwThreshold); + + // ISRDialogs +#ifdef STRICT //library is compiled without strict, so hwnd type does not match up under strict + HRESULT AboutDlg (void * hWndParent, PCWSTR pszTitle = NULL); + HRESULT GeneralDlg (void * hWndParent, PCWSTR pszTitle = NULL); + HRESULT LexiconDlg (void *hWndParent, PCWSTR pszTitle = NULL); + HRESULT TrainGeneralDlg (void * hWndParent, PCWSTR pszTitle = NULL); + HRESULT TrainMicDlg (void * hWndParent, PCWSTR pszTitle = NULL); +#else + HRESULT AboutDlg (HWND hWndParent, PCWSTR pszTitle = NULL); + HRESULT GeneralDlg (HWND hWndParent, PCWSTR pszTitle = NULL); + HRESULT LexiconDlg (HWND hWndParent, PCWSTR pszTitle = NULL); + HRESULT TrainGeneralDlg (HWND hWndParent, PCWSTR pszTitle = NULL); + HRESULT TrainMicDlg (HWND hWndParent, PCWSTR pszTitle = NULL); +#endif + + // IAttributes + HRESULT DWORDGet (DWORD, DWORD*); + HRESULT DWORDSet (DWORD, DWORD); + HRESULT StringGet (DWORD, PWSTR, DWORD, DWORD *); + HRESULT StringSet (DWORD, PCWSTR); + HRESULT MemoryGet (DWORD, PVOID*, DWORD*); + HRESULT MemorySet (DWORD, PVOID, DWORD); + + // variables + PIVOICECMDW m_pIVoiceCmd; + PIVCMDATTRIBUTESW m_pIVCmdAttributes; + PIATTRIBUTESW m_pIAttributes; + PIVCMDDIALOGSW m_pIVCmdDialogs; + }; +typedef CVoiceCommands * PCVoiceCommands; + + +/* CVoiceMenu */ +class CVoiceMenu { + public: + CVoiceMenu (void); + ~CVoiceMenu (void); + + // initalization + HRESULT Init (LPUNKNOWN pIUnkVMenu); + + // IVCmdMenu +#ifdef STRICT //library is compiled without strict, so hwnd type does not match up under strict + HRESULT Activate (void * hWndListening = NULL, DWORD dwFlags = NULL); +#else + HRESULT Activate (HWND hWndListening = NULL, DWORD dwFlags = NULL); +#endif + HRESULT Add (DWORD dwCmdNum, SDATA dData, DWORD *pdwCmdStart); + HRESULT AddOneCommand (DWORD dwID, PCWSTR pszCommand, + PCWSTR pszDescription = NULL, PCWSTR pszCategory = NULL, + DWORD dwFlags = 0, PVOID pAction = NULL, DWORD dwActionSize = NULL); + HRESULT Deactivate (void); + HRESULT EnableItem (DWORD dwEnable, DWORD dwCmdNum, DWORD dwFlag = VCMD_BY_POSITION); + HRESULT Get (DWORD dwCmdStart, DWORD dwCmdNum, DWORD dwFlag, + PSDATA pdData, DWORD *pdwCmdNum); + HRESULT ListGet (PCWSTR pszList, PSDATA pdList, DWORD *pdwListNum); + HRESULT ListSet (PCWSTR pszList, DWORD dwListNum, SDATA dList); + HRESULT Num (DWORD *pdwNumCmd); + DWORD Num (void); + HRESULT Remove (DWORD dwCmdStart, DWORD dwCmdNum = 1, DWORD dwFlag = VCMD_BY_POSITION); + HRESULT Set (DWORD dwCmdStart, DWORD dwCmdNum, DWORD dwFlag, + SDATA dData); + HRESULT SetOneCommand (DWORD dwCmdNum, DWORD dwFlag, + DWORD dwID, PCWSTR pszCommand, + PCWSTR pszDescription = NULL, PCWSTR pszCategory = NULL, + DWORD dwFlags = 0, PVOID pAction = NULL, DWORD dwActionSize = NULL); + HRESULT SetItem (DWORD dwEnable, DWORD dwCmdNum, DWORD dwFlag = VCMD_BY_POSITION); +#ifdef STRICT //library is compiled without strict, so hwnd type does not match up under strict + HRESULT TrainMenuDlg (void * hWndParent, PCWSTR pszTitle = NULL); +#else + HRESULT TrainMenuDlg (HWND hWndParent, PCWSTR pszTitle = NULL); +#endif + + PIVCMDMENUW m_pIVCmdMenu; + }; +typedef CVoiceMenu * PCVoiceMenu; + + +/* CVCmdNotifySink */ +#undef INTERFACE +#define INTERFACE CVCmdNotifySink + +DECLARE_INTERFACE_ (CVCmdNotifySink, IVCmdNotifySinkW) { + unsigned long m_RefCount; + CVCmdNotifySink() + { + m_RefCount = 0; + } + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj); + STDMETHOD_(ULONG,AddRef) (THIS); + STDMETHOD_(ULONG,Release) (THIS); + + // IVCmdNotifySink members + + STDMETHOD (CommandRecognize) (THIS_ DWORD, PVCMDNAMEW, DWORD, DWORD, PVOID, + DWORD, PWSTR, PWSTR); + STDMETHOD (CommandOther) (THIS_ PVCMDNAMEW, PWSTR); + STDMETHOD (CommandStart) (THIS); + STDMETHOD (MenuActivate) (THIS_ PVCMDNAMEW, BOOL); + STDMETHOD (UtteranceBegin) (THIS); + STDMETHOD (UtteranceEnd) (THIS); + STDMETHOD (VUMeter) (THIS_ WORD); + STDMETHOD (AttribChanged) (THIS_ DWORD); + STDMETHOD (Interference) (THIS_ DWORD); +}; + +typedef CVCmdNotifySink * PCVCmdNotifySink; + + + + +/********************************************************************** +voice dictation */ + +/* CVoiceDictation */ +class CVoiceDictation { + public: + CVoiceDictation (void); + ~CVoiceDictation (void); + + // initalization + HRESULT Init (void); + HRESULT Init (LPUNKNOWN pIUnkVDct); + + // initialization and registration combined + HRESULT Init (PCWSTR pszApplication, PCWSTR pszTopic, + IStorage* pISessionData, PCWSTR pszSite, + PVOID pNotifyInterface, IID IIDNotifyInterface, DWORD dwFlags); + HRESULT Init (PCWSTR pszApplication, PIVDCTNOTIFYSINKW pNotifyInterface, + PCWSTR pszTopic = NULL, + PCWSTR pszSite = NULL, + DWORD dwFlags = VCMDRF_ALLBUTVUMETER, + IStorage* pISessionDat = NULL); + + // IVDctAttributes + HRESULT AutoGainEnableGet (DWORD *pdwAutoGain); + DWORD AutoGainEnableGet (void); + HRESULT AutoGainEnableSet (DWORD dwAutoGain); + HRESULT EchoGet (BOOL *pfEcho); + BOOL EchoGet (void); + HRESULT EchoSet (BOOL fEcho); + HRESULT EnergyFloorGet (WORD *pwEnergy); + WORD EnergyFloorGet (void); + HRESULT EnergyFloorSet (WORD wEnergy); +#ifdef STRICT //library is compiled without strict, so hwnd type does not match up under strict + HRESULT IsAnyoneDictating(void * hWnd, WCHAR *pszName, DWORD dwNameSize, DWORD *pdwNameNeeded); +#else + HRESULT IsAnyoneDictating(HWND hWnd, WCHAR *pszName, DWORD dwNameSize, DWORD *pdwNameNeeded); +#endif + HRESULT MemoryGet (VDCTMEMORY *pDctMemory); + HRESULT MemorySet (VDCTMEMORY *pDctMemory); + HRESULT MicrophoneGet (WCHAR *pszMicrophone, DWORD dwMicrophoneSize, DWORD *pdwNeeded); + HRESULT MicrophoneSet (WCHAR *pszMicrophone); + HRESULT ModeGet (DWORD *pdwMode); + DWORD ModeGet (void); + HRESULT ModeSet (DWORD dwMode); + HRESULT RealTimeGet (DWORD *pdwRealTime); + DWORD RealTimeGet (void); + HRESULT RealTimeSet (DWORD dwRealTime); + HRESULT SpeakerGet (WCHAR *pszSpeaker, DWORD dwSpeakerSize, DWORD *pdwNeeded); + HRESULT SpeakerSet (WCHAR *pszSpeaker); + HRESULT ThresholdGet (DWORD *pdwThreshold); + DWORD ThresholdGet (void); + HRESULT ThresholdSet (DWORD dwThreshold); + HRESULT TimeOutGet (DWORD *pdwIncomplete, DWORD *pdwComplete); + HRESULT TimeOutSet(DWORD dwIncomplete, DWORD dwComplete); + + // IVDctCommands + HRESULT CommandAdd (BOOL fGlobal, DWORD dwCmdNum, SDATA dData, DWORD *pdwCmdStart); + HRESULT CommandGet (BOOL fGlobal, DWORD dwCmdStart, DWORD dwCmdNum, DWORD dwFlag, + PSDATA pdData, DWORD *pdwCmdNum); + HRESULT CommandNum (BOOL fGlobal, DWORD *pdwNumCmd); + DWORD CommandNum (BOOL fGlobal = FALSE); + HRESULT CommandRemove (BOOL fGlobal, DWORD dwCmdStart, DWORD dwCmdNum, DWORD dwFlag); + HRESULT CommandSet(BOOL fGlobal, DWORD dwCmdStart, DWORD dwCmdNum, DWORD dwFlag, + SDATA dData); + HRESULT CommandEnableItem (BOOL fGlobal, DWORD dwEnable, DWORD dwCmdNum, DWORD dwFlag); + + // IVDctDialogs +#ifdef STRICT //library is compiled without strict, so hwnd type does not match up under strict + HRESULT AboutDlg (void * hWndParent, PCWSTR pszTitle = NULL); + HRESULT GeneralDlg (void * hWndParent, PCWSTR pszTitle = NULL); + HRESULT LexiconDlg (void * hWndParent, PCWSTR pszTitle = NULL); + HRESULT TrainGeneralDlg (void * hWndParent, PCWSTR pszTitle = NULL); + HRESULT TrainMicDlg (void *hWndParent, PCWSTR pszTitle = NULL); +#else + HRESULT AboutDlg (HWND hWndParent, PCWSTR pszTitle = NULL); + HRESULT GeneralDlg (HWND hWndParent, PCWSTR pszTitle = NULL); + HRESULT LexiconDlg (HWND hWndParent, PCWSTR pszTitle = NULL); + HRESULT TrainGeneralDlg (HWND hWndParent, PCWSTR pszTitle = NULL); + HRESULT TrainMicDlg (HWND hWndParent, PCWSTR pszTitle = NULL); +#endif + + // IVDctGlossary + HRESULT GlossaryAdd (BOOL fGlobal, DWORD dwCmdNum, SDATA dData, DWORD *pdwCmdStart); + HRESULT GlossaryGet (BOOL fGlobal, DWORD dwCmdStart, DWORD dwCmdNum, DWORD dwFlag, + PSDATA pdData, DWORD *pdwCmdNum); + HRESULT GlossaryNum (BOOL fGlobal, DWORD *pdwNumCmd); + DWORD GlossaryNum (BOOL fGlobal = FALSE); + HRESULT GlossaryRemove (BOOL fGlobal, DWORD dwCmdStart, DWORD dwCmdNum, DWORD dwFlag); + HRESULT GlossarySet(BOOL fGlobal, DWORD dwCmdStart, DWORD dwCmdNum, DWORD dwFlag, + SDATA dData); + HRESULT GlossaryEnableItem (BOOL fGlobal, DWORD dwEnable, DWORD dwCmdNum, DWORD dwFlag); + + // IVDctGUI + HRESULT FlagsGet (DWORD *pdwFlags); + DWORD FlagsGet (void); + HRESULT FlagsSet (DWORD dwFlags); + HRESULT SetSelRect (RECT *pRect); + + // IVDctTextNorm + HRESULT OptionsEnum (PWSTR *ppOptions, DWORD *pdwSize); + HRESULT OptionsGet (PCWSTR pszOptionName, BOOL *pfOn); + HRESULT OptionsSet (PCWSTR pszOptionName, BOOL fOn); + + // IVDctText + HRESULT BookmarkAdd (VDCTBOOKMARK *pBookMark); + HRESULT BookmarkEnum (DWORD dwStart, DWORD dwNumChars, + PVDCTBOOKMARK *ppBookMark, DWORD *pdwNumMarks); + HRESULT BookmarkQuery (DWORD dwID, VDCTBOOKMARK *pBookMark); + HRESULT BookmarkRemove (DWORD dwMark); + HRESULT FX(DWORD dwFX); + HRESULT GetChanges (DWORD *pdwNewStart, DWORD *pdwNewEnd, + DWORD *pdwOldStart, DWORD *pdwOldEnd); + HRESULT Hint (PCWSTR pszHint); + HRESULT Lock (); + HRESULT ResultsGet (DWORD dwStart, DWORD dwNumChars, + DWORD *pdwPhraseStart, DWORD *pdwPhraseNumChars, + LPUNKNOWN *ppIUnkPhraseResults); + HRESULT ResultsGet (DWORD dwStart, DWORD dwNumChars, + DWORD *pdwPhraseStart, DWORD *pdwPhraseNumChars, + PCSRResult *ppCSRResult); + HRESULT TextGet (DWORD dwStart, DWORD dwNumChars, PSDATA pData); + HRESULT TextMove (DWORD dwStart, DWORD dwNumChars, + DWORD dwMoveTo, DWORD dwReason); + HRESULT TextRemove (DWORD dwStart, DWORD dwNumChars, + DWORD dwReason); + HRESULT TextSelGet (DWORD *pdwStart, DWORD *pdwNumChars); + HRESULT TextSelSet (DWORD dwStart, DWORD dwNumChars); + HRESULT TextSet (DWORD dwStart, DWORD dwNumChars, + PCWSTR pszBuf, DWORD dwReason); + HRESULT UnLock(); + HRESULT Words (PCWSTR pszWords); + + // IVDctText2 + HRESULT ITNApply (DWORD dwStart, DWORD dwNumChars); + HRESULT ITNExpand (DWORD dwStart, DWORD dwNumChars); + HRESULT ResultsGet2 (DWORD dwStart, DWORD dwNumChars, + DWORD *pdwPhraseStart, DWORD *pdwPhraseNumChars, + LPUNKNOWN *ppIUnkPhraseResults, + DWORD *pdwNodeLeft, DWORD *pdwNodeRight); + HRESULT ResultsSet (DWORD dwStart, DWORD dwNumChars, + LPUNKNOWN pIUnkPhraseResults, DWORD dwNodeLeft, DWORD dwNodeRight); + + // IVoiceDictation +#ifdef STRICT //library is compiled without strict, so hwnd type does not match up under stric + HRESULT Activate(void * hWnd = NULL); +#else + HRESULT Activate(HWND hWnd = NULL); +#endif + HRESULT CFGSet(LANGID lang, PCWSTR pszTopic, PCWSTR pszCFG); + HRESULT Deactivate(void); + HRESULT Register (PCWSTR pszApplication, PCWSTR pszTopic, + IStorage* pISessionData, PCWSTR pszSite, + PVOID pNotifyInterface, IID IIDNotifyInterface, DWORD dwFlags); + HRESULT Register (PCWSTR pszApplication, PIVDCTNOTIFYSINKW pNotifyInterface, + PCWSTR pszTopic = NULL, + PCWSTR pszSite = NULL, + DWORD dwFlags = VCMDRF_ALLBUTVUMETER, + IStorage* pISessionDat = NULL); + HRESULT SessionDeserialize (IStorage* pISessionData); + HRESULT SessionSerialize (IStorage* pISessionData); + HRESULT SiteInfoGet (PCWSTR pszSite, PVDSITEINFOW pSiteInfo); + HRESULT SiteInfoSet (PCWSTR pszSite, PVDSITEINFOW pSiteInfo); + HRESULT TopicAddGrammar (PCWSTR pszTopic, SDATA sData); + HRESULT TopicAddString (PCWSTR pszTopic, LANGUAGEW *pLanguage); + HRESULT TopicDeserialize (IStorage* pITopicData); + HRESULT TopicEnum (PSDATA pData); + HRESULT TopicRemove (PCWSTR pszTopic); + HRESULT TopicSerialize (IStorage* pITopicData); + + // ISRSpeaker + HRESULT Delete (WCHAR *pszSpeakerName); + HRESULT Enum (PWSTR *ppszBuffer, DWORD *pdwBufSize); + HRESULT Merge (WCHAR *pszSpeakerName, PVOID pSpeakerData, DWORD dwSpeakerData); + HRESULT New (WCHAR *pszSpeakerName); + HRESULT Query (WCHAR *pszSpeakerName, DWORD dwSize, DWORD *pdwNeeded); + HRESULT Read (WCHAR *pszSpeakerName, PVOID *ppBuffer, DWORD *pdwBufSize); + HRESULT Revert (WCHAR *pszSpeakerName); + HRESULT Select(WCHAR *pszSpeakerName, BOOL fLock); + HRESULT Write (WCHAR *pszSpeakerName, PVOID pSpeakerData, DWORD dwSpeakerData); + + // ILexPronounce + HRESULT Add(VOICECHARSET CharSet, WCHAR *pszText, WCHAR *pszPronounce, + VOICEPARTOFSPEECH PartOfSpeech, PVOID pEngineInfo, + DWORD dwEngineInfoSize); + HRESULT Get(VOICECHARSET CharSet, WCHAR *pszText, WORD wSense, + WCHAR *pszPronounce, DWORD dwPronounceSize, + DWORD *pdwPronounceNeeded, VOICEPARTOFSPEECH *pPartOfSpeech, + PVOID pEngineInfo, DWORD dwEngineInfoSize, + DWORD *pdwEngineInfoNeeded); + HRESULT Remove(WCHAR *pszText, WORD wSense); + + // ILexPronounce2 + HRESULT AddTo(DWORD dwLex, VOICECHARSET CharSet, WCHAR *pszText, WCHAR *pszPronounce, + VOICEPARTOFSPEECH PartOfSpeech, PVOID pEngineInfo, + DWORD dwEngineInfoSize); + HRESULT GetFrom(DWORD dwLex, VOICECHARSET CharSet, WCHAR *pszText, WORD wSense, + WCHAR *pszPronounce, DWORD dwPronounceSize, + DWORD *pdwPronounceNeeded, VOICEPARTOFSPEECH *pPartOfSpeech, + PVOID pEngineInfo, DWORD dwEngineInfoSize, + DWORD *pdwEngineInfoNeeded); + HRESULT RemoveFrom(DWORD dwLex, WCHAR *pszText, WORD wSense); + HRESULT QueryLexicons (BOOL f, DWORD *pdw); + HRESULT ChangeSpelling (DWORD dwLex, PCWSTR psz1, PCWSTR psz2); + + // vdctcommandsbuiltin +#ifdef STRICT //library is compiled without strict, so hwnd type does not match up under strict + HRESULT BuiltInActivate (void * hWnd, DWORD dwFlags); +#else + HRESULT BuiltInActivate (HWND hWnd, DWORD dwFlags); +#endif + HRESULT BuiltInDeactivate (void); + HRESULT BuiltInFromMemory (PVOID pMem, DWORD dwSize); + + HRESULT BuiltInFromFile (PCWSTR pszFile); + HRESULT BuiltInFromStream (IStream *pIStream); + HRESULT BuiltInListSet (PCWSTR pszList, PVOID pMem, DWORD dwSize); + HRESULT BuiltInTextGet (LPWSTR* pszText, DWORD* pdwSize); + HRESULT BuiltInToMemory (PVOID* ppMem, DWORD* pdwSize); + HRESULT BuiltInToFile (PCWSTR pszFile); + HRESULT BuiltInToStream (IStream *pIStream); + + // vdctcommandsApp +#ifdef STRICT //library is compiled without strict, so hwnd type does not match up under strict + HRESULT AppActivate (void * hWnd, DWORD dwFlags); +#else + HRESULT AppActivate (HWND hWnd, DWORD dwFlags); +#endif + HRESULT AppDeactivate (void); + HRESULT AppFromMemory (PVOID pMem, DWORD dwSize); + HRESULT AppFromFile (PCWSTR pszFile); + HRESULT AppFromStream (IStream *pIStream); + HRESULT AppListSet (PCWSTR pszList, PVOID pMem, DWORD dwSize); + HRESULT AppTextGet (LPWSTR* pszText, DWORD* pdwSize); + HRESULT AppToMemory (PVOID* ppMem, DWORD* pdwSize); + HRESULT AppToFile (PCWSTR pszFile); + HRESULT AppToStream (IStream *pIStream); + + // IAttributes + HRESULT DWORDGet (DWORD, DWORD*); + HRESULT DWORDSet (DWORD, DWORD); + HRESULT StringGet (DWORD, PWSTR, DWORD, DWORD *); + HRESULT StringSet (DWORD, PCWSTR); + HRESULT MemoryGet (DWORD, PVOID*, DWORD*); + HRESULT MemorySet (DWORD, PVOID, DWORD); + + // IVDctTextCache + HRESULT CopyToBin (DWORD, DWORD, DWORD); + HRESULT CopyToMemory (DWORD, DWORD, PVOID*, DWORD*, LPUNKNOWN**, DWORD*); + HRESULT PasteFromBin (DWORD, DWORD, DWORD); + HRESULT PasteFromMemory (DWORD, DWORD, PVOID, DWORD, LPUNKNOWN*, DWORD); + + // variables + PIVDCTATTRIBUTESW m_pIVDctAttributes; + PIATTRIBUTESW m_pIAttributes; + PIVDCTCOMMANDSW m_pIVDctCommands; + PIVDCTCOMMANDSBUILTINW m_pIVDctCommandsBuiltIn; + PIVDCTCOMMANDSAPPW m_pIVDctCommandsApp; + PIVDCTDIALOGSW m_pIVDctDialogs; + PIVDCTGLOSSARYW m_pIVDctGlossary; + PIVDCTGUI m_pIVDctGUI; + PIVDCTINVTEXTNORMW m_pIVDctInvTextNorm; + PIVDCTTEXTW m_pIVDctText; + PIVOICEDICTATIONW m_pIVoiceDictation; + PISRSPEAKERW m_pISRSpeaker; + PILEXPRONOUNCEW m_pILexPronounce; + PILEXPRONOUNCE2W m_pILexPronounce2; + PIVDCTTEXTCACHE m_pIVDctTextCache; + PIVDCTTEXT2W m_pIVDctText2; + }; +typedef CVoiceDictation * PCVoiceDictation; + + +/* CVDctNotifySink */ +#undef INTERFACE +#define INTERFACE CVDctNotifySink + +DECLARE_INTERFACE_ (CVDctNotifySink, IVDctNotifySink2W) { + + // IUnknown members + unsigned long m_RefCount; + CVDctNotifySink() + { + m_RefCount = 0; + } + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj); + STDMETHOD_(ULONG,AddRef) (THIS); + STDMETHOD_(ULONG,Release) (THIS); + + // CVDctNotifySink members + STDMETHOD (CommandBuiltIn) (THIS_ PWSTR); + STDMETHOD (CommandOther) (THIS_ PWSTR); + STDMETHOD (CommandRecognize) (THIS_ DWORD, DWORD, DWORD, PVOID, PWSTR); + STDMETHOD (TextSelChanged) (THIS); + STDMETHOD (TextChanged) (THIS_ DWORD); + STDMETHOD (TextBookmarkChanged) (THIS_ DWORD); + STDMETHOD (PhraseStart) (THIS); + STDMETHOD (PhraseFinish) (THIS_ DWORD, PSRPHRASEW); + STDMETHOD (PhraseHypothesis) (THIS_ DWORD, PSRPHRASEW); + STDMETHOD (UtteranceBegin) (THIS); + STDMETHOD (UtteranceEnd) (THIS); + STDMETHOD (VUMeter) (THIS_ WORD); + STDMETHOD (AttribChanged) (THIS_ DWORD); + STDMETHOD (Interference) (THIS_ DWORD); + STDMETHOD (Training) (THIS_ DWORD); + STDMETHOD (Dictating) (THIS_ PCWSTR, BOOL); + + STDMETHOD (Error) (THIS_ LPUNKNOWN); + STDMETHOD (Warning) (THIS_ LPUNKNOWN); +}; + +typedef CVDctNotifySink * PCVDctNotifySink; + + + + +/********************************************************************** +voice text */ + +/* CVoiceText */ +class CVoiceText { + public: + CVoiceText (void); + ~CVoiceText (void); + + // initalization + HRESULT Init (void); + HRESULT Init (LPUNKNOWN pIUnkVTxt); + + // initialization and registration combined + HRESULT Init (PCWSTR pszSite, PCWSTR pszApplication, + PVOID pNotifyInterface, IID IIDNotifyInterface, + DWORD dwFlags, PVTSITEINFO pSiteInfo); + HRESULT Init (PCWSTR pszApplication, PIVTXTNOTIFYSINKW pNotifyInterface = NULL, + PCWSTR pszSite = NULL, + DWORD dwFlags = 0, PVTSITEINFO pSiteInfo = NULL); + + // IVTxtAttributes + HRESULT DeviceGet (DWORD *pdwDeviceID); + DWORD DeviceGet (void); + HRESULT DeviceSet (DWORD dwDeviceID); + HRESULT EnabledGet (DWORD *dwEnabled); + DWORD EnabledGet (void); + HRESULT EnabledSet (DWORD dwEnabled); + HRESULT IsSpeaking (BOOL *pfSpeaking); + BOOL IsSpeaking (void); + HRESULT SpeedGet (DWORD *pdwSpeed); + DWORD SpeedGet (void); + HRESULT SpeedSet (DWORD dwSpeed); + HRESULT TTSModeGet (GUID *pgVoice); + HRESULT TTSModeSet (GUID gVoice); + + // IVTxtDialogs +#ifdef STRICT //library is compiled without strict, so hwnd type does not match up under strict + HRESULT AboutDlg (void * hWndParent, PWSTR pszTitle = NULL); + HRESULT GeneralDlg (void * hWndParent, PWSTR pszTitle = NULL); + HRESULT LexiconDlg (void * hWndParent, PWSTR pszTitle = NULL); + HRESULT TranslateDlg (void * hWndParent, PWSTR pszTitle = NULL); +#else + HRESULT AboutDlg (HWND hWndParent, PWSTR pszTitle = NULL); + HRESULT GeneralDlg (HWND hWndParent, PWSTR pszTitle = NULL); + HRESULT LexiconDlg (HWND hWndParent, PWSTR pszTitle = NULL); + HRESULT TranslateDlg (HWND hWndParent, PWSTR pszTitle = NULL); +#endif + // IVoiceText + HRESULT AudioFastForward (void); + HRESULT AudioPause (void); + HRESULT AudioResume (void); + HRESULT AudioRewind (void); + HRESULT Register (PCWSTR pszSite, PCWSTR pszApplication, + PVOID pNotifyInterface, IID IIDNotifyInterface, + DWORD dwFlags, PVTSITEINFO pSiteInfo); + HRESULT Register (PCWSTR pszApplication, PIVTXTNOTIFYSINKW pNotifyInterface = NULL, + PCWSTR pszSite = NULL, + DWORD dwFlags = 0, PVTSITEINFO pSiteInfo = NULL); + HRESULT Speak (PCWSTR pszSpeak, DWORD dwFlags = 0, PCWSTR pszTags = NULL); + HRESULT SpeakAndWait (PCWSTR pszSpeak, DWORD dwFlags = 0, PCWSTR pszTags = NULL); + HRESULT StopSpeaking (void); + + // IAttributes + HRESULT DWORDGet (DWORD, DWORD*); + HRESULT DWORDSet (DWORD, DWORD); + HRESULT StringGet (DWORD, PWSTR, DWORD, DWORD *); + HRESULT StringSet (DWORD, PCWSTR); + HRESULT MemoryGet (DWORD, PVOID*, DWORD*); + HRESULT MemorySet (DWORD, PVOID, DWORD); + + // variables + PIVTXTATTRIBUTESW m_pIVTxtAttributes; + PIATTRIBUTESW m_pIAttributes; + PIVTXTDIALOGSW m_pIVTxtDialogs; + PIVOICETEXTW m_pIVoiceText; + }; +typedef CVoiceText * PCVoiceText; + +/* CVTxtNotifySink */ +#undef INTERFACE +#define INTERFACE CVTxtNotifySink + +DECLARE_INTERFACE_ (CVTxtNotifySink, IVTxtNotifySinkW) { + unsigned long m_RefCount; + CVTxtNotifySink() + { + m_RefCount = 0; + } + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj); + STDMETHOD_(ULONG,AddRef) (THIS); + STDMETHOD_(ULONG,Release) (THIS); + + // IVTxtNotifySinkW members + STDMETHOD (AttribChanged) (THIS_ DWORD); + STDMETHOD (Visual) (THIS_ WCHAR, WCHAR, DWORD, PTTSMOUTH); + STDMETHOD (Speak) (THIS_ PWSTR, PWSTR, DWORD); + STDMETHOD (SpeakingStarted) (THIS); + STDMETHOD (SpeakingDone) (THIS); +}; + +typedef CVTxtNotifySink * PCVTxtNotifySink; + + + + +/********************************************************************** +telephony */ + +/* CTelInfo */ +class CTelInfo { + public: + CTelInfo (void); + ~CTelInfo (void); + + // Init + HRESULT Init (void); + HRESULT Init (LPUNKNOWN lpUnk); + + // Init, type set, and quick create + HRESULT Init (DWORD dwType, PSRMODEINFOW pSRModeInfo = NULL, + PTTSMODEINFOW pTTSModeInfo = NULL, PCWSTR pszWave = NULL, + HMODULE hModApp = NULL); + + // ITelInfo + HRESULT ObjectGet (GUID gObject, LPUNKNOWN *ppIUnk); + HRESULT ObjectGet (GUID gObject, IID iid, PVOID* ppI); + HRESULT ObjectSet (GUID gObject, LPUNKNOWN pIUnk); + HRESULT DWORDGet (GUID gDWORD, DWORD *pdwValue); + DWORD DWORDGet (GUID gDWORD); + HRESULT DWORDSet (GUID gDWORD, DWORD dwValue); + HRESULT MemoryGet (GUID gMem, PVOID *ppMem, DWORD *pdwSize); + HRESULT MemorySet (GUID gMem, PVOID pMem, DWORD dwSize); + HRESULT SendDTMF (WCHAR cDTMF); + HRESULT SendAbort (DWORD dwVal); + HRESULT TypeSet (DWORD dwType); + HRESULT AudioSourceCreate (LPUNKNOWN *ppIUnk); + HRESULT AudioDestCreate (LPUNKNOWN *ppIUnk); + HRESULT QuickCreate (HMODULE hModApp, PSRMODEINFOW pSRModeInfo = NULL, + PTTSMODEINFOW pTTSModeInfo = NULL, PCWSTR pszWave = NULL, + BOOL fUseLogging = FALSE); + HRESULT QuickCreate (HMODULE hModApp, PSRMODEINFOW pSRModeInfo, + PTTSMODEINFOW pTTSModeInfo, DWORD dwResourceID, + BOOL fUseLogging); + + // Easy to get + PCSRMode SRModeGet (void); + PCSTTTSQueue STTTSQueueGet (void); + PCSTLog STLogGet (void); + PITELNOTIFYSINK TelNotifySinkGet (void); + HRESULT TelNotifySinkSet (PITELNOTIFYSINK pITel); + HRESULT EnableOperatorSet (BOOL f = TRUE); + BOOL EnableOperatorGet (void); + HRESULT DisableSpeedChangeSet (BOOL f = TRUE); + BOOL DisableSpeedChangeGet (void); + HRESULT EnableAskHangUpSet (BOOL f = TRUE); + BOOL EnableAskHangUpGet (void); + + // variables + PITELINFO m_pITelInfo; + }; +typedef CTelInfo * PCTelInfo; + +/* CTelControl */ +class CTelControl : public ITelControlNotifySink { + public: + CTelControl (void); + ~CTelControl (void); + + // Init + HRESULT Init (CLSID clsid); + HRESULT Init (LPUNKNOWN lpUnk); + + // Initialization that also does ObjectSet + HRESULT Init (CLSID clsid, PITELINFO pITelInfo); + HRESULT Init (CLSID clsid, PCTelInfo pCTelInfo); + + // ITelControl + HRESULT FromMemory (PVOID pMem, DWORD dwSize); + HRESULT FromStream (IStream *pIStream); + HRESULT FromFile (PCWSTR pszFile); +#ifdef STRICT //library is compiled without strict, so hinstance type does not match up under strict + HRESULT FromResource (void * hInst, DWORD dwResID); +#else + HRESULT FromResource (HINSTANCE hInst, DWORD dwResID); +#endif + HRESULT Compile (LPWSTR *ppszErr = NULL, DWORD *pdwErr = NULL); + HRESULT IsCompiled (BOOL *pfCompiled); + BOOL IsCompiled (void); + HRESULT LanguageGet (LANGUAGEW *pLang); + HRESULT ToMemory (PVOID *ppMem, DWORD *pdwSize); + HRESULT ToStream (IStream *pIStream); + HRESULT ToFile (PCWSTR pszFile); + HRESULT TextGet (LPWSTR *ppszText, DWORD *pdwSize); + HRESULT TextDefaultGet (LPWSTR *ppszText, DWORD *pdwSize); + HRESULT ObjectSet (PITELINFO pITelInfo); + HRESULT Start (PITELCONTROLNOTIFYSINK pITelControlNotifySink); + HRESULT Abort (void); + + // Syncrhonous execution (must be compiled) + HRESULT Go (DWORD *pdwResult, PVOID *ppMem = NULL, DWORD *pdwSize = NULL); + + // Load & compile if necessary & do syncrhronous + HRESULT GoFromMemory (PVOID pMem, DWORD dwSize, + DWORD *pdwResult, PVOID *ppMem = NULL, DWORD *pdwSize = NULL); + HRESULT GoFromStream (IStream *pIStream, + DWORD *pdwResult, PVOID *ppMem = NULL, DWORD *pdwSize = NULL); + HRESULT GoFromFile (PCWSTR pszFile, + DWORD *pdwResult, PVOID *ppMem = NULL, DWORD *pdwSize = NULL); +#ifdef STRICT //library is compiled without strict, so hinstance type does not match up under strict + HRESULT GoFromResource (void * hInst, DWORD dwResID, +#else + HRESULT GoFromResource (HINSTANCE hInst, DWORD dwResID, +#endif + DWORD *pdwResult, PVOID *ppMem = NULL, DWORD *pdwSize = NULL); + + // variables + PITELCONTROL m_pITelControl; + DWORD m_dwResultFinish; + PVOID m_pMemFinish; + DWORD m_dwSizeFinish; + BOOL m_fFinish; + + + // Members for ITelControlNotifySink. Apps should not call this + STDMETHODIMP QueryInterface (REFIID, LPVOID FAR *); + STDMETHODIMP_(ULONG) AddRef(void); + STDMETHODIMP_(ULONG) Release(void); + STDMETHODIMP Finish (DWORD, PVOID, DWORD); + STDMETHODIMP Info(DWORD, PVOID, DWORD); + }; +typedef CTelControl * PCTelControl; + + +/* CTelControlNotifySink */ +#undef INTERFACE +#define INTERFACE CTelControlNotifySink + +DECLARE_INTERFACE_ (CTelControlNotifySink, ITelControlNotifySink) { + // IUnkown members + STDMETHOD (QueryInterface) (THIS_ REFIID, LPVOID FAR *); + STDMETHOD_(ULONG,AddRef) (THIS); + STDMETHOD_(ULONG,Release) (THIS); + + // ITelControlNotifySink members + STDMETHOD (Finish) (THIS_ DWORD, PVOID, DWORD); + STDMETHOD (Info) (THIS_ DWORD, PVOID, DWORD); +}; +typedef CTelControlNotifySink *PCTelControlNotifySink; + +/* CTelNotifySInk */ +#undef INTERFACE +#define INTERFACE CTelNotifySink + +DECLARE_INTERFACE_ (CTelNotifySink, ITelNotifySink) { + // IUnkown members + STDMETHOD (QueryInterface) (THIS_ REFIID, LPVOID FAR *); + STDMETHOD_(ULONG,AddRef) (THIS); + STDMETHOD_(ULONG,Release) (THIS); + + // ITelNotifySink members + STDMETHOD (DTMF) (THIS_ WCHAR); + STDMETHOD (Abort) (THIS_ DWORD); +}; +typedef CTelNotifySink *PCTelNotifySink; + + + +/* CTelControlFramwork */ + +#define STATE_VERIFY ((DWORD)-1L) // verification state + +class CTelControlFramework; + +class CTCSRNotifySink : public ISRNotifySinkW { + private: + CTelControlFramework *m_pTelControl; + + public: + CTCSRNotifySink (CTelControlFramework *); + ~CTCSRNotifySink (void); + + // IUnkown members that delegate to m_punkOuter + // Non-delegating object IUnknown + STDMETHODIMP QueryInterface (REFIID, LPVOID FAR *); + STDMETHODIMP_(ULONG) AddRef(void); + STDMETHODIMP_(ULONG) Release(void); + + // ISRNotifySink + STDMETHODIMP AttribChanged (DWORD); + STDMETHODIMP Interference (QWORD, QWORD, DWORD); + STDMETHODIMP Sound (QWORD, QWORD); + STDMETHODIMP UtteranceBegin (QWORD); + STDMETHODIMP UtteranceEnd (QWORD, QWORD); + STDMETHODIMP VUMeter (QWORD, WORD); + }; +typedef CTCSRNotifySink * PCTCSRNotifySink; + +class CTCTelNotifySink : public ITelNotifySink { + + protected: + CTelControlFramework *m_pTelControl; + + public: + CTCTelNotifySink(CTelControlFramework *); + ~CTCTelNotifySink(void); + + // IUnknown members + STDMETHODIMP QueryInterface (REFIID, LPVOID FAR *); + STDMETHODIMP_(ULONG) AddRef(void); + STDMETHODIMP_(ULONG) Release(void); + + // ITelNotifySink members + STDMETHODIMP DTMF (WCHAR); + STDMETHODIMP Abort(DWORD); +}; +typedef CTCTelNotifySink *PCTCTelNotifySink; + + +class CTCSRGramNotifySink : public ISRGramNotifySinkW { + + protected: + CTelControlFramework *m_pTelControl; + + public: + CTCSRGramNotifySink(CTelControlFramework *); + ~CTCSRGramNotifySink(void); + + // IUnknown members + STDMETHODIMP QueryInterface (REFIID, LPVOID FAR *); + STDMETHODIMP_(ULONG) AddRef(void); + STDMETHODIMP_(ULONG) Release(void); + + // ISRGramNotifySinkW members + STDMETHODIMP BookMark (DWORD); + STDMETHODIMP Paused (void); + STDMETHODIMP PhraseFinish (DWORD, QWORD, QWORD, PSRPHRASEW, LPUNKNOWN); + STDMETHODIMP PhraseHypothesis(DWORD, QWORD, QWORD, PSRPHRASEW, LPUNKNOWN); + STDMETHODIMP PhraseStart (QWORD); + STDMETHODIMP ReEvaluate (LPUNKNOWN); + STDMETHODIMP Training (DWORD); + STDMETHODIMP UnArchive (LPUNKNOWN); +}; +typedef CTCSRGramNotifySink *PCTCSRGramNotifySink; + + +class CTCSTTTTSQueueNotifySink : public ISTTTSQueueNotifySink { + + protected: + CTelControlFramework *m_pTelControl; + + public: + CTCSTTTTSQueueNotifySink(CTelControlFramework *); + ~CTCSTTTTSQueueNotifySink(void); + + // IUnknown members + STDMETHODIMP QueryInterface (REFIID, LPVOID FAR *); + STDMETHODIMP_(ULONG) AddRef(void); + STDMETHODIMP_(ULONG) Release(void); + + // ITTSNotifySinkW members + STDMETHODIMP Start (void); + STDMETHODIMP Stop (void); + STDMETHODIMP SpeakID (DWORD); + STDMETHODIMP Error (HRESULT); + STDMETHODIMP Bookmark (DWORD); +}; +typedef CTCSTTTTSQueueNotifySink *PCTCSTTTTSQueueNotifySink; + + +class CTelControlFramework : public ITelControl { + public: + CTelControlFramework (); + ~CTelControlFramework (void); + + // virtual functions + virtual PCWSTR GetControlName (void); + virtual DWORD GetDefaultTextResID (LANGID langID); + virtual void GetCLSID (CLSID *pCLSID); + virtual void OnState (DWORD dwStateID); + virtual void OnNoAnswer (void); + virtual void OnPhraseParse (DWORD dwParseID, PVOID pParseMem, + DWORD dwParseMemSize, + PSRPHRASEW pSRPhrase, LPUNKNOWN lpUnkResult); + virtual void OnPhraseUnrecognized (PSRPHRASEW pSRPhrase, LPUNKNOWN lpUnkResult); + virtual void OnDTMF (WORD wDTMF); + virtual void OnInterference (DWORD dwInterference); + virtual void OnTTSStop (void); + virtual void OnTTSBookmark (DWORD dwMark); + virtual HRESULT FromMemoryArchive (PVOID pMem, DWORD dwSize); + virtual void OnAbort (void); + virtual void OnPhraseHypothesisParse (DWORD dwParseID, PVOID pParseMem, + DWORD dwParseMemSize, + PSRPHRASEW pSRPhrase, LPUNKNOWN lpUnkResult); + virtual void OnPhraseStart (void); + virtual void OnTTSStart (void); + virtual void OnTTSSpeakID (DWORD dwSpeakID); + virtual void OnTTSError (HRESULT hRes); + virtual void OnAskBack (void); + virtual void OnAskHelp (void); + virtual void OnAskWhere (void); + virtual void OnAskOperator (void); + virtual void OnAskHangUp (void); + virtual void OnAskSpeakFaster (void); + virtual void OnAskSpeakSlower (void); + virtual void OnAskRepeat (void); + virtual void FreeUpControlData (void); + virtual void OnVerify (void); + + // non-overriding functions +#ifdef STRICT + HRESULT Init (LONG *pObjCount, PVOID hModule); +#else + HRESULT Init (LONG *pObjCount, HINSTANCE hModule); +#endif + void DoState (DWORD dwState); + void StopAllMedia (void); + HRESULT StartSR (PCWSTR pszRule = NULL); + HRESULT StartSRWhenReady (PCWSTR pszRule = NULL); + HRESULT StopSR (void); + HRESULT PlayTAPIBeep (DWORD); + HRESULT ReadyToListenBeep (void); + HRESULT RecognizedBeep (void); + HRESULT RecordingBeep (void); + HRESULT UnrecognizedBeep (void); + HRESULT FreeUpDefaultControlData (void); + HRESULT LoadInDefaultText (LANGID lang); + void DoFinish (DWORD dwResult, PVOID pMem = NULL, DWORD dwSize = 0); + void DoInfo (DWORD dwResult, PVOID pMem = NULL, DWORD dwSize = 0); + BOOL GetValue (PCWSTR pszSection, PCWSTR pszValue, + PWSTR pszRet, DWORD *dwSize); + LONG GetValue (PCWSTR pszSection, PCWSTR pszValue, LONG lDefault = 0); + HRESULT TTSSpeak (PCWSTR pszSection, PCWSTR pszValue); + void UnregisterNotificationSinks (void); + void RegisterNotificationSinks (void); + HRESULT DoVerify (PCWSTR pszPreSpeakItem, PCWSTR pszPostSpeakItem, + PCWSTR pszVerifySpeak, DWORD dwOnCorrectState, DWORD dwOnWrongState); + + // interfaces + STDMETHODIMP QueryInterface (REFIID, LPVOID FAR *); + STDMETHODIMP_(ULONG) AddRef (void); + STDMETHODIMP_(ULONG) Release(void); + + // ITelControl members + STDMETHODIMP FromMemory (PVOID, DWORD); + STDMETHODIMP FromStream (IStream *); +#ifdef STRICT //library is compiled without strict, so hinstance type does not match up under strict + STDMETHODIMP FromResource (void *, DWORD); +#else + STDMETHODIMP FromResource (HINSTANCE, DWORD); +#endif + STDMETHODIMP FromFile (PCWSTR); + STDMETHODIMP Compile (LPWSTR*, DWORD*); + STDMETHODIMP IsCompiled (BOOL*); + STDMETHODIMP LanguageGet (LANGUAGEW*); + STDMETHODIMP ToMemory (PVOID*, DWORD*); + STDMETHODIMP ToStream (IStream *); + STDMETHODIMP ToFile (PCWSTR); + STDMETHODIMP TextGet (LPWSTR*, DWORD*); + STDMETHODIMP TextDefaultGet (LPWSTR*, DWORD*); + STDMETHODIMP ObjectSet (PITELINFO); + STDMETHODIMP Start (PITELCONTROLNOTIFYSINK); + STDMETHODIMP Abort (void); + + // variables + PWSTR m_pszText; + PWSTR m_pszDefaultText; + PCInfParse m_pTextParse; + PCInfParse m_pDefaultTextParse; + BOOL m_fStarted; + BOOL m_fIsCompiled; + DWORD m_cRef; + LONG* m_plObjCount; + HMODULE m_hModule; + DWORD m_dwDefaultTextResIDLoaded; + CTCSRNotifySink* m_pISRNotifySink; + CTCSRGramNotifySink* m_pISRGramNotifySink; + DWORD m_dwSRKey; + CTCSTTTTSQueueNotifySink* m_pISTTTSQueueNotifySink; + CTCTelNotifySink* m_pITelNotifySink; + BOOL m_fNotifySinksUsed; + PCSRMode m_pSRMode; + PCSTGramComp m_pGramComp; + PCSRGram m_pGram; + PCSTTTSQueue m_pQueue; + PCSTLog m_pLog; + PCTelInfo m_pTelInfo; + PITELCONTROLNOTIFYSINK m_pITelControlNotifySink; + DWORD m_dwTimeOut; + DWORD m_dwNoAnswerTime; + DWORD m_dwNoAnswer; + DWORD m_dwNoAnswerMax; + LANGUAGEW m_lang; + WCHAR m_szRuleActive[64]; + BOOL m_fActiveWhenDoneTalking; + WCHAR m_szRuleToActivate[64]; + BOOL m_fIsSRActive; + BOOL m_fFullDuplex; + DWORD m_dwCurState; + BOOL m_fActivateWhenDoneTalking; + PCWSTR m_pszPreSpeakItem; + PCWSTR m_pszPostSpeakItem; + PCWSTR m_pszVerifySpeak; + DWORD m_dwOnCorrectState; + DWORD m_dwOnWrongState; + BOOL m_fVerify; + PCTreeList m_pTLSpoken; + BOOL m_fUseTAPIBeep; + HCALL m_hCall; // of TAPI + DWORD m_dwPlayBeep; // if TRUE, and TAPI beep, then play this beep when done speaking + BOOL m_fDisableRecogBeep; // if TRUE, disable the recognition beeps + long m_DTMFcount; +#define MAXDTMFCOUNT 25 + WCHAR m_DTMFString[MAXDTMFCOUNT+1]; +}; +typedef CTelControlFramework *PCTelControlFramework; + + +/********************************************************** +The following defines are used by the objects defined below +*/ +#define MAXBUFSIZE 256 +#define ERR_NONE 0 + +#define ALLOC(x) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, x); +#define FREE(x) HeapFree(GetProcessHeap(), NULL, x); + +#define WM_TELCONTROL_CALLDONE WM_USER + 1375 +#define WM_TELCONTROL_INITDONE WM_USER + 1376 +#define WM_TELCONTROL_CALLSTATE WM_USER + 1377 + +#define TM_STOP WM_USER + 1389 +#define TM_RUN WM_USER + 1390 +#define TM_ABORT WM_USER + 1391 +#define TM_DTMF WM_USER + 1392 + +#define CALLSTATE_INITIALIZING 0x00000001 +#define CALLSTATE_CONNECTING 0x00000002 +#define CALLSTATE_INPROGRESS 0x00000003 +#define CALLSTATE_DISCONNECTING 0x00000004 +#define CALLSTATE_IDLE 0x00000005 +#define CALLSTATE_DISABLED 0x00000006 + +// pure virtual functions to define the interfaces for the telephony objects +class CCall +{ + public: + virtual HRESULT Init(PITELINFO); + virtual HRESULT Shutdown(void); +#ifdef STRICT //library is compiled without strict, so hinstance type does not match up under strict + virtual HRESULT DoQuickCreate(PITELINFO, void *); +#else + virtual HRESULT DoQuickCreate(PITELINFO, HINSTANCE); +#endif + virtual HRESULT DoPhoneCall(void) = 0; +}; +typedef CCall *PCCALL; + + +class CTelLine +{ + public: +#ifdef STRICT //library is compiled without strict, so hwnd type does not match up under strict + virtual HRESULT Init(void *, PVOID, PCCALL) = 0; +#else + virtual HRESULT Init(HWND, PVOID, PCCALL) = 0; +#endif + virtual HRESULT ThreadLoop(void); + virtual HRESULT NewCall(void) = 0; + virtual HRESULT Go(void) = 0; + virtual HRESULT Stop(void); + virtual HRESULT Abort(void) = 0; + virtual HRESULT AbortControl(void); + virtual HRESULT GotDTMF(WCHAR) = 0; + virtual HRESULT SendDTMF(WCHAR); +}; +typedef CTelLine *PCTELLINE; + + +class CTelMain +{ + public: +#ifdef STRICT //library is compiled without strict, so hwnd type does not match up under strict + virtual HRESULT Init(void *, void *) = 0; +#else + virtual HRESULT Init(HWND, HINSTANCE) = 0; +#endif + virtual HRESULT Shutdown(void) = 0; + virtual HRESULT Callback(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD) = 0; + virtual HRESULT Callback(void) = 0; + virtual HRESULT CreateLineObject(PCCALL *) = 0; + virtual HRESULT CallDone(DWORD) = 0; + virtual HRESULT CallDialog(void) = 0; + virtual HRESULT Abort(void) = 0; + virtual HRESULT UseLogging(void); +#ifdef STRICT //library is compiled without strict, so hwnd type does not match up under strict + virtual HRESULT CallLoggingDialog(void *); +#else + virtual HRESULT CallLoggingDialog(HWND); +#endif + virtual HRESULT GotDTMF(DWORD) = 0; + + DWORD m_dwAnswerAfterRings; // answer the phone after this many rings + DWORD m_dwMaxLines; // maximum lines that can be connected +}; +typedef CTelMain *PCTELMAIN; + + + +// structs +typedef struct tagLINEINFO +{ + PCTELLINE pTelLine; // Line object + PCCALL pAppCall; // Apps call logic + HLINEAPP hApp; // App handle returned from intialize + DWORD nAddr; // Number of avail. addresses on the line + BOOL fVoiceLine; // Is this a voice line? + DWORD dwAPIVersion; // API version which the line supports + HLINE hLine; // line handle returned by lineOpen + HCALL hCall; // handle to a call on this line + DWORD dwPermanentLineID; // Permanent line ID retreived from devcaps + DWORD dwState; // line status + DWORD dwLineReplyNum; // identifier if expecting a reply + char szLineName[MAXBUFSIZE]; // the line's name + +} LINEINFO, *LPLINEINFO; + + +class CTelLineTAPI14 : public CTelLine +{ + private: + HINSTANCE m_hInst; + HWND m_hWnd; + HWND m_hAppWnd; + PITELINFO m_pITelInfo; + + DWORD m_dwLine; + DWORD m_dwWaveIn; + DWORD m_dwWaveOut; + LINEINFO m_li; + + HANDLE m_hThread; + DWORD m_dwThreadID; + PCCALL m_pCall; + + PVOID m_pTelMain; + + + public: +#ifdef STRICT //library is compiled without strict, so hinstance type does not match up under strict + CTelLineTAPI14(void *, DWORD, LPLINEINFO); +#else + CTelLineTAPI14(HINSTANCE, DWORD, LPLINEINFO); +#endif + ~CTelLineTAPI14(void); +#ifdef STRICT //library is compiled without strict, so hwnd type does not match up under strict + HRESULT Init(void *, PVOID, PCCALL); +#else + HRESULT Init(HWND, PVOID, PCCALL); +#endif + HRESULT ThreadLoop(void); + HRESULT NewCall(void); + HRESULT Go(void); + HRESULT Stop(void); + HRESULT Abort(void); + HRESULT AbortControl(void); + HRESULT GotDTMF(WCHAR); + HRESULT SendDTMF(WCHAR); + HRESULT CTelLineTAPI14::MakeCall(LPCSTR number,DWORD countrycode); + HRESULT CTelLineTAPI14::DropCall(); + HRESULT CTelLineTAPI14::SetHCALL(HCALL hCall); + + HANDLE m_eFreeForAnotherCall; // if set, free for another call, if not, on a call +}; +typedef CTelLineTAPI14 *PCTELLINETAPI14; + + +class CTelMainTAPI14 : public CTelMain +{ + friend class CTelLineTAPI14; + + private: + HLINEAPP m_hLineApp; + + DWORD m_dwState; + DWORD *m_pdwAddr; + HINSTANCE m_hInst; + + HWND m_hAppWnd; + HWND m_hDlgWnd; + HCALL m_hCall; + + + + int m_iReq; // request ID + + public: + DWORD m_dwNumLines; + LPLINEINFO m_lpLineInfo; + CTelMainTAPI14(void); + ~CTelMainTAPI14(void); + + void GetNumLines(DWORD *pdwNum) {*pdwNum = m_dwNumLines;} + void GetState(DWORD dwLine, DWORD *pdwState) {*pdwState = m_lpLineInfo[dwLine].dwState;} +#ifdef STRICT //library is compiled without strict, so hwnd type does not match up under strict + void SetDlgHWND(void * hwnd) {m_hDlgWnd = (HWND) hwnd;} +#else + void SetDlgHWND(HWND hwnd) {m_hDlgWnd = hwnd;} +#endif + void LineNotify(DWORD dwLine, DWORD dwNotification); +#ifdef STRICT //library is compiled without strict, so hwnd type does not match up under strict + HRESULT Init(void *, void *); +#else + HRESULT Init(HWND, HINSTANCE); +#endif + HRESULT Shutdown(void); + HRESULT Callback(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD); + HRESULT Callback(void); + virtual HRESULT CreateLineObject(PCCALL *) = 0; + HRESULT CallDone(DWORD); + HRESULT CallDialog(void); + HRESULT Abort(void); + HRESULT GotDTMF(DWORD); +}; +typedef CTelMainTAPI14 *PCTELMAINTAPI14; + + +class CTelLinePC : public CTelLine +{ + private: + HINSTANCE m_hInst; + HWND m_hAppWnd; + PITELINFO m_pITelInfo; + PVOID m_pCallback; + + PCCALL m_pCall; + PVOID m_pTelMain; + + + public: +#ifdef STRICT //library is compiled without strict, so hinstance type does not match up under strict + CTelLinePC(void *); +#else + CTelLinePC(HINSTANCE); +#endif + ~CTelLinePC(void); +#ifdef STRICT //library is compiled without strict, so hwnd type does not match up under strict + HRESULT Init(void *, PVOID, PCCALL); +#else + HRESULT Init(HWND, PVOID, PCCALL); +#endif + HRESULT NewCall(void); + HRESULT Go(void); + HRESULT Abort(void); + HRESULT GotDTMF(WCHAR); +}; +typedef CTelLinePC *PCTELLINEPC; + + +class CTelMainPC : public CTelMain +{ + private: + HINSTANCE m_hInst; + HWND m_hAppWnd; + PCTELLINEPC m_pLine; + PCCALL m_pAppCall; + + public: + CTelMainPC(void); + ~CTelMainPC(void); +#ifdef STRICT //library is compiled without strict, so hwnd type does not match up under strict + HRESULT Init(void *, void *); +#else + HRESULT Init(HWND, HINSTANCE); +#endif + HRESULT Shutdown(void); + HRESULT Callback(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD); + HRESULT Callback(void); + HRESULT CallDone(DWORD); + HRESULT CallDialog(void); + HRESULT Abort(void); + HRESULT GotDTMF(DWORD); +}; +typedef CTelMainPC *PCTELMAINPC; + +#endif // _SPCHWRAP_H + diff --git a/speech2/third_party/sapi4/include/speech.h b/speech2/third_party/sapi4/include/speech.h new file mode 100644 index 0000000..1671201 --- /dev/null +++ b/speech2/third_party/sapi4/include/speech.h @@ -0,0 +1,6635 @@ +/************************************************************************ +Speech.H - Header file to use the Microsoft Speech APIs. + +Copyright 1994 -1998 by Microsoft corporation.All rights reserved. +*/ + +#ifndef _SPEECH_ +#define _SPEECH_ + +// Disable the warning for zero-length arrays in structures +#pragma warning(disable:4200) + + +/************************************************************************ +Defines common to all of the speech APIs. +*/ + +// Application Speech API Compiler Defines _S_UNICODE +// ----------------------------------------------------------------------------- +// ANSI ANSI undefined +// ANSI Unicode _S_UNICODE defined +// Unicode ANSI (UNICODE || _UNICODE) && _S_ANSI undefined +// Unicode Unicode (UNICODE || _UNICODE) defined + +#if (defined(UNICODE) || defined(_UNICODE)) && !defined(_S_ANSI) +#ifndef _S_UNICODE +#define _S_UNICODE +#endif +#endif + +/************************************************************************ +defines */ +#define SVFN_LEN (262) +#define LANG_LEN (64) +#define EI_TITLESIZE (128) +#define EI_DESCSIZE (512) +#define EI_FIXSIZE (512) +#define SVPI_MFGLEN (64) +#define SVPI_PRODLEN (64) +#define SVPI_COMPLEN (64) +#define SVPI_COPYRIGHTLEN (128) +#define SVI_MFGLEN (SVPI_MFGLEN) +#define SETBIT(x) ((DWORD)1 << (x)) + + +// Error Macros +#define FACILITY_SPEECH (FACILITY_ITF) +#define SPEECHERROR(x) MAKE_SCODE(SEVERITY_ERROR, FACILITY_SPEECH, (x)+0x200) +#define AUDERROR(x) MAKE_SCODE(SEVERITY_ERROR, FACILITY_SPEECH, (x)+0x300) +#define SRWARNING(x) MAKE_SCODE(SEVERITY_SUCCESS, FACILITY_SPEECH, (x)+0x400) +#define SRERROR(x) MAKE_SCODE(SEVERITY_ERROR, FACILITY_SPEECH, (x)+0x400) +#define TTSERROR(x) MAKE_SCODE(SEVERITY_ERROR, FACILITY_SPEECH, (x)+0x500) +#define VCMDERROR(x) MAKE_SCODE(SEVERITY_ERROR, FACILITY_SPEECH, (x)+0x600) +#define VTXTERROR(x) MAKE_SCODE(SEVERITY_ERROR, FACILITY_SPEECH, (x)+0x700) +#define LEXERROR(x) MAKE_SCODE(SEVERITY_ERROR, FACILITY_SPEECH, (x)+0x800) +#define LEXWARNING(x) MAKE_SCODE(SEVERITY_SUCCESS, FACILITY_SPEECH, (x)+0x800) + +// Audio Errors +#define AUDERR_NONE S_OK // 0x00000000 +#define AUDERR_BADDEVICEID AUDERROR(1) // 0x80040301 +#define AUDERR_NEEDWAVEFORMAT AUDERROR(2) // 0x80040302 +#define AUDERR_NOTSUPPORTED E_NOTIMPL // 0x80004001 +#define AUDERR_NOTENOUGHDATA SPEECHERROR(1) // 0x80040201 +#define AUDERR_NOTPLAYING AUDERROR(6) // 0x80040306 +#define AUDERR_INVALIDPARAM E_INVALIDARG // 0x80070057 +#define AUDERR_WAVEFORMATNOTSUPPORTED SPEECHERROR(2) // 0x80040202 +#define AUDERR_WAVEDEVICEBUSY SPEECHERROR(3) // 0x80040203 +#define AUDERR_WAVEDEVNOTSUPPORTED AUDERROR(18) // 0x80040312 +#define AUDERR_NOTRECORDING AUDERROR(19) // 0x80040313 +#define AUDERR_INVALIDFLAG SPEECHERROR(4) // 0x80040204 +#define AUDERR_INVALIDHANDLE E_HANDLE // 0x80070006 +#define AUDERR_NODRIVER AUDERROR(23) // 0x80040317 +#define AUDERR_HANDLEBUSY AUDERROR(24) // 0x80040318 +#define AUDERR_INVALIDNOTIFYSINK AUDERROR(25) // 0x80040319 +#define AUDERR_WAVENOTENABLED AUDERROR(26) // 0x8004031A +#define AUDERR_ALREADYCLAIMED AUDERROR(29) // 0x8004031D +#define AUDERR_NOTCLAIMED AUDERROR(30) // 0x8004031E +#define AUDERR_STILLPLAYING AUDERROR(31) // 0x8004031F +#define AUDERR_ALREADYSTARTED AUDERROR(32) // 0x80040320 +#define AUDERR_SYNCNOTALLOWED AUDERROR(33) // 0x80040321 + +// Speech Recognition Warnings +#define SRWARN_BAD_LIST_PRONUNCIATION SRWARNING(1) + +// Speech Recognition Errors +#define SRERR_NONE S_OK // 0x00000000 +#define SRERR_OUTOFDISK SPEECHERROR(5) // 0x80040205 +#define SRERR_NOTSUPPORTED E_NOTIMPL // 0x80004001 +#define SRERR_NOTENOUGHDATA AUDERR_NOTENOUGHDATA // 0x80040201 +#define SRERR_VALUEOUTOFRANGE E_UNEXPECTED // 0x8000FFFF +#define SRERR_GRAMMARTOOCOMPLEX SRERROR(6) // 0x80040406 +#define SRERR_GRAMMARWRONGTYPE SRERROR(7) // 0x80040407 +#define SRERR_INVALIDWINDOW OLE_E_INVALIDHWND // 0x8004000F +#define SRERR_INVALIDPARAM E_INVALIDARG // 0x80070057 +#define SRERR_INVALIDMODE SPEECHERROR(6) // 0x80040206 +#define SRERR_TOOMANYGRAMMARS SRERROR(11) // 0x8004040B +#define SRERR_INVALIDLIST SPEECHERROR(7) // 0x80040207 +#define SRERR_WAVEDEVICEBUSY AUDERR_WAVEDEVICEBUSY // 0x80040203 +#define SRERR_WAVEFORMATNOTSUPPORTED AUDERR_WAVEFORMATNOTSUPPORTED // 0x80040202 +#define SRERR_INVALIDCHAR SPEECHERROR(8) // 0x80040208 +#define SRERR_GRAMTOOCOMPLEX SRERR_GRAMMARTOOCOMPLEX // 0x80040406 +#define SRERR_GRAMTOOLARGE SRERROR(17) // 0x80040411 +#define SRERR_INVALIDINTERFACE E_NOINTERFACE // 0x80004002 +#define SRERR_INVALIDKEY SPEECHERROR(9) // 0x80040209 +#define SRERR_INVALIDFLAG AUDERR_INVALIDFLAG // 0x80040204 +#define SRERR_GRAMMARERROR SRERROR(22) // 0x80040416 +#define SRERR_INVALIDRULE SRERROR(23) // 0x80040417 +#define SRERR_RULEALREADYACTIVE SRERROR(24) // 0x80040418 +#define SRERR_RULENOTACTIVE SRERROR(25) // 0x80040419 +#define SRERR_NOUSERSELECTED SRERROR(26) // 0x8004041A +#define SRERR_BAD_PRONUNCIATION SRERROR(27) // 0x8004041B +#define SRERR_DATAFILEERROR SRERROR(28) // 0x8004041C +#define SRERR_GRAMMARALREADYACTIVE SRERROR(29) // 0x8004041D +#define SRERR_GRAMMARNOTACTIVE SRERROR(30) // 0x8004041E +#define SRERR_GLOBALGRAMMARALREADYACTIVE SRERROR(31) // 0x8004041F +#define SRERR_LANGUAGEMISMATCH SRERROR(32) // 0x80040420 +#define SRERR_MULTIPLELANG SRERROR(33) // 0x80040421 +#define SRERR_LDGRAMMARNOWORDS SRERROR(34) // 0x80040422 +#define SRERR_NOLEXICON SRERROR(35) // 0x80040423 +#define SRERR_SPEAKEREXISTS SRERROR(36) // 0x80040424 +#define SRERR_GRAMMARENGINEMISMATCH SRERROR(37) // 0x80040425 +#define SRERR_BOOKMARKEXISTS SRERROR(38) // 0x80040426 +#define SRERR_BOOKMARKDOESNOTEXIST SRERROR(39) // 0x80040427 +#define SRERR_MICWIZARDCANCELED SRERROR(40) // 0x80040428 +#define SRERR_WORDTOOLONG SRERROR(41) // 0x80040429 +#define SRERR_BAD_WORD SRERROR(42) // 0x8004042A +#define E_WRONGTYPE SPEECHERROR(13) // 0x8004020C +#define E_BUFFERTOOSMALL SPEECHERROR(14) // 0x8004020D + + +// Text to Speech Errors +#define TTSERR_NONE S_OK // 0x00000000 +#define TTSERR_INVALIDINTERFACE E_NOINTERFACE // 0x80004002 +#define TTSERR_OUTOFDISK SRERR_OUTOFDISK // 0x80040205 +#define TTSERR_NOTSUPPORTED E_NOTIMPL // 0x80004001 +#define TTSERR_VALUEOUTOFRANGE E_UNEXPECTED // 0x8000FFFF +#define TTSERR_INVALIDWINDOW OLE_E_INVALIDHWND // 0x8004000F +#define TTSERR_INVALIDPARAM E_INVALIDARG // 0x80070057 +#define TTSERR_INVALIDMODE SRERR_INVALIDMODE // 0x80040206 +#define TTSERR_INVALIDKEY SRERR_INVALIDKEY // 0x80040209 +#define TTSERR_WAVEFORMATNOTSUPPORTED AUDERR_WAVEFORMATNOTSUPPORTED // 0x80040202 +#define TTSERR_INVALIDCHAR SRERR_INVALIDCHAR // 0x80040208 +#define TTSERR_QUEUEFULL SPEECHERROR(10) // 0x8004020A +#define TTSERR_WAVEDEVICEBUSY AUDERR_WAVEDEVICEBUSY // 0x80040203 +#define TTSERR_NOTPAUSED TTSERROR(1) // 0x80040501 +#define TTSERR_ALREADYPAUSED TTSERROR(2) // 0x80040502 + + +// Voice Command Errors + +/* + * Everything worked + */ +#define VCMDERR_NONE S_OK // 0x00000000 + +/* + * Voice Commands could not allocate memory + */ +#define VCMDERR_OUTOFMEM E_OUTOFMEMORY // 0x8007000E + +/* + * Voice Commands could not store/retrieve a command set from the database + */ +#define VCMDERR_OUTOFDISK SRERR_OUTOFDISK // 0x80040205 + +/* + * Function not implemented + */ +#define VCMDERR_NOTSUPPORTED E_NOTIMPL // 0x80004001 + +/* + * A parameter was passed that was out of the ranged of accepted values + */ +#define VCMDERR_VALUEOUTOFRANGE E_UNEXPECTED // 0x8000FFFF + +/* + * A menu was too complex to compile a context-free grammar + */ +#define VCMDERR_MENUTOOCOMPLEX VCMDERROR(0x06) // 0x80040606 + +/* + * Language mismatch between the speech recognition mode and menu trying + * to create + */ +#define VCMDERR_MENUWRONGLANGUAGE VCMDERROR(0x07) // 0x80040607 + +/* + * An invalid window handle was passed to Voice Commands + */ +#define VCMDERR_INVALIDWINDOW OLE_E_INVALIDHWND // 0x8004000F + +/* + * Voice Commands detected a bad function parameter + */ +#define VCMDERR_INVALIDPARAM E_INVALIDARG // 0x80070057 + +/* + * This function cannot be completed right now, usually when trying to do + * some operation while no speech recognition site is established + */ +#define VCMDERR_INVALIDMODE SRERR_INVALIDMODE // 0x80040206 + +/* + * There are too many Voice Commands menu + */ // 0x8004060B +#define VCMDERR_TOOMANYMENUS VCMDERROR(0x0B) + +/* + * Invalid list passed to ListSet/ListGet + */ +#define VCMDERR_INVALIDLIST SRERR_INVALIDLIST // 0x80040207 + +/* + * Trying to open an existing menu that is not in the Voice Commands database + */ +#define VCMDERR_MENUDOESNOTEXIST VCMDERROR(0x0D) // 0x8004060D + +/* + * The function could not be completed because the menu is actively + * listening for commands + */ +#define VCMDERR_MENUACTIVE VCMDERROR(0x0E) // 0x8004060E + +/* + * No speech recognition engine is started + */ +#define VCMDERR_NOENGINE VCMDERROR(0x0F) // 0x8004060F + +/* + * Voice Commands could not acquire a Grammar interface from the speech + * recognition engine + */ +#define VCMDERR_NOGRAMMARINTERFACE VCMDERROR(0x10) // 0x80040610 + +/* + * Voice Commands could not acquire a Find interface from the speech + * recognition engine + */ +#define VCMDERR_NOFINDINTERFACE VCMDERROR(0x11) // 0x80040611 + +/* + * Voice Commands could not create a speech recognition enumerator + */ +#define VCMDERR_CANTCREATESRENUM VCMDERROR(0x12) // 0x80040612 + +/* + * Voice Commands could get the appropriate site information to start a + * speech recognition engine + */ +#define VCMDERR_NOSITEINFO VCMDERROR(0x13) // 0x80040613 + +/* + * Voice Commands could not find a speech recognition engine + */ +#define VCMDERR_SRFINDFAILED VCMDERROR(0x14) // 0x80040614 + +/* + * Voice Commands could not create an audio source object + */ +#define VCMDERR_CANTCREATEAUDIODEVICE VCMDERROR(0x15) // 0x80040615 + +/* + * Voice Commands could not set the appropriate device number in the + * audio source object + */ +#define VCMDERR_CANTSETDEVICE VCMDERROR(0x16) // 0x80040616 + +/* + * Voice Commands could not select a speech recognition engine. Usually the + * error will occur when Voice Commands has enumerated and found an + * appropriate speech recognition engine, then it is not able to actually + * select/start the engine. There are different reasons that the engine won't + * start, but the most common is that there is no wave in device. + */ +#define VCMDERR_CANTSELECTENGINE VCMDERROR(0x17) // 0x80040617 + +/* + * Voice Commands could not create a notfication sink for engine + * notifications + */ +#define VCMDERR_CANTCREATENOTIFY VCMDERROR(0x18) // 0x80040618 + +/* + * Voice Commands could not create internal data structures. + */ +#define VCMDERR_CANTCREATEDATASTRUCTURES VCMDERROR(0x19) // 0x80040619 + +/* + * Voice Commands could not initialize internal data structures + */ +#define VCMDERR_CANTINITDATASTRUCTURES VCMDERROR(0x1A) // 0x8004061A + +/* + * The menu does not have an entry in the Voice Commands cache + */ +#define VCMDERR_NOCACHEDATA VCMDERROR(0x1B) // 0x8004061B + +/* + * The menu does not have commands + */ +#define VCMDERR_NOCOMMANDS VCMDERROR(0x1C) // 0x8004061C + +/* + * Voice Commands cannot extract unique words needed for the engine grammar + */ +#define VCMDERR_CANTXTRACTWORDS VCMDERROR(0x1D) // 0x8004061D + +/* + * Voice Commands could not get the command set database name + */ +#define VCMDERR_CANTGETDBNAME VCMDERROR(0x1E) // 0x8004061E + +/* + * Voice Commands could not create a registry key + */ +#define VCMDERR_CANTCREATEKEY VCMDERROR(0x1F) // 0x8004061F + +/* + * Voice Commands could not create a new database name + */ +#define VCMDERR_CANTCREATEDBNAME VCMDERROR(0x20) // 0x80040620 + +/* + * Voice Commands could not update the registry + */ +#define VCMDERR_CANTUPDATEREGISTRY VCMDERROR(0x21) // 0x80040621 + +/* + * Voice Commands could not open the registry + */ +#define VCMDERR_CANTOPENREGISTRY VCMDERROR(0x22) // 0x80040622 + +/* + * Voice Commands could not open the command set database + */ +#define VCMDERR_CANTOPENDATABASE VCMDERROR(0x23) // 0x80040623 + +/* + * Voice Commands could not create a database storage object + */ +#define VCMDERR_CANTCREATESTORAGE VCMDERROR(0x24) // 0x80040624 + +/* + * Voice Commands could not do CmdMimic + */ +#define VCMDERR_CANNOTMIMIC VCMDERROR(0x25) // 0x80040625 + +/* + * A menu of this name already exist + */ +#define VCMDERR_MENUEXIST VCMDERROR(0x26) // 0x80040626 + +/* + * A menu of this name is open and cannot be deleted right now + */ +#define VCMDERR_MENUOPEN VCMDERROR(0x27) // 0x80040627 + + +// Voice Text Errors +#define VTXTERR_NONE S_OK // 0x00000000 + +/* + * Voice Text failed to allocate memory it needed + */ +#define VTXTERR_OUTOFMEM E_OUTOFMEMORY // 0x8007000E + +/* + * An empty string ("") was passed to the Speak function + */ +#define VTXTERR_EMPTYSPEAKSTRING SPEECHERROR(0x0b) // 0x8004020B + +/* + * An invalid parameter was passed to a Voice Text function + */ +#define VTXTERR_INVALIDPARAM E_INVALIDARG // 0x80070057 + +/* + * The called function cannot be done at this time. This usually occurs + * when trying to call a function that needs a site, but no site has been + * registered. + */ +#define VTXTERR_INVALIDMODE SRERR_INVALIDMODE // 0x80040206 + +/* + * No text-to-speech engine is started + */ +#define VTXTERR_NOENGINE VTXTERROR(0x0F) // 0x8004070F + +/* + * Voice Text could not acquire a Find interface from the text-to-speech + * engine + */ +#define VTXTERR_NOFINDINTERFACE VTXTERROR(0x11) // 0x80040711 + +/* + * Voice Text could not create a text-to-speech enumerator + */ +#define VTXTERR_CANTCREATETTSENUM VTXTERROR(0x12) // 0x80040712 + +/* + * Voice Text could get the appropriate site information to start a + * text-to-speech engine + */ +#define VTXTERR_NOSITEINFO VTXTERROR(0x13) // 0x80040713 + +/* + * Voice Text could not find a text-to-speech engine + */ +#define VTXTERR_TTSFINDFAILED VTXTERROR(0x14) // 0x80040714 + +/* + * Voice Text could not create an audio destination object + */ +#define VTXTERR_CANTCREATEAUDIODEVICE VTXTERROR(0x15) // 0x80040715 + +/* + * Voice Text could not set the appropriate device number in the + * audio destination object + */ +#define VTXTERR_CANTSETDEVICE VTXTERROR(0x16) // 0x80040716 + +/* + * Voice Text could not select a text-to-speech engine. Usually the + * error will occur when Voice Text has enumerated and found an + * appropriate text-to-speech engine, then it is not able to actually + * select/start the engine. + */ +#define VTXTERR_CANTSELECTENGINE VTXTERROR(0x17) // 0x80040717 + +/* + * Voice Text could not create a notfication sink for engine + * notifications + */ +#define VTXTERR_CANTCREATENOTIFY VTXTERROR(0x18) // 0x80040718 + +/* + * Voice Text is disabled at this time + */ +#define VTXTERR_NOTENABLED VTXTERROR(0x19) // 0x80040719 + +#define VTXTERR_OUTOFDISK SRERR_OUTOFDISK // 0x80040205 +#define VTXTERR_NOTSUPPORTED E_NOTIMPL // 0x80004001 +#define VTXTERR_NOTENOUGHDATA AUDERR_NOTENOUGHDATA // 0x80040201 +#define VTXTERR_QUEUEFULL TTSERR_QUEUEFULL // 0x8004020A +#define VTXTERR_VALUEOUTOFRANGE E_UNEXPECTED // 0x8000FFFF +#define VTXTERR_INVALIDWINDOW OLE_E_INVALIDHWND // 0x8004000F +#define VTXTERR_WAVEDEVICEBUSY AUDERR_WAVEDEVICEBUSY // 0x80040203 +#define VTXTERR_WAVEFORMATNOTSUPPORTED AUDERR_WAVEFORMATNOTSUPPORTED // 0x80040202 +#define VTXTERR_INVALIDCHAR SRERR_INVALIDCHAR // 0x80040208 + + +// ILexPronounce errors +#define LEXERR_INVALIDTEXTCHAR LEXERROR(0x01) // 0x80040801 +#define LEXERR_INVALIDSENSE LEXERROR(0x02) // 0x80040802 +#define LEXERR_NOTINLEX LEXERROR(0x03) // 0x80040803 +#define LEXERR_OUTOFDISK LEXERROR(0x04) // 0x80040804 +#define LEXERR_INVALIDPRONCHAR LEXERROR(0x05) // 0x80040805 +#define LEXERR_ALREADYINLEX LEXWARNING(0x06) // 0x00040806 +#define LEXERR_PRNBUFTOOSMALL LEXERROR(0x07) // 0x80040807 +#define LEXERR_ENGBUFTOOSMALL LEXERROR(0x08) // 0x80040808 +#define LEXERR_INVALIDLEX LEXERROR(0x09) // 0x80040809 + + + +/************************************************************************ +typedefs */ + +typedef LPUNKNOWN FAR * PIUNKNOWN; + +typedef struct { + PVOID pData; + DWORD dwSize; + } SDATA, * PSDATA; + + + +typedef struct { + LANGID LanguageID; + WCHAR szDialect[LANG_LEN]; + } LANGUAGEW, FAR * PLANGUAGEW; + +typedef struct { + LANGID LanguageID; + CHAR szDialect[LANG_LEN]; + } LANGUAGEA, FAR * PLANGUAGEA; + +#ifdef _S_UNICODE +#define LANGUAGE LANGUAGEW +#define PLANGUAGE PLANGUAGEW +#else +#define LANGUAGE LANGUAGEA +#define PLANGUAGE PLANGUAGEA +#endif // _S_UNICODE + + +typedef struct { + HRESULT hRes; + WCHAR szStrings[512]; + } SPCHERRORW, FAR * PSPCHERRORW; + +typedef struct { + HRESULT hRes; + CHAR szStrings[512]; + } SPCHERRORA, FAR * PSPCHERRORA; + +#ifdef _S_UNICODE +#define SPCHERROR SPCHERRORW +#define PSPCHERROR PSPCHERRORW +#else +#define SPCHERROR SPCHERRORA +#define PSPCHERROR PSPCHERRORA +#endif // _S_UNICODE + + + +typedef unsigned __int64 QWORD, * PQWORD; + +typedef enum { + CHARSET_TEXT = 0, + CHARSET_IPAPHONETIC = 1, + CHARSET_ENGINEPHONETIC = 2 + } VOICECHARSET; + +typedef enum _VOICEPARTOFSPEECH { + VPS_UNKNOWN = 0, + VPS_NOUN = 1, + VPS_VERB = 2, + VPS_ADVERB = 3, + VPS_ADJECTIVE = 4, + VPS_PROPERNOUN = 5, + VPS_PRONOUN = 6, + VPS_CONJUNCTION = 7, + VPS_CARDINAL = 8, + VPS_ORDINAL = 9, + VPS_DETERMINER = 10, + VPS_QUANTIFIER = 11, + VPS_PUNCTUATION = 12, + VPS_CONTRACTION = 13, + VPS_INTERJECTION = 14, + VPS_ABBREVIATION = 15, + VPS_PREPOSITION = 16 + } VOICEPARTOFSPEECH; + + +typedef struct { + DWORD dwNextPhonemeNode; + DWORD dwUpAlternatePhonemeNode; + DWORD dwDownAlternatePhonemeNode; + DWORD dwPreviousPhonemeNode; + DWORD dwWordNode; + QWORD qwStartTime; + QWORD qwEndTime; + DWORD dwPhonemeScore; + WORD wVolume; + WORD wPitch; + } SRRESPHONEMENODE, *PSRRESPHONEMENODE; + + +typedef struct { + DWORD dwNextWordNode; + DWORD dwUpAlternateWordNode; + DWORD dwDownAlternateWordNode; + DWORD dwPreviousWordNode; + DWORD dwPhonemeNode; + QWORD qwStartTime; + QWORD qwEndTime; + DWORD dwWordScore; + WORD wVolume; + WORD wPitch; + VOICEPARTOFSPEECH pos; + DWORD dwCFGParse; + DWORD dwCue; + } SRRESWORDNODE, * PSRRESWORDNODE; + + +/************************************************************************ +interfaces */ + +/* + * IAttributes + */ + +/* attribute values */ +#define TTSBASEATTR 0x1000 +#define SRBASEATTR 0x2000 +#define VDCTBASEATTR 0x3000 +#define VCMDBASEATTR 0x4000 +#define VTXTBASEATTR 0x5000 +#define AUDBASEATTR 0x6000 + +#define TTSATTR_PITCH (1) +#define TTSATTR_REALTIME (0) +#define TTSATTR_SPEED (2) +#define TTSATTR_VOLUME (3) +#define TTSATTR_PITCHRANGE (TTSBASEATTR + 5) +#define TTSATTR_PITCHRANGEDEFAULT (TTSBASEATTR + 6) +#define TTSATTR_PITCHRANGEMAX (TTSBASEATTR + 7) +#define TTSATTR_PITCHRANGEMIN (TTSBASEATTR + 8) +#define TTSATTR_PITCHRANGERELATIVE (TTSBASEATTR + 9) +#define TTSATTR_PITCHRANGERELATIVEMAX (TTSBASEATTR + 10) +#define TTSATTR_PITCHRANGERELATIVEMIN (TTSBASEATTR + 11) +#define TTSATTR_PITCHRELATIVE (TTSBASEATTR + 12) +#define TTSATTR_PITCHRELATIVEMAX (TTSBASEATTR + 13) +#define TTSATTR_PITCHRELATIVEMIN (TTSBASEATTR + 14) +#define TTSATTR_PITCHDEFAULT (TTSBASEATTR + 15) +#define TTSATTR_PITCHMAX (TTSBASEATTR + 16) +#define TTSATTR_PITCHMIN (TTSBASEATTR + 17) +#define TTSATTR_SPEEDRELATIVE (TTSBASEATTR + 18) +#define TTSATTR_SPEEDRELATIVEMAX (TTSBASEATTR + 19) +#define TTSATTR_SPEEDRELATIVEMIN (TTSBASEATTR + 20) +#define TTSATTR_SPEEDDEFAULT (TTSBASEATTR + 21) +#define TTSATTR_SPEEDMAX (TTSBASEATTR + 22) +#define TTSATTR_SPEEDMIN (TTSBASEATTR + 23) +#define TTSATTR_THREADPRIORITY (TTSBASEATTR + 24) +#define TTSATTR_SINKFLAGS (TTSBASEATTR + 25) +#define TTSATTR_VOLUMEDEFAULT (TTSBASEATTR + 26) + +#define SRATTR_AUTOGAIN (1) +#define SRATTR_ECHO (3) +#define SRATTR_ENERGYFLOOR (4) +#define SRATTR_MICROPHONE (5) +#define SRATTR_REALTIME (6) +#define SRATTR_SPEAKER (7) +#define SRATTR_TIMEOUT_COMPLETE (8) +#define SRATTR_TIMEOUT_INCOMPLETE (SRBASEATTR + 8) +#define SRATTR_THRESHOLD (2) +#define SRATTR_ACCURACYSLIDER (SRBASEATTR + 10) +#define SRATTR_LEVEL (SRBASEATTR + 11) +#define SRATTR_LISTENINGSTATE (SRBASEATTR + 12) +#define SRATTR_RESULTSINFO (SRBASEATTR + 13) +#define SRATTR_RESULTSINFO_POSSIBLE (SRBASEATTR + 14) +#define SRATTR_SINKFLAGS (SRBASEATTR + 15) +#define SRATTR_THREADPRIORITY (SRBASEATTR + 16) + +#define VDCTATTR_AWAKESTATE (VDCTBASEATTR + 1) +#define VDCTATTR_MODE (VDCTBASEATTR + 2) +#define VDCTATTR_MEMORY (VDCTBASEATTR + 3) +#define VDCTATTR_CORRECTIONRECT (VDCTBASEATTR + 4) +#define VDCTATTR_VISIBLETEXTSTART (VDCTBASEATTR + 5) +#define VDCTATTR_VISIBLETEXTCHARS (VDCTBASEATTR + 6) +#define VDCTATTR_INSERTIONGUI (VDCTBASEATTR + 7) // turn on ISRGramInsertionGUI + +#define VCMDATTR_AWAKESTATE (VCMDBASEATTR + 1) +#define VCMDATTR_DEVICE (VCMDBASEATTR + 2) +#define VCMDATTR_ENABLED (VCMDBASEATTR + 3) +#define VCMDATTR_SRMODE (VCMDBASEATTR + 4) + +#define AUDATTR_USELOWPRIORITY (AUDBASEATTR + 1) // MMAudioSource: if true, send low priority message to card when starting +#define AUDATTR_AUTORETRY (AUDBASEATTR + 2) // MMAudioSource: if true, keep retrying to open wave device if can't initially +#define AUDATTR_TIMERMS (AUDBASEATTR + 3) // MMAudioDest: milliseconds between timer ticks, when send out buffers, etc. +#define AUDATTR_DIRECTFLAGS (AUDBASEATTR + 4) // DirectSoundAudioDest: Flages to send into CreateSoundBuffer + // set these values before waveformatset. Use to do 3-d tts + +// SRATTR_RESULTSINFO flags +#define SRRI_AUDIO SETBIT(0) +#define SRRI_AUDIO_UNCOMPRESSED SETBIT(1) +#define SRRI_ALTERNATIVES SETBIT(2) +#define SRRI_WORDGRAPH SETBIT(3) +#define SRRI_PHONEMEGRAPH SETBIT(4) + +// SRATTR_SINKFLAGS flags +#define SRASF_ATTRIBUTES SETBIT(0) +#define SRASF_INTERFERENCE SETBIT(1) +#define SRASF_SOUND SETBIT(2) +#define SRASF_UTTERANCEBEGIN SETBIT(3) +#define SRASF_UTTERANCEEND SETBIT(4) +#define SRASF_VUMETER SETBIT(5) +#define SRASF_PHRASEHYPOTHESIS SETBIT(6) +#define SRASF_TRAINING SETBIT(7) +#define SRASF_ERRORWARNING SETBIT(8) + +#undef INTERFACE +#define INTERFACE IAttributesW + +// {1D59DED1-E367-11d1-BED7-006008317CE8} +DEFINE_GUID(IID_IAttributesW, +0x1d59ded1, 0xe367, 0x11d1, 0xbe, 0xd7, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +DECLARE_INTERFACE_ (IAttributesW, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // AttributesW members + STDMETHOD (DWORDGet) (DWORD, DWORD*) PURE; + STDMETHOD (DWORDSet) (DWORD, DWORD) PURE; + STDMETHOD (StringGet) (DWORD, PWSTR, DWORD, DWORD *) PURE; + STDMETHOD (StringSet) (DWORD, PCWSTR) PURE; + STDMETHOD (MemoryGet) (DWORD, PVOID*, DWORD*) PURE; + STDMETHOD (MemorySet) (DWORD, PVOID, DWORD) PURE; + }; + +typedef IAttributesW FAR * PIATTRIBUTESW; + + +#undef INTERFACE +#define INTERFACE IAttributesA + +// {1D59DED2-E367-11d1-BED7-006008317CE8} +DEFINE_GUID(IID_IAttributesA, +0x1d59ded2, 0xe367, 0x11d1, 0xbe, 0xd7, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +DECLARE_INTERFACE_ (IAttributesA, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // AttributesA members + STDMETHOD (DWORDGet) (DWORD, DWORD*) PURE; + STDMETHOD (DWORDSet) (DWORD, DWORD) PURE; + STDMETHOD (StringGet) (DWORD, PSTR, DWORD, DWORD *) PURE; + STDMETHOD (StringSet) (DWORD, PCSTR) PURE; + STDMETHOD (MemoryGet) (DWORD, PVOID*, DWORD*) PURE; + STDMETHOD (MemorySet) (DWORD, PVOID, DWORD) PURE; + }; + +typedef IAttributesA FAR * PIATTRIBUTESA; + + +#ifdef _S_UNICODE + #define IAttributes IAttributesW + #define IID_IAttributes IID_IAttributesW + #define PIATTRIBUTES PIATTRIBUTESW + +#else + #define IAttributes IAttributesA + #define IID_IAttributes IID_IAttributesA + #define PIATTRIBUTES PIATTRIBUTESA + +#endif // _S_UNICODE + + +/* + * ISpchError + */ + +#undef INTERFACE +#define INTERFACE ISpchErrorW + +// {9B445335-E39F-11d1-BED7-006008317CE8} +DEFINE_GUID(IID_ISpchErrorW, +0x9b445335, 0xe39f, 0x11d1, 0xbe, 0xd7, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +DECLARE_INTERFACE_ (ISpchErrorW, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // SpchError members + STDMETHOD (LastErrorGet) (THIS_ SPCHERRORW *) PURE; + STDMETHOD (ErrorMessageGet) (THIS_ WCHAR *, DWORD, DWORD *) PURE; + }; + +typedef ISpchErrorW FAR * PISPCHERRORW; + + +#undef INTERFACE +#define INTERFACE ISpchErrorA + +// {9B445336-E39F-11d1-BED7-006008317CE8} +DEFINE_GUID(IID_ISpchErrorA, +0x9b445336, 0xe39f, 0x11d1, 0xbe, 0xd7, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +DECLARE_INTERFACE_ (ISpchErrorA, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // SpchError members + STDMETHOD (LastErrorGet) (THIS_ SPCHERRORA *) PURE; + STDMETHOD (ErrorMessageGet) (THIS_ CHAR *, DWORD, DWORD *) PURE; + }; + +typedef ISpchErrorA FAR * PISPCHERRORA; +#ifdef _S_UNICODE + #define ISpchError ISpchErrorW + #define IID_ISpchError IID_ISpchErrorW + #define PISPCHERROR PISPCHERRORW + +#else + #define ISpchError ISpchErrorA + #define IID_ISpchError IID_ISpchErrorA + #define PISPCHERROR PISPCHERRORA + +#endif // _S_UNICODE + + + + + +/* + * ILexPronounce + */ + +#undef INTERFACE +#define INTERFACE ILexPronounceW + +DEFINE_GUID(IID_ILexPronounceW, 0x090CD9A2, 0xDA1A, 0x11CD, 0xB3, 0xCA, 0x0, 0xAA, 0x0, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ILexPronounceW, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // LexPronounceW members + STDMETHOD (Add) (THIS_ VOICECHARSET, PCWSTR, PCWSTR, + VOICEPARTOFSPEECH, PVOID, DWORD) PURE; + STDMETHOD (Get) (THIS_ VOICECHARSET, PCWSTR, WORD, PWSTR, + DWORD, DWORD *, VOICEPARTOFSPEECH *, PVOID, + DWORD, DWORD *) PURE; + STDMETHOD (Remove) (THIS_ PCWSTR, WORD) PURE; + }; + +typedef ILexPronounceW FAR * PILEXPRONOUNCEW; + + +#undef INTERFACE +#define INTERFACE ILexPronounceA + +DEFINE_GUID(IID_ILexPronounceA, 0x2F26B9C0L, 0xDB31, 0x11CD, 0xB3, 0xCA, 0x00, 0xAA, 0x00, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ILexPronounceA, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // LexPronounceA members + STDMETHOD (Add) (THIS_ VOICECHARSET, PCSTR, PCSTR, + VOICEPARTOFSPEECH, PVOID, DWORD) PURE; + STDMETHOD (Get) (THIS_ VOICECHARSET, PCSTR, WORD, PSTR, + DWORD, DWORD *, VOICEPARTOFSPEECH *, PVOID, + DWORD, DWORD *) PURE; + STDMETHOD (Remove) (THIS_ PCSTR, WORD) PURE; + }; + +typedef ILexPronounceA FAR * PILEXPRONOUNCEA; + + +#ifdef _S_UNICODE + #define ILexPronounce ILexPronounceW + #define IID_ILexPronounce IID_ILexPronounceW + #define PILEXPRONOUNCE PILEXPRONOUNCEW + +#else + #define ILexPronounce ILexPronounceA + #define IID_ILexPronounce IID_ILexPronounceA + #define PILEXPRONOUNCE PILEXPRONOUNCEA + +#endif // _S_UNICODE + + +/* + * ILexPronounce2 + */ + +#define ILP2_ACTIVE SETBIT(0) +#define ILP2_USER SETBIT(1) +#define ILP2_BACKUP SETBIT(2) +#define ILP2_LTS SETBIT(3) + +#undef INTERFACE +#define INTERFACE ILexPronounce2W + +// {D6E56341-B3EA-11d1-AFA5-0000F81E880D} +DEFINE_GUID(IID_ILexPronounce2W, 0xd6e56341, 0xb3ea, 0x11d1, 0xaf, 0xa5, 0x0, 0x0, 0xf8, 0x1e, 0x88, 0xd); + +DECLARE_INTERFACE_ (ILexPronounce2W, ILexPronounceW) { + + // LexPronounceW members + STDMETHOD (Add) (THIS_ VOICECHARSET, PCWSTR, PCWSTR, + VOICEPARTOFSPEECH, PVOID, DWORD) PURE; + STDMETHOD (Get) (THIS_ VOICECHARSET, PCWSTR, WORD, PWSTR, + DWORD, DWORD *, VOICEPARTOFSPEECH *, PVOID, + DWORD, DWORD *) PURE; + STDMETHOD (Remove) (THIS_ PCWSTR, WORD) PURE; + + // LexPronounce2W members + STDMETHOD (AddTo) (THIS_ DWORD, VOICECHARSET, PCWSTR, PCWSTR, + VOICEPARTOFSPEECH, PVOID, DWORD) PURE; + STDMETHOD (GetFrom) (THIS_ DWORD, VOICECHARSET, PCWSTR, WORD, PWSTR, + DWORD, DWORD *, VOICEPARTOFSPEECH *, PVOID, + DWORD, DWORD *) PURE; + STDMETHOD (RemoveFrom) (THIS_ DWORD, PCWSTR, WORD) PURE; + STDMETHOD (QueryLexicons) (THIS_ BOOL, DWORD *) PURE; + STDMETHOD (ChangeSpelling) (THIS_ DWORD, PCWSTR, PCWSTR) PURE; + }; + +typedef ILexPronounce2W FAR * PILEXPRONOUNCE2W; + + +#undef INTERFACE +#define INTERFACE ILexPronounce2A + +// {D6E56342-B3EA-11d1-AFA5-0000F81E880D} +DEFINE_GUID(IID_ILexPronounce2A, 0xd6e56342, 0xb3ea, 0x11d1, 0xaf, 0xa5, 0x0, 0x0, 0xf8, 0x1e, 0x88, 0xd); + +DECLARE_INTERFACE_ (ILexPronounce2A, ILexPronounceA) { + + // LexPronounceA members + STDMETHOD (Add) (THIS_ VOICECHARSET, PCSTR, PCSTR, + VOICEPARTOFSPEECH, PVOID, DWORD) PURE; + STDMETHOD (Get) (THIS_ VOICECHARSET, PCSTR, WORD, PSTR, + DWORD, DWORD *, VOICEPARTOFSPEECH *, PVOID, + DWORD, DWORD *) PURE; + STDMETHOD (Remove) (THIS_ PCSTR, WORD) PURE; + + // LexPronounceA members + STDMETHOD (AddTo) (THIS_ DWORD, VOICECHARSET, PCSTR, PCSTR, + VOICEPARTOFSPEECH, PVOID, DWORD) PURE; + STDMETHOD (GetFrom) (THIS_ DWORD, VOICECHARSET, PCSTR, WORD, PSTR, + DWORD, DWORD *, VOICEPARTOFSPEECH *, PVOID, + DWORD, DWORD *) PURE; + STDMETHOD (RemoveFrom) (THIS_ DWORD, PCSTR, WORD) PURE; + STDMETHOD (QueryLexicons) (THIS_ BOOL, DWORD *) PURE; + STDMETHOD (ChangeSpelling) (THIS_ DWORD, PCSTR, PCSTR) PURE; + }; + +typedef ILexPronounce2A FAR * PILEXPRONOUNCE2A; + + +#ifdef _S_UNICODE + #define ILexPronounce2 ILexPronounce2W + #define IID_ILexPronounce2 IID_ILexPronounce2W + #define PILEXPRONOUNCE2 PILEXPRONOUNCE2W + +#else + #define ILexPronounce2 ILexPronounce2A + #define IID_ILexPronounce2 IID_ILexPronounce2A + #define PILEXPRONOUNCE2 PILEXPRONOUNCE2A + +#endif // _S_UNICODE + +/************************************************************************ +Speech Tools +*/ + +/* defines */ +// ISTMicWizard->Wizard +#define STMWU_CNC 0 +#define STMWU_DICTATION 1 +#define STMWU_LOWERGAIN 0x10000 // if on, tries for a lower gain +#define STMWU_NOAUTOGAIN 0x20000 // if on, doesn't adjust the autogain bit + +#define STMWF_CANSKIP SETBIT(0) + +// MICWIZARDINFO +#define STMWI_UNKNOWN 0 +#define STMWI_CLOSETALK 1 +#define STMWI_EARPIECE 2 +#define STMWI_HANDSET 3 +#define STMWI_CLIPON 4 +#define STMWI_DESKTOP 5 +#define STMWI_HANDHELD 6 +#define STMWI_TOPMONITOR 7 +#define STMWI_INMONITOR 8 +#define STMWI_KEYBOARD 9 +#define STMWI_REMOTE 10 + +#define STMWIS_UNKNOWN 0 +#define STMWIS_SPEAKERS 1 +#define STMWIS_HEADPHONES 2 +#define STMWIS_BOTH 3 + +/* structures */ + +typedef struct { + BOOL fHasRunMicWizard; + DWORD dwWaveInDevice; + DWORD dwMicrophoneType; + WCHAR szMicString[64]; +} MICWIZARDINFO, *PMICWIZARDINFO; + +typedef struct { + BOOL fHasRunMicWizard; + DWORD dwWaveInDevice; + DWORD dwMicrophoneType; + WCHAR szMicString[64]; + DWORD dwSpeakers; + DWORD dwLastMicLevel; + DWORD dwMicLevelDeviceID; +} MICWIZARDINFO2, *PMICWIZARDINFO2; + +// STLexDlg +#define STLD_DISABLEREMOVE SETBIT(0) +#define STLD_DISABLEADD SETBIT(1) +#define STLD_FORCEEDIT SETBIT(2) +#define STLD_DISABLEPRONADDREMOVE SETBIT(3) +#define STLD_TEST SETBIT(4) +#define STLD_DISABLERENAME SETBIT(5) +#define STLD_CHANGEPRONADDS SETBIT(6) + +/* class IDs */ +// {B9F11A95-90E3-11d0-8D77-00A0C9034A7E} +DEFINE_GUID(CLSID_STMicWizard, +0xb9f11a95, 0x90e3, 0x11d0, 0x8d, 0x77, 0x0, 0xa0, 0xc9, 0x3, 0x4a, 0x7e); + +// {92655FB1-ADF9-11d1-BEB9-006008317CE8} +DEFINE_GUID(CLSID_STLexDlg, +0x92655fb1, 0xadf9, 0x11d1, 0xbe, 0xb9, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +// {B9F11A96-90E3-11d0-8D77-00A0C9034A7E} +DEFINE_GUID(CLSID_STPhoneConv, +0xb9f11a96, 0x90e3, 0x11d0, 0x8d, 0x77, 0x0, 0xa0, 0xc9, 0x3, 0x4a, 0x7e); + + +/* interfaces */ +// ISTMicWizard Interface + +#undef INTERFACE +#define INTERFACE ISTMicWizard + +// {B9F11A97-90E3-11d0-8D77-00A0C9034A7E} +DEFINE_GUID(IID_ISTMicWizard, +0xb9f11a97, 0x90e3, 0x11d0, 0x8d, 0x77, 0x0, 0xa0, 0xc9, 0x3, 0x4a, 0x7e); + +DECLARE_INTERFACE_ (ISTMicWizard, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISTMicWizard members + STDMETHOD (InfoGet) (THIS_ PMICWIZARDINFO) PURE; + STDMETHOD (InfoSet) (THIS_ PMICWIZARDINFO) PURE; + STDMETHOD (Wizard) (THIS_ HWND, DWORD, DWORD, DWORD, DWORD) PURE; + }; + +typedef ISTMicWizard FAR * PISTMICWIZARD; + + +// ISTLexDlg Interface + +#undef INTERFACE +#define INTERFACE ISTLexDlg + +// {A27B8A01-ADF9-11d1-BEB9-006008317CE8} +DEFINE_GUID(IID_ISTLexDlg, +0xa27b8a01, 0xadf9, 0x11d1, 0xbe, 0xb9, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +DECLARE_INTERFACE_ (ISTLexDlg, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISTLexDlg members + STDMETHOD (LexDlg) (THIS_ HWND, PCWSTR, DWORD, LANGID, + LPUNKNOWN, LPUNKNOWN, LPUNKNOWN, PCWSTR, PCWSTR) PURE; + }; + +typedef ISTLexDlg FAR * PISTLEXDLG; + +// ISTPhoneConv Interface + +#undef INTERFACE +#define INTERFACE ISTPhoneConv + +// {B9F11A98-90E3-11d0-8D77-00A0C9034A7E} +DEFINE_GUID(IID_ISTPhoneConv, +0xb9f11a98, 0x90e3, 0x11d0, 0x8d, 0x77, 0x0, 0xa0, 0xc9, 0x3, 0x4a, 0x7e); + +DECLARE_INTERFACE_ (ISTPhoneConv, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISTPhoneConv members + STDMETHOD (FromIPA) (THIS_ LPCWSTR, DWORD *, LPWSTR, DWORD, DWORD*) PURE; + STDMETHOD (Get) (THIS_ SDATA *) PURE; + STDMETHOD (SetByLang) (THIS_ LANGID) PURE; + STDMETHOD (SetByText) (THIS_ LPCWSTR) PURE; + STDMETHOD (ToIPA) (THIS_ LPCWSTR, DWORD *, LPWSTR, DWORD, DWORD*) PURE; + }; + +typedef ISTPhoneConv FAR * PISTPHONECONV; + + + +/************************************************************************ +Audio source/destiantion API +*/ + +/************************************************************************ +defines */ + +// AudioStop +#define IANSRSN_NODATA 0 +#define IANSRSN_PRIORITY 1 +#define IANSRSN_INACTIVE 2 +#define IANSRSN_EOF 3 + +// IAudioSourceInstrumented::StateSet +#define IASISTATE_PASSTHROUGH 0 +#define IASISTATE_PASSNOTHING 1 +#define IASISTATE_PASSREADFROMWAVE 2 +#define IASISTATE_PASSWRITETOWAVE 3 + +/************************************************************************ +typedefs */ + +/************************************************************************ +Class IDs */ +// {CB96B400-C743-11cd-80E5-00AA003E4B50} +DEFINE_GUID(CLSID_MMAudioDest, +0xcb96b400, 0xc743, 0x11cd, 0x80, 0xe5, 0x0, 0xaa, 0x0, 0x3e, 0x4b, 0x50); + +// {D24FE500-C743-11cd-80E5-00AA003E4B50} +DEFINE_GUID(CLSID_MMAudioSource, +0xd24fe500, 0xc743, 0x11cd, 0x80, 0xe5, 0x0, 0xaa, 0x0, 0x3e, 0x4b, 0x50); + +// {D4023720-E4B9-11cf-8D56-00A0C9034A7E} +DEFINE_GUID(CLSID_InstAudioSource, +0xd4023720, 0xe4b9, 0x11cf, 0x8d, 0x56, 0x0, 0xa0, 0xc9, 0x3, 0x4a, 0x7e); + +// {D4123720-E4B9-11cf-8D56-00A0C9034A7E} +DEFINE_GUID(CLSID_SuspAudioSource, +0xd4123720, 0xe4b9, 0x11cf, 0x8d, 0x56, 0x0, 0xa0, 0xc9, 0x3, 0x4a, 0x7e); + +// {D4523720-E4B9-11cf-8D56-00A0C9034A7E} +DEFINE_GUID(CLSID_AudioSourceFile, +0xd4523720, 0xe4b9, 0x11cf, 0x8d, 0x56, 0x0, 0xa0, 0xc9, 0x3, 0x4a, 0x7e); + +// {D4523720-E4B9-11cf-8D56-00A0C9034A7E} +DEFINE_GUID(CLSID_AudioDestFile, +0xd4623720, 0xe4b9, 0x11cf, 0x8d, 0x56, 0x0, 0xa0, 0xc9, 0x3, 0x4a, 0x7e); + +// {B9F11A90-90E3-11d0-8D77-00A0C9034A7E} +DEFINE_GUID(CLSID_AudioDestDirect, +0xb9f11a90, 0x90e3, 0x11d0, 0x8d, 0x77, 0x0, 0xa0, 0xc9, 0x3, 0x4a, 0x7e); + +// {32C35401-D04F-11d0-99B3-00AA004CD65C} +DEFINE_GUID(CLSID_AudioSourceDirect, +0x32c35401, 0xd04f, 0x11d0, 0x99, 0xb3, 0x0, 0xaa, 0x0, 0x4c, 0xd6, 0x5c); + + +/************************************************************************ +interfaces */ + +// IAudio +#undef INTERFACE +#define INTERFACE IAudio + +// {F546B340-C743-11cd-80E5-00AA003E4B50} +DEFINE_GUID(IID_IAudio, +0xf546b340, 0xc743, 0x11cd, 0x80, 0xe5, 0x0, 0xaa, 0x0, 0x3e, 0x4b, 0x50); + +DECLARE_INTERFACE_ (IAudio, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IAudio members + STDMETHOD (Flush) (THIS) PURE; + STDMETHOD (LevelGet) (THIS_ DWORD *) PURE; + STDMETHOD (LevelSet) (THIS_ DWORD) PURE; + STDMETHOD (PassNotify) (THIS_ PVOID, IID) PURE; + STDMETHOD (PosnGet) (THIS_ PQWORD) PURE; + STDMETHOD (Claim) (THIS) PURE; + STDMETHOD (UnClaim) (THIS) PURE; + STDMETHOD (Start) (THIS) PURE; + STDMETHOD (Stop) (THIS) PURE; + STDMETHOD (TotalGet) (THIS_ PQWORD) PURE; + STDMETHOD (ToFileTime) (THIS_ PQWORD, FILETIME *) PURE; + STDMETHOD (WaveFormatGet) (THIS_ PSDATA) PURE; + STDMETHOD (WaveFormatSet) (THIS_ SDATA) PURE; + }; + +typedef IAudio FAR * PIAUDIO; + +// IAudioDest + +#undef INTERFACE +#define INTERFACE IAudioDest + +// {2EC34DA0-C743-11cd-80E5-00AA003E4B50} +DEFINE_GUID(IID_IAudioDest, +0x2ec34da0, 0xc743, 0x11cd, 0x80, 0xe5, 0x0, 0xaa, 0x0, 0x3e, 0x4b, 0x50); + +DECLARE_INTERFACE_ (IAudioDest, IUnknown) { + + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IAudioDest members + STDMETHOD (FreeSpace) (THIS_ DWORD *, BOOL *) PURE; + STDMETHOD (DataSet) (THIS_ PVOID, DWORD) PURE; + STDMETHOD (BookMark) (THIS_ DWORD) PURE; + }; + +typedef IAudioDest FAR * PIAUDIODEST; + + + +// IAudioDestNotifySink + +#undef INTERFACE +#define INTERFACE IAudioDestNotifySink + +// {ACB08C00-C743-11cd-80E5-00AA003E4B50} +DEFINE_GUID(IID_IAudioDestNotifySink, +0xacb08c00, 0xc743, 0x11cd, 0x80, 0xe5, 0x0, 0xaa, 0x0, 0x3e, 0x4b, 0x50); + +DECLARE_INTERFACE_ (IAudioDestNotifySink, IUnknown) { + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IAudioDestNotifySink members + STDMETHOD (AudioStop) (THIS_ WORD) PURE; + STDMETHOD (AudioStart) (THIS) PURE; + STDMETHOD (FreeSpace) (THIS_ DWORD, BOOL) PURE; + STDMETHOD (BookMark) (THIS_ DWORD, BOOL) PURE; + }; + +typedef IAudioDestNotifySink FAR * PIAUDIODESTNOTIFYSINK; + + + +// IAudioMultiMediaDevice + +#undef INTERFACE +#define INTERFACE IAudioMultiMediaDevice + +// {B68AD320-C743-11cd-80E5-00AA003E4B50} +DEFINE_GUID(IID_IAudioMultiMediaDevice, +0xb68ad320, 0xc743, 0x11cd, 0x80, 0xe5, 0x0, 0xaa, 0x0, 0x3e, 0x4b, 0x50); + +DECLARE_INTERFACE_ (IAudioMultiMediaDevice, IUnknown) { + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IAudioMultiMediaDevice members + STDMETHOD (CustomMessage) (THIS_ UINT, SDATA) PURE; + STDMETHOD (DeviceNumGet) (THIS_ DWORD*) PURE; + STDMETHOD (DeviceNumSet) (THIS_ DWORD) PURE; + }; + +typedef IAudioMultiMediaDevice FAR * PIAUDIOMULTIMEDIADEVICE; + + + +// IAudioSource +#undef INTERFACE +#define INTERFACE IAudioSource + +// {BC06A220-C743-11cd-80E5-00AA003E4B50} +DEFINE_GUID(IID_IAudioSource, +0xbc06a220, 0xc743, 0x11cd, 0x80, 0xe5, 0x0, 0xaa, 0x0, 0x3e, 0x4b, 0x50); + +DECLARE_INTERFACE_ (IAudioSource, IUnknown) { + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IAudioSource members + STDMETHOD (DataAvailable) (THIS_ DWORD *, BOOL *) PURE; + STDMETHOD (DataGet) (THIS_ PVOID, DWORD, DWORD *) PURE; + }; + +typedef IAudioSource FAR * PIAUDIOSOURCE; + + + +// IAudioSourceInstrumented +#undef INTERFACE +#define INTERFACE IAudioSourceInstrumented + +// {D4023721-E4B9-11cf-8D56-00A0C9034A7E} +DEFINE_GUID(IID_IAudioSourceInstrumented, +0xd4023721, 0xe4b9, 0x11cf, 0x8d, 0x56, 0x0, 0xa0, 0xc9, 0x3, 0x4a, 0x7e); + +DECLARE_INTERFACE_ (IAudioSourceInstrumented, IUnknown) { + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IAudioSourceInstrumented members + STDMETHOD (AudioSource) (THIS_ LPUNKNOWN) PURE; + STDMETHOD (RegistryGet) (THIS_ PWSTR, DWORD, DWORD *) PURE; + STDMETHOD (RegistrySet) (THIS_ PCWSTR) PURE; + STDMETHOD (StateGet) (THIS_ DWORD*) PURE; + STDMETHOD (StateSet) (THIS_ DWORD) PURE; + STDMETHOD (WaveFileReadGet)(THIS_ PWSTR, DWORD, DWORD *) PURE; + STDMETHOD (WaveFileReadSet)(THIS_ PCWSTR) PURE; + STDMETHOD (WaveFileWriteGet)(THIS_ PWSTR, DWORD, DWORD *) PURE; + STDMETHOD (WaveFileWriteSet)(THIS_ PCWSTR) PURE; + }; + +typedef IAudioSourceInstrumented FAR * PIAUDIOSOURCEINSTRUMENTED; + + +// IAudioSourceSusp +#undef INTERFACE +#define INTERFACE IAudioSourceSusp + +// {D4123721-E4B9-11cf-8D56-00A0C9034A7E} +DEFINE_GUID(IID_IAudioSourceSusp, +0xd4123721, 0xe4b9, 0x11cf, 0x8d, 0x56, 0x0, 0xa0, 0xc9, 0x3, 0x4a, 0x7e); + +DECLARE_INTERFACE_ (IAudioSourceSusp, IUnknown) { + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IAudioSourceSusp members + STDMETHOD (AudioSource) (THIS_ LPUNKNOWN) PURE; + STDMETHOD (Pause) (THIS) PURE; + STDMETHOD (Resume) (THIS) PURE; + }; + +typedef IAudioSourceSusp FAR * PIAUDIOSOURCESUSP; + + +// IAudioSourceNotifySink +#undef INTERFACE +#define INTERFACE IAudioSourceNotifySink + +// {C0BD9A80-C743-11cd-80E5-00AA003E4B50} +DEFINE_GUID(IID_IAudioSourceNotifySink, +0xc0bd9a80, 0xc743, 0x11cd, 0x80, 0xe5, 0x0, 0xaa, 0x0, 0x3e, 0x4b, 0x50); + +DECLARE_INTERFACE_ (IAudioSourceNotifySink, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IAudioSourceNotifySink members + STDMETHOD (AudioStop) (THIS_ WORD) PURE; + STDMETHOD (AudioStart) (THIS) PURE; + STDMETHOD (DataAvailable) (THIS_ DWORD, BOOL) PURE; + STDMETHOD (Overflow) (THIS_ DWORD) PURE; + }; + +typedef IAudioSourceNotifySink FAR * PIAUDIOSOURCENOTIFYSINK; + +// IAudioFileNotifySink Interface +#undef INTERFACE +#define INTERFACE IAudioFileNotifySink + +// {492FE490-51E7-11b9-C000-FED6CBA3B1A9} +DEFINE_GUID( IID_IAudioFileNotifySink, 0x492fe490, 0x51e7, 0x11b9, 0xc0, 0x0, 0xfe, 0xd6, 0xcb, 0xa3, 0xb1, 0xa9); + +DECLARE_INTERFACE_ (IAudioFileNotifySink, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IAudioSourceNotifySink members + STDMETHOD (FileBegin) (THIS_ DWORD) PURE; + STDMETHOD (FileEnd) (THIS_ DWORD) PURE; + STDMETHOD (QueueEmpty) (THIS) PURE; + STDMETHOD (Posn) (THIS_ QWORD, QWORD) PURE; + }; + +typedef IAudioFileNotifySink FAR * PIAUDIOFILENOTIFYSINK; + + + +// IAudioFile Interface + +#undef INTERFACE +#define INTERFACE IAudioFile + +// {FD7C2320-3D6D-11b9-C000-FED6CBA3B1A9} +DEFINE_GUID( IID_IAudioFile, 0xfd7c2320, 0x3d6d, 0x11b9, 0xc0, 0x0, 0xfe, 0xd6, 0xcb, 0xa3, 0xb1, 0xa9); + +DECLARE_INTERFACE_ (IAudioFile, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IAudioFile members + STDMETHOD (Register) (THIS_ PIAUDIOFILENOTIFYSINK) PURE; + STDMETHOD (Set) (THIS_ LPCWSTR pszFile, DWORD dwID) PURE; + STDMETHOD (Add) (THIS_ LPCWSTR pszFile, DWORD dwID) PURE; + STDMETHOD (Flush) (THIS) PURE; + STDMETHOD (RealTimeSet) (THIS_ WORD wTime) PURE; + STDMETHOD (RealTimeGet) (THIS_ WORD *pwTime) PURE; + }; + +typedef IAudioFile FAR * PIAUDIOFILE; + + +// IAudioDirect Interface + +#undef INTERFACE +#define INTERFACE IAudioDirect + +// {B9F11A94-90E3-11d0-8D77-00A0C9034A7E} +DEFINE_GUID(IID_IAudioDirect, +0xb9f11a94, 0x90e3, 0x11d0, 0x8d, 0x77, 0x0, 0xa0, 0xc9, 0x3, 0x4a, 0x7e); + +DECLARE_INTERFACE_ (IAudioDirect, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IAudioDirect members + STDMETHOD (Init) (THIS_ PVOID, REFIID) PURE; + }; + +typedef IAudioDirect FAR * PIAUDIODIRECT; + + + +/************************************************************************ +defines */ +/* SRINFO */ +#define SRMI_NAMELEN SVFN_LEN + +#define SRSEQUENCE_DISCRETE (0) +#define SRSEQUENCE_CONTINUOUS (1) +#define SRSEQUENCE_WORDSPOT (2) +#define SRSEQUENCE_CONTCFGDISCDICT (3) + +#define SRGRAM_CFG SETBIT(0) +#define SRGRAM_DICTATION SETBIT(1) +#define SRGRAM_LIMITEDDOMAIN SETBIT(2) + +#define SRFEATURE_INDEPSPEAKER SETBIT(0) +#define SRFEATURE_INDEPMICROPHONE SETBIT(1) +#define SRFEATURE_TRAINWORD SETBIT(2) +#define SRFEATURE_TRAINPHONETIC SETBIT(3) +#define SRFEATURE_WILDCARD SETBIT(4) +#define SRFEATURE_ANYWORD SETBIT(5) +#define SRFEATURE_PCOPTIMIZED SETBIT(6) +#define SRFEATURE_PHONEOPTIMIZED SETBIT(7) +#define SRFEATURE_GRAMLIST SETBIT(8) +#define SRFEATURE_GRAMLINK SETBIT(9) +#define SRFEATURE_MULTILINGUAL SETBIT(10) +#define SRFEATURE_GRAMRECURSIVE SETBIT(11) +#define SRFEATURE_IPAUNICODE SETBIT(12) +#define SRFEATURE_SINGLEINSTANCE SETBIT(13) +#define SRFEATURE_THREADSAFE SETBIT(14) +#define SRFEATURE_FIXEDAUDIO SETBIT(15) +#define SRFEATURE_IPAWORD SETBIT(16) +#define SRFEATURE_SAPI4 SETBIT(17) + +#define SRI_ILEXPRONOUNCE SETBIT(0) +#define SRI_ISRATTRIBUTES SETBIT(1) +#define SRI_ISRCENTRAL SETBIT(2) +#define SRI_ISRDIALOGS SETBIT(3) +#define SRI_ISRGRAMCOMMON SETBIT(4) +#define SRI_ISRGRAMCFG SETBIT(5) +#define SRI_ISRGRAMDICTATION SETBIT(6) +#define SRI_ISRGRAMINSERTIONGUI SETBIT(7) +#define SRI_ISRESBASIC SETBIT(8) +#define SRI_ISRESMERGE SETBIT(9) +#define SRI_ISRESAUDIO SETBIT(10) +#define SRI_ISRESCORRECTION SETBIT(11) +#define SRI_ISRESEVAL SETBIT(12) +#define SRI_ISRESGRAPH SETBIT(13) +#define SRI_ISRESMEMORY SETBIT(14) +#define SRI_ISRESMODIFYGUI SETBIT(15) +#define SRI_ISRESSPEAKER SETBIT(16) +#define SRI_ISRSPEAKER SETBIT(17) +#define SRI_ISRESSCORES SETBIT(18) +#define SRI_ISRESAUDIOEX SETBIT(19) +#define SRI_ISRGRAMLEXPRON SETBIT(20) +#define SRI_ISRRESGRAPHEX SETBIT(21) +#define SRI_ILEXPRONOUNCE2 SETBIT(22) +#define SRI_IATTRIBUTES SETBIT(23) +#define SRI_ISRSPEAKER2 SETBIT(24) +#define SRI_ISRDIALOGS2 SETBIT(25) + + +// ISRGramCommon::TrainQuery +#define SRGRAMQ_NONE 0 +#define SRGRAMQ_GENERALTRAIN 1 +#define SRGRAMQ_PHRASE 2 +#define SRGRAMQ_DIALOG 3 + +// ISRGramNotifySink::PhraseFinish +#define ISRNOTEFIN_RECOGNIZED SETBIT(0) +#define ISRNOTEFIN_THISGRAMMAR SETBIT(1) +#define ISRNOTEFIN_FROMTHISGRAMMAR SETBIT(2) + +// ISRGramNotifySink::Training +#define SRGNSTRAIN_GENERAL SETBIT(0) +#define SRGNSTRAIN_GRAMMAR SETBIT(1) +#define SRGNSTRAIN_MICROPHONE SETBIT(2) + +// ISRNotifySink::AttribChange +#define ISRNSAC_AUTOGAINENABLE 1 +#define ISRNSAC_THRESHOLD 2 +#define ISRNSAC_ECHO 3 +#define ISRNSAC_ENERGYFLOOR 4 +#define ISRNSAC_MICROPHONE 5 +#define ISRNSAC_REALTIME 6 +#define ISRNSAC_SPEAKER 7 +#define ISRNSAC_TIMEOUT 8 +#define ISRNSAC_STARTLISTENING 9 +#define ISRNSAC_STOPLISTENING 10 + +/* Interference */ +#define SRMSGINT_NOISE (0x0001) +#define SRMSGINT_NOSIGNAL (0x0002) +#define SRMSGINT_TOOLOUD (0x0003) +#define SRMSGINT_TOOQUIET (0x0004) +#define SRMSGINT_AUDIODATA_STOPPED (0x0005) +#define SRMSGINT_AUDIODATA_STARTED (0x0006) +#define SRMSGINT_IAUDIO_STARTED (0x0007) +#define SRMSGINT_IAUDIO_STOPPED (0x0008) + +// Grammar header values +#define SRHDRTYPE_CFG 0 +#define SRHDRTYPE_LIMITEDDOMAIN 1 +#define SRHDRTYPE_DICTATION 2 + +#define SRHDRFLAG_UNICODE SETBIT(0) + +// results objects defines +#define SRRESCUE_COMMA 1 +#define SRRESCUE_DECLARATIVEBEGIN 2 +#define SRRESCUE_DECLARATIVEEND 3 +#define SRRESCUE_IMPERATIVEBEGIN 4 +#define SRRESCUE_IMPERATIVEEND 5 +#define SRRESCUE_INTERROGATIVEBEGIN 6 +#define SRRESCUE_INTERROGATIVEEND 7 +#define SRRESCUE_NOISE 8 +#define SRRESCUE_PAUSE 9 +#define SRRESCUE_SENTENCEBEGIN 10 +#define SRRESCUE_SENTENCEEND 11 +#define SRRESCUE_UM 12 +#define SRRESCUE_WILDCARD 13 +#define SRRESCUE_WORD 14 + +/* SRCFGSYMBOL */ +#define SRCFG_STARTOPERATION (1) +#define SRCFG_ENDOPERATION (2) +#define SRCFG_WORD (3) +#define SRCFG_RULE (4) +#define SRCFG_WILDCARD (5) +#define SRCFG_LIST (6) + +#define SRCFGO_SEQUENCE (1) +#define SRCFGO_ALTERNATIVE (2) +#define SRCFGO_REPEAT (3) +#define SRCFGO_OPTIONAL (4) + + +// Grammar-chunk IDs +#define SRCK_LANGUAGE 1 +#define SRCKCFG_WORDS 2 +#define SRCKCFG_RULES 3 +#define SRCKCFG_EXPORTRULES 4 +#define SRCKCFG_IMPORTRULES 5 +#define SRCKCFG_LISTS 6 +#define SRCKD_TOPIC 7 +#define SRCKD_COMMON 8 +#define SRCKD_GROUP 9 +#define SRCKD_SAMPLE 10 +#define SRCKLD_WORDS 11 +#define SRCKLD_GROUP 12 +#define SRCKLD_SAMPLE 13 +#define SRCKD_WORDCOUNT 14 +#define SRCKD_NGRAM 15 + +/* TrainQuery */ +#define SRTQEX_REQUIRED (0x0000) +#define SRTQEX_RECOMMENDED (0x0001) + +/* ISRResAudioEx */ +#define SRAUDIOTIMESTAMP_DEFAULT ((QWORD) -1) + +/* ISRResCorrection */ +#define SRCORCONFIDENCE_SOME (0x0001) +#define SRCORCONFIDENCE_VERY (0x0002) + +/* ISRResGraphEx */ +DEFINE_GUID(SRGARC_ACOUSTICSCORE, 0xbf2f5b20, 0xb91d, 0x11d1, 0xb7, 0xbc, 0x0, 0x60, 0x97, 0x98, 0x41, 0xb4); +DEFINE_GUID(SRGARC_WORDTEXT, 0xbf2f5b21, 0xb91d, 0x11d1, 0xb7, 0xbc, 0x0, 0x60, 0x97, 0x98, 0x41, 0xb4); +DEFINE_GUID(SRGARC_NONLEXICALTEXT, 0x62ec00, 0xbaa0, 0x11d1, 0xb7, 0xbd, 0x0, 0x60, 0x97, 0x98, 0x41, 0xb4); +DEFINE_GUID(SRGARC_WORDPRONUNCIATION, 0xbf2f5b22, 0xb91d, 0x11d1, 0xb7, 0xbc, 0x0, 0x60, 0x97, 0x98, 0x41, 0xb4); +DEFINE_GUID(SRGNODE_TIME, 0xbf2f5b23, 0xb91d, 0x11d1, 0xb7, 0xbc, 0x0, 0x60, 0x97, 0x98, 0x41, 0xb4); + +#define SRGEX_ACOUSTICONLY SETBIT(0) +#define SRGEX_LMONLY SETBIT(1) +#define SRGEX_ACOUSTICANDLM SETBIT(2) + +/* ISRResMemory constants */ +#define SRRESMEMKIND_AUDIO SETBIT(0) +#define SRRESMEMKIND_CORRECTION SETBIT(1) +#define SRRESMEMKIND_EVAL SETBIT(2) +#define SRRESMEMKIND_PHONEMEGRAPH SETBIT(3) +#define SRRESMEMKIND_WORDGRAPH SETBIT(4) + +// Attribute minimums and maximums +#define SRATTR_MINAUTOGAIN 0 +#define SRATTR_MAXAUTOGAIN 100 +#define SRATTR_MINENERGYFLOOR 0 +#define SRATTR_MAXENERGYFLOOR 0xffff +#define SRATTR_MINREALTIME 0 +#define SRATTR_MAXREALTIME 0xffffffff +#define SRATTR_MINTHRESHOLD 0 +#define SRATTR_MAXTHRESHOLD 100 +#define SRATTR_MINTOINCOMPLETE 0 +#define SRATTR_MAXTOINCOMPLETE 0xffffffff +#define SRATTR_MINTOCOMPLETE 0 +#define SRATTR_MAXTOCOMPLETE 0xffffffff + + +/************************************************************************ +typedefs */ + +typedef struct { + DWORD dwSize; + DWORD dwUniqueID; + BYTE abData[0]; + } SRCFGRULE, * PSRCFGRULE; + + + +typedef struct { + DWORD dwSize; + DWORD dwRuleNum; + WCHAR szString[0]; + } SRCFGIMPRULEW, * PSRCFGIMPRULEW; + +typedef struct { + DWORD dwSize; + DWORD dwRuleNum; + CHAR szString[0]; + } SRCFGIMPRULEA, * PSRCFGIMPRULEA; + +#ifdef _S_UNICODE +#define SRCFGIMPRULE SRCFGIMPRULEW +#define PSRCFGIMPRULE PSRCFGIMPRULEW +#else +#define SRCFGIMPRULE SRCFGIMPRULEA +#define PSRCFGIMPRULE PSRCFGIMPRULEA +#endif // _S_UNICODE + + + +typedef struct { + DWORD dwSize; + DWORD dwRuleNum; + WCHAR szString[0]; + } SRCFGXRULEW, * PSRCFGXRULEW; + +typedef struct { + DWORD dwSize; + DWORD dwRuleNum; + CHAR szString[0]; + } SRCFGXRULEA, * PSRCFGXRULEA; + +#ifdef _S_UNICODE +#define SRCFGXRULE SRCFGXRULEW +#define PSRCFGXRULE PSRCFGXRULEW +#else +#define SRCFGXRULE SRCFGXRULEA +#define PSRCFGXRULE PSRCFGXRULEA +#endif // _S_UNICODE + + + +typedef struct { + DWORD dwSize; + DWORD dwListNum; + WCHAR szString[0]; + } SRCFGLISTW, * PSRCFGLISTW; + +typedef struct { + DWORD dwSize; + DWORD dwListNum; + CHAR szString[0]; + } SRCFGLISTA, * PSRCFGLISTA; + +#ifdef _S_UNICODE +#define SRCFGLIST SRCFGLISTW +#define PSRCFGLIST PSRCFGLISTW +#else +#define SRCFGLIST SRCFGLISTA +#define PSRCFGLIST PSRCFGLISTA +#endif // _S_UNICODE + + + +typedef struct { + WORD wType; + WORD wProbability; + DWORD dwValue; + } SRCFGSYMBOL, * PSRCFGSYMBOL; + + + +typedef struct { + DWORD dwSize; + DWORD dwWordNum; + WCHAR szWord[0]; + } SRWORDW, * PSRWORDW; + +typedef struct { + DWORD dwSize; + DWORD dwWordNum; + CHAR szWord[0]; + } SRWORDA, * PSRWORDA; + +#ifdef _S_UNICODE +#define SRWORD SRWORDW +#define PSRWORD PSRWORDW +#else +#define SRWORD SRWORDA +#define PSRWORD PSRWORDA +#endif // _S_UNICODE + + + +typedef struct { + DWORD dwSize; + BYTE abWords[0]; + } SRPHRASEW, * PSRPHRASEW; + +typedef struct { + DWORD dwSize; + BYTE abWords[0]; + } SRPHRASEA, * PSRPHRASEA; + +#ifdef _S_UNICODE +#define SRPHRASE SRPHRASEW +#define PSRPHRASE PSRPHRASEW +#else +#define SRPHRASE SRPHRASEA +#define PSRPHRASE PSRPHRASEA +#endif // _S_UNICODE + + + +typedef struct { + DWORD dwType; + DWORD dwFlags; + } SRHEADER, *PSRHEADER; + +typedef struct { + DWORD dwChunkID; + DWORD dwChunkSize; + BYTE avInfo[0]; + } SRCHUNK, *PSRCHUNK; + + + +typedef struct { + GUID gEngineID; + WCHAR szMfgName[SRMI_NAMELEN]; + WCHAR szProductName[SRMI_NAMELEN]; + GUID gModeID; + WCHAR szModeName[SRMI_NAMELEN]; + LANGUAGEW language; + DWORD dwSequencing; + DWORD dwMaxWordsVocab; + DWORD dwMaxWordsState; + DWORD dwGrammars; + DWORD dwFeatures; + DWORD dwInterfaces; + DWORD dwEngineFeatures; + } SRMODEINFOW, * PSRMODEINFOW; + +typedef struct { + GUID gEngineID; + CHAR szMfgName[SRMI_NAMELEN]; + CHAR szProductName[SRMI_NAMELEN]; + GUID gModeID; + CHAR szModeName[SRMI_NAMELEN]; + LANGUAGEA language; + DWORD dwSequencing; + DWORD dwMaxWordsVocab; + DWORD dwMaxWordsState; + DWORD dwGrammars; + DWORD dwFeatures; + DWORD dwInterfaces; + DWORD dwEngineFeatures; + } SRMODEINFOA, * PSRMODEINFOA; + +#ifdef _S_UNICODE +#define SRMODEINFO SRMODEINFOW +#define PSRMODEINFO PSRMODEINFOW +#else +#define SRMODEINFO SRMODEINFOA +#define PSRMODEINFO PSRMODEINFOA +#endif // _S_UNICODE + + + +typedef struct { + DWORD dwEngineID; + DWORD dwMfgName; + DWORD dwProductName; + DWORD dwModeID; + DWORD dwModeName; + DWORD dwLanguage; + DWORD dwDialect; + DWORD dwSequencing; + DWORD dwMaxWordsVocab; + DWORD dwMaxWordsState; + DWORD dwGrammars; + DWORD dwFeatures; + DWORD dwInterfaces; + DWORD dwEngineFeatures; + } SRMODEINFORANK, * PSRMODEINFORANK; + + + +// speech recognition enumeration sharing object +typedef struct { + QWORD qwInstanceID; + DWORD dwDeviceID; + SRMODEINFOW srModeInfo; +} SRSHAREW, * PSRSHAREW; + +typedef struct { + QWORD qwInstanceID; + DWORD dwDeviceID; + SRMODEINFOA srModeInfo; +} SRSHAREA, * PSRSHAREA; + +#ifdef _S_UNICODE +#define SRSHARE SRSHAREW +#define PSRSHARE PSRSHAREW +#else +#define SRSHARE SRSHAREA +#define PSRSHARE PSRSHAREA +#endif // _S_UNICODE + + + + +// ISRCentral::GrammarLoad +typedef enum { + SRGRMFMT_CFG = 0x0000, + SRGRMFMT_LIMITEDDOMAIN = 0x0001, + SRGRMFMT_DICTATION = 0x0002, + SRGRMFMT_CFGNATIVE = 0x8000, + SRGRMFMT_LIMITEDDOMAINNATIVE = 0x8001, + SRGRMFMT_DICTATIONNATIVE = 0x8002, + SRGRMFMT_DRAGONNATIVE1 = 0x8101, + SRGRMFMT_DRAGONNATIVE2 = 0x8102, + SRGRMFMT_DRAGONNATIVE3 = 0x8103 + } SRGRMFMT, * PSRGRMFMT; + +// SRCKD_NGRAM +typedef struct { + QWORD dwTotalCounts; + DWORD dwNumWordsClasses; + DWORD dwWordClassNameOffset; + DWORD dwNumContextGroups; + DWORD dwContextGroupOffset; + DWORD dwNumClasses; + DWORD dwClassOffset; + BYTE bBitsPerWord; + BYTE abFiller[3]; + DWORD adwProbability[256]; + } NGRAMHDR, * PNGRAMHDR; + +typedef struct { + DWORD dwSize; + QWORD dwTotalCounts; + DWORD adwWordClassID[4]; + DWORD dwNumSequential; + DWORD dwNumRandomAccess; + BYTE bBackOffProbToken; + BYTE abFiller[3]; + // WORD or DWORD awRandomAccessWordsClasses[dwNumRandomAccess]; + // BYTE abProbToken[dwNumSequential+dwNumRandomAccess]; + } NGRAMCGHDR, *PNGRAMCGHDR; + + +/************************************************************************ +Class IDs */ + + +// {E02D16C0-C743-11cd-80E5-00AA003E4B50} +DEFINE_GUID(CLSID_SREnumerator, +0xe02d16c0, 0xc743, 0x11cd, 0x80, 0xe5, 0x0, 0xaa, 0x0, 0x3e, 0x4b, 0x50); + + +/************************************************************************ +interfaces */ + + +/* + * ISRAttributes + */ + +#undef INTERFACE +#define INTERFACE ISRAttributesW + +DEFINE_GUID(IID_ISRAttributesW, 0x68A33AA0L, 0x44CD, 0x101B, 0x90, 0xA8, 0x00, 0xAA, 0x00, 0x3E, 0x4B, 0x50); + +DECLARE_INTERFACE_ (ISRAttributesW, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRAttributesW members + STDMETHOD (AutoGainEnableGet) (THIS_ DWORD *) PURE; + STDMETHOD (AutoGainEnableSet) (THIS_ DWORD) PURE; + STDMETHOD (EchoGet) (THIS_ BOOL *) PURE; + STDMETHOD (EchoSet) (THIS_ BOOL) PURE; + STDMETHOD (EnergyFloorGet) (THIS_ WORD *) PURE; + STDMETHOD (EnergyFloorSet) (THIS_ WORD) PURE; + STDMETHOD (MicrophoneGet) (THIS_ PWSTR, DWORD, DWORD *) PURE; + STDMETHOD (MicrophoneSet) (THIS_ PCWSTR) PURE; + STDMETHOD (RealTimeGet) (THIS_ DWORD *) PURE; + STDMETHOD (RealTimeSet) (THIS_ DWORD) PURE; + STDMETHOD (SpeakerGet) (THIS_ PWSTR, DWORD, DWORD *) PURE; + STDMETHOD (SpeakerSet) (THIS_ PCWSTR) PURE; + STDMETHOD (TimeOutGet) (THIS_ DWORD *, DWORD *) PURE; + STDMETHOD (TimeOutSet) (THIS_ DWORD, DWORD) PURE; + STDMETHOD (ThresholdGet) (THIS_ DWORD *) PURE; + STDMETHOD (ThresholdSet) (THIS_ DWORD) PURE; + }; + +typedef ISRAttributesW FAR * PISRATTRIBUTESW; + + +#undef INTERFACE +#define INTERFACE ISRAttributesA + +DEFINE_GUID(IID_ISRAttributesA, 0x2F26B9C1L, 0xDB31, 0x11CD, 0xB3, 0xCA, 0x00, 0xAA, 0x00, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ISRAttributesA, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRAttributesA members + STDMETHOD (AutoGainEnableGet) (THIS_ DWORD *) PURE; + STDMETHOD (AutoGainEnableSet) (THIS_ DWORD) PURE; + STDMETHOD (EchoGet) (THIS_ BOOL *) PURE; + STDMETHOD (EchoSet) (THIS_ BOOL) PURE; + STDMETHOD (EnergyFloorGet) (THIS_ WORD *) PURE; + STDMETHOD (EnergyFloorSet) (THIS_ WORD) PURE; + STDMETHOD (MicrophoneGet) (THIS_ PSTR, DWORD, DWORD *) PURE; + STDMETHOD (MicrophoneSet) (THIS_ PCSTR) PURE; + STDMETHOD (RealTimeGet) (THIS_ DWORD *) PURE; + STDMETHOD (RealTimeSet) (THIS_ DWORD) PURE; + STDMETHOD (SpeakerGet) (THIS_ PSTR, DWORD, DWORD *) PURE; + STDMETHOD (SpeakerSet) (THIS_ PCSTR) PURE; + STDMETHOD (TimeOutGet) (THIS_ DWORD *, DWORD *) PURE; + STDMETHOD (TimeOutSet) (THIS_ DWORD, DWORD) PURE; + STDMETHOD (ThresholdGet) (THIS_ DWORD *) PURE; + STDMETHOD (ThresholdSet) (THIS_ DWORD) PURE; + }; + +typedef ISRAttributesA FAR * PISRATTRIBUTESA; + + +#ifdef _S_UNICODE + #define ISRAttributes ISRAttributesW + #define IID_ISRAttributes IID_ISRAttributesW + #define PISRATTRIBUTES PISRATTRIBUTESW + +#else + #define ISRAttributes ISRAttributesA + #define IID_ISRAttributes IID_ISRAttributesA + #define PISRATTRIBUTES PISRATTRIBUTESA + +#endif // _S_UNICODE + +/* + * ISRCentral + */ + +#undef INTERFACE +#define INTERFACE ISRCentralW + +DEFINE_GUID(IID_ISRCentralW, 0xB9BD3860L, 0x44DB, 0x101B, 0x90, 0xA8, 0x00, 0xAA, 0x00, 0x3E, 0x4B, 0x50); + +DECLARE_INTERFACE_ (ISRCentralW, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRCentralW members + STDMETHOD (ModeGet) (THIS_ PSRMODEINFOW) PURE; + STDMETHOD (GrammarLoad) (THIS_ SRGRMFMT, SDATA, PVOID, IID, LPUNKNOWN *) PURE; + STDMETHOD (Pause) (THIS) PURE; + STDMETHOD (PosnGet) (THIS_ PQWORD) PURE; + STDMETHOD (Resume) (THIS) PURE; + STDMETHOD (ToFileTime) (THIS_ PQWORD, FILETIME *) PURE; + STDMETHOD (Register) (THIS_ PVOID, IID, DWORD*) PURE; + STDMETHOD (UnRegister) (THIS_ DWORD) PURE; + }; + +typedef ISRCentralW FAR * PISRCENTRALW; + + +#undef INTERFACE +#define INTERFACE ISRCentralA + +DEFINE_GUID(IID_ISRCentralA, 0x2F26B9C2L, 0xDB31, 0x11CD, 0xB3, 0xCA, 0x00, 0xAA, 0x00, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ISRCentralA, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRCentralA members + STDMETHOD (ModeGet) (THIS_ PSRMODEINFOA) PURE; + STDMETHOD (GrammarLoad) (THIS_ SRGRMFMT, SDATA, PVOID, IID, LPUNKNOWN *) PURE; + STDMETHOD (Pause) (THIS) PURE; + STDMETHOD (PosnGet) (THIS_ PQWORD) PURE; + STDMETHOD (Resume) (THIS) PURE; + STDMETHOD (ToFileTime) (THIS_ PQWORD, FILETIME *) PURE; + STDMETHOD (Register) (THIS_ PVOID, IID, DWORD*) PURE; + STDMETHOD (UnRegister) (THIS_ DWORD) PURE; + }; + +typedef ISRCentralA FAR * PISRCENTRALA; + + +#ifdef _S_UNICODE + #define ISRCentral ISRCentralW + #define IID_ISRCentral IID_ISRCentralW + #define PISRCENTRAL PISRCENTRALW + +#else + #define ISRCentral ISRCentralA + #define IID_ISRCentral IID_ISRCentralA + #define PISRCENTRAL PISRCENTRALA + +#endif // _S_UNICODE + + + +/* + * ISRDialogs + */ + +#undef INTERFACE +#define INTERFACE ISRDialogsW + +DEFINE_GUID(IID_ISRDialogsW, 0xBCFB4C60L, 0x44DB, 0x101B, 0x90, 0xA8, 0x00, 0xAA, 0x00, 0x3E, 0x4B, 0x50); + +DECLARE_INTERFACE_ (ISRDialogsW, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRDialogsW members + STDMETHOD (AboutDlg) (THIS_ HWND, PCWSTR) PURE; + STDMETHOD (GeneralDlg) (THIS_ HWND, PCWSTR) PURE; + STDMETHOD (LexiconDlg) (THIS_ HWND, PCWSTR) PURE; + STDMETHOD (TrainMicDlg) (THIS_ HWND, PCWSTR) PURE; + STDMETHOD (TrainGeneralDlg)(THIS_ HWND, PCWSTR) PURE; + }; + +typedef ISRDialogsW FAR * PISRDIALOGSW; + + +#undef INTERFACE +#define INTERFACE ISRDialogsA + +DEFINE_GUID(IID_ISRDialogsA, 0x05EB6C60L, 0xDBAB, 0x11CD, 0xB3, 0xCA, 0x00, 0xAA, 0x00, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ISRDialogsA, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRDialogsA members + STDMETHOD (AboutDlg) (THIS_ HWND, PCSTR) PURE; + STDMETHOD (GeneralDlg) (THIS_ HWND, PCSTR) PURE; + STDMETHOD (LexiconDlg) (THIS_ HWND, PCSTR) PURE; + STDMETHOD (TrainMicDlg) (THIS_ HWND, PCSTR) PURE; + STDMETHOD (TrainGeneralDlg)(THIS_ HWND, PCSTR) PURE; + }; + +typedef ISRDialogsA FAR * PISRDIALOGSA; + + +#ifdef _S_UNICODE + #define ISRDialogs ISRDialogsW + #define IID_ISRDialogs IID_ISRDialogsW + #define PISRDIALOGS PISRDIALOGSW + +#else + #define ISRDialogs ISRDialogsA + #define IID_ISRDialogs IID_ISRDialogsA + #define PISRDIALOGS PISRDIALOGSA + +#endif + + +/* + * ISRDialogs2 + */ + +#undef INTERFACE +#define INTERFACE ISRDialogs2W + +// {9B445330-E39F-11d1-BED7-006008317CE8} +DEFINE_GUID(IID_ISRDialogs2W, +0x9b445330, 0xe39f, 0x11d1, 0xbe, 0xd7, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +DECLARE_INTERFACE_ (ISRDialogs2W, ISRDialogsW) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRDialogs2W members + STDMETHOD (AboutDlg) (THIS_ HWND, PCWSTR) PURE; + STDMETHOD (GeneralDlg) (THIS_ HWND, PCWSTR) PURE; + STDMETHOD (LexiconDlg) (THIS_ HWND, PCWSTR) PURE; + STDMETHOD (TrainMicDlg) (THIS_ HWND, PCWSTR) PURE; + STDMETHOD (TrainGeneralDlg)(THIS_ HWND, PCWSTR) PURE; + + STDMETHOD (TrainPhrasesDlg)(THIS_ HWND, PCWSTR, PCWSTR) PURE; + }; + +typedef ISRDialogs2W FAR * PISRDIALOGS2W; + + +#undef INTERFACE +#define INTERFACE ISRDialogs2A + +// {9B445331-E39F-11d1-BED7-006008317CE8} +DEFINE_GUID(IID_ISRDialogs2A, +0x9b445331, 0xe39f, 0x11d1, 0xbe, 0xd7, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +DECLARE_INTERFACE_ (ISRDialogs2A, ISRDialogsA) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRDialogs2A members + STDMETHOD (AboutDlg) (THIS_ HWND, PCSTR) PURE; + STDMETHOD (GeneralDlg) (THIS_ HWND, PCSTR) PURE; + STDMETHOD (LexiconDlg) (THIS_ HWND, PCSTR) PURE; + STDMETHOD (TrainMicDlg) (THIS_ HWND, PCSTR) PURE; + STDMETHOD (TrainGeneralDlg)(THIS_ HWND, PCSTR) PURE; + + STDMETHOD (TrainPhrasesDlg)(THIS_ HWND, PCSTR, PCSTR) PURE; + }; + +typedef ISRDialogs2A FAR * PISRDIALOGS2A; + + +#ifdef _S_UNICODE + #define ISRDialogs2 ISRDialogs2W + #define IID_ISRDialogs2 IID_ISRDialogs2W + #define PISRDIALOGS2 PISRDIALOGS2W + +#else + #define ISRDialogs2 ISRDialogs2A + #define IID_ISRDialogs2 IID_ISRDialogs2A + #define PISRDIALOGS2 PISRDIALOGS2A + +#endif + + +/* + * ISREnum + */ + +#undef INTERFACE +#define INTERFACE ISREnumW + +DEFINE_GUID(IID_ISREnumW, 0xBFA9F1A0L, 0x44DB, 0x101B, 0x90, 0xA8, 0x00, 0xAA, 0x00, 0x3E, 0x4B, 0x50); + +DECLARE_INTERFACE_ (ISREnumW, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISREnumW members + STDMETHOD (Next) (THIS_ ULONG, PSRMODEINFOW, ULONG *) PURE; + STDMETHOD (Skip) (THIS_ ULONG) PURE; + STDMETHOD (Reset) (THIS) PURE; + STDMETHOD (Clone) (THIS_ ISREnumW * FAR *) PURE; + STDMETHOD (Select) (THIS_ GUID, PISRCENTRALW *, LPUNKNOWN) PURE; + }; + +typedef ISREnumW FAR * PISRENUMW; + + +#undef INTERFACE +#define INTERFACE ISREnumA + +DEFINE_GUID(IID_ISREnumA, 0x05EB6C61L, 0xDBAB, 0x11CD, 0xB3, 0xCA, 0x00, 0xAA, 0x00, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ISREnumA, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISREnumA members + STDMETHOD (Next) (THIS_ ULONG, PSRMODEINFOA, ULONG *) PURE; + STDMETHOD (Skip) (THIS_ ULONG) PURE; + STDMETHOD (Reset) (THIS) PURE; + STDMETHOD (Clone) (THIS_ ISREnumA * FAR *) PURE; + STDMETHOD (Select) (THIS_ GUID, PISRCENTRALA *, LPUNKNOWN) PURE; + }; + +typedef ISREnumA FAR * PISRENUMA; + + +#ifdef _S_UNICODE + #define ISREnum ISREnumW + #define IID_ISREnum IID_ISREnumW + #define PISRENUM PISRENUMW + +#else + #define ISREnum ISREnumA + #define IID_ISREnum IID_ISREnumA + #define PISRENUM PISRENUMA + +#endif + + + +/* + * ISRFind + */ + +#undef INTERFACE +#define INTERFACE ISRFindW + +DEFINE_GUID(IID_ISRFindW, 0xC2835060L, 0x44DB, 0x101B, 0x90, 0xA8, 0x00, 0xAA, 0x00, 0x3E, 0x4B, 0x50); + +DECLARE_INTERFACE_ (ISRFindW, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRFindW members + STDMETHOD (Find) (THIS_ PSRMODEINFOW, PSRMODEINFORANK, PSRMODEINFOW) PURE; + STDMETHOD (Select) (THIS_ GUID, PISRCENTRALW *, LPUNKNOWN) PURE; + }; + +typedef ISRFindW FAR * PISRFINDW; + + +#undef INTERFACE +#define INTERFACE ISRFindA + +DEFINE_GUID(IID_ISRFindA, 0x05EB6C62L, 0xDBAB, 0x11CD, 0xB3, 0xCA, 0x00, 0xAA, 0x00, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ISRFindA, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRFindA members + STDMETHOD (Find) (THIS_ PSRMODEINFOA, PSRMODEINFORANK, PSRMODEINFOA) PURE; + STDMETHOD (Select) (THIS_ GUID, PISRCENTRALA *, LPUNKNOWN) PURE; + }; + +typedef ISRFindA FAR * PISRFINDA; + + +#ifdef _S_UNICODE + #define ISRFind ISRFindW + #define IID_ISRFind IID_ISRFindW + #define PISRFIND PISRFINDW + +#else + #define ISRFind ISRFindA + #define IID_ISRFind IID_ISRFindA + #define PISRFIND PISRFINDA + +#endif + + +/* + * ISRGramLexPron + */ + +#undef INTERFACE +#define INTERFACE ISRGramLexPronW + +// {7EB4B631-19A7-11d1-AF95-0000F81E880D} +DEFINE_GUID(IID_ISRGramLexPronW, 0x7eb4b631, 0x19a7, 0x11d1, 0xaf, 0x95, 0x0, 0x0, 0xf8, 0x1e, 0x88, 0xd); + +DECLARE_INTERFACE_ (ISRGramLexPronW, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRGramLexPronW members + STDMETHOD (Add) (THIS_ VOICECHARSET, PCWSTR, PCWSTR, + VOICEPARTOFSPEECH, PVOID, DWORD, BOOL) PURE; + STDMETHOD (Get) (THIS_ VOICECHARSET, PCWSTR, WORD, PWSTR, + DWORD, DWORD *, VOICEPARTOFSPEECH *, PVOID, + DWORD, DWORD *) PURE; + STDMETHOD (Remove) (THIS_ PCWSTR, WORD) PURE; + STDMETHOD (LexiconDlg) (THIS_ HWND, PCWSTR, PCWSTR) PURE; + }; + +typedef ISRGramLexPronW FAR * PISRGRAMLEXPRONW; + + +#undef INTERFACE +#define INTERFACE ISRGramLexPronA + +// {7EB4B632-19A7-11d1-AF95-0000F81E880D} +DEFINE_GUID(IID_ISRGramLexPronA, 0x7eb4b632, 0x19a7, 0x11d1, 0xaf, 0x95, 0x0, 0x0, 0xf8, 0x1e, 0x88, 0xd); + +DECLARE_INTERFACE_ (ISRGramLexPronA, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // LexPronA members + STDMETHOD (Add) (THIS_ VOICECHARSET, PCSTR, PCSTR, + VOICEPARTOFSPEECH, PVOID, DWORD, BOOL) PURE; + STDMETHOD (Get) (THIS_ VOICECHARSET, PCSTR, WORD, PSTR, + DWORD, DWORD *, VOICEPARTOFSPEECH *, PVOID, + DWORD, DWORD *) PURE; + STDMETHOD (Remove) (THIS_ PCSTR, WORD) PURE; + STDMETHOD (LexiconDlg) (THIS_ HWND, PCSTR, PCSTR) PURE; + }; + +typedef ISRGramLexPronA FAR * PISRGRAMLEXPRONA; + + +#ifdef _S_UNICODE + #define ISRGramLexPron ISRGramLexPronW + #define IID_ISRGramLexPron IID_ISRGramLexPronW + #define PISRGRAMLEXPRON PISRGRAMLEXPRONW + +#else + #define ISRGramLexPron ISRGramLexPronA + #define IID_ISRGramLexPron IID_ISRGramLexPronA + #define PISRGRAMLEXPRON PISRGRAMLEXPRONA + +#endif // _S_UNICODE + + +/* + * ISRGramCommon + */ + +#undef INTERFACE +#define INTERFACE ISRGramCommonW + +DEFINE_GUID(IID_ISRGramCommonW, 0xe8c3e160, 0xc743, 0x11cd, 0x80, 0xe5, 0x0, 0xaa, 0x0, 0x3e, 0x4b, 0x50); + +DECLARE_INTERFACE_ (ISRGramCommonW, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRGramCommonW members + STDMETHOD (Activate) (THIS_ HWND, BOOL, PCWSTR) PURE; + STDMETHOD (Archive) (THIS_ BOOL, PVOID, DWORD, DWORD *) PURE; + STDMETHOD (BookMark) (THIS_ QWORD, DWORD) PURE; + STDMETHOD (Deactivate) (THIS_ PCWSTR) PURE; + STDMETHOD (DeteriorationGet) (THIS_ DWORD *, DWORD *, DWORD *) PURE; + STDMETHOD (DeteriorationSet) (THIS_ DWORD, DWORD, DWORD) PURE; + STDMETHOD (TrainDlg) (THIS_ HWND, PCWSTR) PURE; + STDMETHOD (TrainPhrase) (THIS_ DWORD, PSDATA) PURE; + STDMETHOD (TrainQuery) (THIS_ DWORD *) PURE; + }; + +typedef ISRGramCommonW FAR * PISRGRAMCOMMONW; + + +#undef INTERFACE +#define INTERFACE ISRGramCommonA + +DEFINE_GUID(IID_ISRGramCommonA, 0x05EB6C63L, 0xDBAB, 0x11CD, 0xB3, 0xCA, 0x00, 0xAA, 0x00, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ISRGramCommonA, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRGramCommonA members + STDMETHOD (Activate) (THIS_ HWND, BOOL, PCSTR) PURE; + STDMETHOD (Archive) (THIS_ BOOL, PVOID, DWORD, DWORD *) PURE; + STDMETHOD (BookMark) (THIS_ QWORD, DWORD) PURE; + STDMETHOD (Deactivate) (THIS_ PCSTR) PURE; + STDMETHOD (DeteriorationGet) (THIS_ DWORD *, DWORD *, DWORD *) PURE; + STDMETHOD (DeteriorationSet) (THIS_ DWORD, DWORD, DWORD) PURE; + STDMETHOD (TrainDlg) (THIS_ HWND, PCSTR) PURE; + STDMETHOD (TrainPhrase) (THIS_ DWORD, PSDATA) PURE; + STDMETHOD (TrainQuery) (THIS_ DWORD *) PURE; + }; + +typedef ISRGramCommonA FAR * PISRGRAMCOMMONA; + + +#ifdef _S_UNICODE + #define ISRGramCommon ISRGramCommonW + #define IID_ISRGramCommon IID_ISRGramCommonW + #define PISRGRAMCOMMON PISRGRAMCOMMONW + +#else + #define ISRGramCommon ISRGramCommonA + #define IID_ISRGramCommon IID_ISRGramCommonA + #define PISRGRAMCOMMON PISRGRAMCOMMONA + +#endif + + + +/* + * ISRGramCFG + */ + +#undef INTERFACE +#define INTERFACE ISRGramCFGW + +DEFINE_GUID(IID_ISRGramCFGW, 0xecc0b180, 0xc743, 0x11cd, 0x80, 0xe5, 0x0, 0xaa, 0x0, 0x3e, 0x4b, 0x50); + +DECLARE_INTERFACE_ (ISRGramCFGW, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRGramCFGW members + STDMETHOD (LinkQuery) (THIS_ PCWSTR, BOOL *) PURE; + STDMETHOD (ListAppend) (THIS_ PCWSTR, SDATA) PURE; + STDMETHOD (ListGet) (THIS_ PCWSTR, PSDATA) PURE; + STDMETHOD (ListRemove) (THIS_ PCWSTR, SDATA) PURE; + STDMETHOD (ListSet) (THIS_ PCWSTR, SDATA) PURE; + STDMETHOD (ListQuery) (THIS_ PCWSTR, BOOL *) PURE; + }; + +typedef ISRGramCFGW FAR * PISRGRAMCFGW; + + +#undef INTERFACE +#define INTERFACE ISRGramCFGA + +DEFINE_GUID(IID_ISRGramCFGA, 0x05EB6C64L, 0xDBAB, 0x11CD, 0xB3, 0xCA, 0x00, 0xAA, 0x00, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ISRGramCFGA, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRGramCFGA members + STDMETHOD (LinkQuery) (THIS_ PCSTR, BOOL *) PURE; + STDMETHOD (ListAppend) (THIS_ PCSTR, SDATA) PURE; + STDMETHOD (ListGet) (THIS_ PCSTR, PSDATA) PURE; + STDMETHOD (ListRemove) (THIS_ PCSTR, SDATA) PURE; + STDMETHOD (ListSet) (THIS_ PCSTR, SDATA) PURE; + STDMETHOD (ListQuery) (THIS_ PCSTR, BOOL *) PURE; + }; + +typedef ISRGramCFGA FAR * PISRGRAMCFGA; + + +#ifdef _S_UNICODE + #define ISRGramCFG ISRGramCFGW + #define IID_ISRGramCFG IID_ISRGramCFGW + #define PISRGRAMCFG PISRGRAMCFGW + +#else + #define ISRGramCFG ISRGramCFGA + #define IID_ISRGramCFG IID_ISRGramCFGA + #define PISRGRAMCFG PISRGRAMCFGA + +#endif + + + +/* + * ISRGramDictation + */ + +#undef INTERFACE +#define INTERFACE ISRGramDictationW + +DEFINE_GUID(IID_ISRGramDictationW, 0x090CD9A3, 0xDA1A, 0x11CD, 0xB3, 0xCA, 0x0, 0xAA, 0x0, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ISRGramDictationW, IUnknown) { + + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRGramDictationW members + STDMETHOD (Context) (THIS_ PCWSTR, PCWSTR) PURE; + STDMETHOD (Hint) (THIS_ PCWSTR) PURE; + STDMETHOD (Words) (THIS_ PCWSTR) PURE; + }; + +typedef ISRGramDictationW FAR *PISRGRAMDICTATIONW; + + +#undef INTERFACE +#define INTERFACE ISRGramDictationA + +DEFINE_GUID(IID_ISRGramDictationA, 0x05EB6C65L, 0xDBAB, 0x11CD, 0xB3, 0xCA, 0x00, 0xAA, 0x00, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ISRGramDictationA, IUnknown) { + + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRGramDictationA members + STDMETHOD (Context) (THIS_ PCSTR, PCSTR) PURE; + STDMETHOD (Hint) (THIS_ PCSTR) PURE; + STDMETHOD (Words) (THIS_ PCSTR) PURE; + }; + +typedef ISRGramDictationA FAR *PISRGRAMDICTATIONA; + + +#ifdef _S_UNICODE + #define ISRGramDictation ISRGramDictationW + #define IID_ISRGramDictation IID_ISRGramDictationW + #define PISRGRAMDICTATION PISRGRAMDICTATIONW + +#else + #define ISRGramDictation ISRGramDictationA + #define IID_ISRGramDictation IID_ISRGramDictationA + #define PISRGRAMDICTATION PISRGRAMDICTATIONA + +#endif + + + +// ISRGramInsertionGUI +// This does not need an ANSI/UNICODE interface because no characters are passed +#undef INTERFACE +#define INTERFACE ISRGramInsertionGUI + +// {090CD9A4-DA1A-11CD-B3CA-00AA0047BA4F} +DEFINE_GUID(IID_ISRGramInsertionGUI, +0x090CD9A4, 0xDA1A, 0x11CD, 0xB3, 0xCA, 0x0, 0xAA, 0x0, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ISRGramInsertionGUI, IUnknown) { + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRGramInsertionGUI members + STDMETHOD (Hide) (THIS) PURE; + STDMETHOD (Move) (THIS_ RECT) PURE; + STDMETHOD (Show) (THIS_ HWND) PURE; + }; + +typedef ISRGramInsertionGUI FAR *PISRGRAMINSERTIONGUI; + + + +/* + * ISRGramNotifySink + */ + +#undef INTERFACE +#define INTERFACE ISRGramNotifySinkW + +DEFINE_GUID(IID_ISRGramNotifySinkW, 0xf106bfa0, 0xc743, 0x11cd, 0x80, 0xe5, 0x0, 0xaa, 0x0, 0x3e, 0x4b, 0x50); + +DECLARE_INTERFACE_ (ISRGramNotifySinkW, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRGramNotifySinkW members + STDMETHOD (BookMark) (THIS_ DWORD) PURE; + STDMETHOD (Paused) (THIS) PURE; + STDMETHOD (PhraseFinish) (THIS_ DWORD, QWORD, QWORD, PSRPHRASEW, LPUNKNOWN) PURE; + STDMETHOD (PhraseHypothesis)(THIS_ DWORD, QWORD, QWORD, PSRPHRASEW, LPUNKNOWN) PURE; + STDMETHOD (PhraseStart) (THIS_ QWORD) PURE; + STDMETHOD (ReEvaluate) (THIS_ LPUNKNOWN) PURE; + STDMETHOD (Training) (THIS_ DWORD) PURE; + STDMETHOD (UnArchive) (THIS_ LPUNKNOWN) PURE; + }; + +typedef ISRGramNotifySinkW FAR * PISRGRAMNOTIFYSINKW; + + +// ISRGramNotifySinkA +#undef INTERFACE +#define INTERFACE ISRGramNotifySinkA + +// {EFEEA350-CE5E-11cd-9D96-00AA002FC7C9} +DEFINE_GUID(IID_ISRGramNotifySinkA, +0xefeea350, 0xce5e, 0x11cd, 0x9d, 0x96, 0x0, 0xaa, 0x0, 0x2f, 0xc7, 0xc9); + +DECLARE_INTERFACE_ (ISRGramNotifySinkA, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRGramNotifySinkA members + STDMETHOD (BookMark) (THIS_ DWORD) PURE; + STDMETHOD (Paused) (THIS) PURE; + STDMETHOD (PhraseFinish) (THIS_ DWORD, QWORD, QWORD, PSRPHRASEA, LPUNKNOWN) PURE; + STDMETHOD (PhraseHypothesis)(THIS_ DWORD, QWORD, QWORD, PSRPHRASEA, LPUNKNOWN) PURE; + STDMETHOD (PhraseStart) (THIS_ QWORD) PURE; + STDMETHOD (ReEvaluate) (THIS_ LPUNKNOWN) PURE; + STDMETHOD (Training) (THIS_ DWORD) PURE; + STDMETHOD (UnArchive) (THIS_ LPUNKNOWN) PURE; + }; + +typedef ISRGramNotifySinkA FAR * PISRGRAMNOTIFYSINKA; + + +#ifdef _S_UNICODE + #define ISRGramNotifySink ISRGramNotifySinkW + #define IID_ISRGramNotifySink IID_ISRGramNotifySinkW + #define PISRGRAMNOTIFYSINK PISRGRAMNOTIFYSINKW + +#else + #define ISRGramNotifySink ISRGramNotifySinkA + #define IID_ISRGramNotifySink IID_ISRGramNotifySinkA + #define PISRGRAMNOTIFYSINK PISRGRAMNOTIFYSINKA + +#endif // _S_UNICODE + + + +// ISRNotifySink +// This does not need an ANSI/UNICODE interface because no characters are passed +#undef INTERFACE +#define INTERFACE ISRNotifySink + +DEFINE_GUID(IID_ISRNotifySink, +0x090CD9B0L, 0xDA1A, 0x11CD, 0xB3, 0xCA, 0x00, 0xAA, 0x00, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ISRNotifySink, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRNotifySink members + STDMETHOD (AttribChanged) (THIS_ DWORD) PURE; + STDMETHOD (Interference) (THIS_ QWORD, QWORD, DWORD) PURE; + STDMETHOD (Sound) (THIS_ QWORD, QWORD) PURE; + STDMETHOD (UtteranceBegin) (THIS_ QWORD) PURE; + STDMETHOD (UtteranceEnd) (THIS_ QWORD, QWORD) PURE; + STDMETHOD (VUMeter) (THIS_ QWORD, WORD) PURE; + }; + +typedef ISRNotifySink FAR *PISRNOTIFYSINK; + +// Just in case anyone uses the wide/ansi versions +#define ISRNotifySinkW ISRNotifySink +#define IID_ISRNotifySinkW IID_ISRNotifySink +#define PISRNOTIFYSINKW PISRNOTIFYSINK +#define ISRNotifySinkA ISRNotifySink +#define IID_ISRNotifySinkA IID_ISRNotifySink +#define PISRNOTIFYSINKA PISRNOTIFYSINK + + +// ISRNotifySink2 +// This does not need an ANSI/UNICODE interface because no characters are passed +#undef INTERFACE +#define INTERFACE ISRNotifySink2 + +// {9B445332-E39F-11d1-BED7-006008317CE8} +DEFINE_GUID(IID_ISRNotifySink2, +0x9b445332, 0xe39f, 0x11d1, 0xbe, 0xd7, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +DECLARE_INTERFACE_ (ISRNotifySink2, ISRNotifySink) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRNotifySink2 members + STDMETHOD (AttribChanged) (THIS_ DWORD) PURE; + STDMETHOD (Interference) (THIS_ QWORD, QWORD, DWORD) PURE; + STDMETHOD (Sound) (THIS_ QWORD, QWORD) PURE; + STDMETHOD (UtteranceBegin) (THIS_ QWORD) PURE; + STDMETHOD (UtteranceEnd) (THIS_ QWORD, QWORD) PURE; + STDMETHOD (VUMeter) (THIS_ QWORD, WORD) PURE; + + STDMETHOD (Training) (THIS) PURE; + STDMETHOD (Error) (THIS_ LPUNKNOWN) PURE; + STDMETHOD (Warning) (THIS_ LPUNKNOWN) PURE; + }; + +typedef ISRNotifySink2 FAR *PISRNOTIFYSINK2; + + +/* + * ISRResBasic + */ + +#undef INTERFACE +#define INTERFACE ISRResBasicW + +DEFINE_GUID(IID_ISRResBasicW, 0x090CD9A5, 0xDA1A, 0x11CD, 0xB3, 0xCA, 0x0, 0xAA, 0x0, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ISRResBasicW, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRResBasicW members + STDMETHOD (PhraseGet) (THIS_ DWORD, PSRPHRASEW, DWORD, DWORD *) PURE; + STDMETHOD (Identify) (THIS_ GUID *) PURE; + STDMETHOD (TimeGet) (THIS_ PQWORD, PQWORD) PURE; + STDMETHOD (FlagsGet) (THIS_ DWORD, DWORD *) PURE; + }; + +typedef ISRResBasicW FAR *PISRRESBASICW; + + +#undef INTERFACE +#define INTERFACE ISRResBasicA + +DEFINE_GUID(IID_ISRResBasicA, 0x05EB6C66L, 0xDBAB, 0x11CD, 0xB3, 0xCA, 0x00, 0xAA, 0x00, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ISRResBasicA, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRResBasicA members + STDMETHOD (PhraseGet) (THIS_ DWORD, PSRPHRASEA, DWORD, DWORD *) PURE; + STDMETHOD (Identify) (THIS_ GUID *) PURE; + STDMETHOD (TimeGet) (THIS_ PQWORD, PQWORD) PURE; + STDMETHOD (FlagsGet) (THIS_ DWORD, DWORD *) PURE; + }; + +typedef ISRResBasicA FAR *PISRRESBASICA; + + +#ifdef _S_UNICODE + #define ISRResBasic ISRResBasicW + #define IID_ISRResBasic IID_ISRResBasicW + #define PISRRESBASIC PISRRESBASICW + +#else + #define ISRResBasic ISRResBasicA + #define IID_ISRResBasic IID_ISRResBasicA + #define PISRRESBASIC PISRRESBASICA + +#endif // _S_UNICODE + + +/* + * ISRResScore + * This does not need an ANSI/UNICODE interface because no characters are passed + */ + +#undef INTERFACE +#define INTERFACE ISRResScores + + +// {0B37F1E0-B8DE-11cf-B22E-00AA00A215ED} +DEFINE_GUID(IID_ISRResScores, 0xb37f1e0, 0xb8de, 0x11cf, 0xb2, 0x2e, 0x0, 0xaa, 0x0, 0xa2, 0x15, 0xed); + +DECLARE_INTERFACE_ (ISRResScores, IUnknown) { + + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRResScores members + STDMETHOD (GetPhraseScore) (THIS_ DWORD, long FAR *) PURE; + STDMETHOD (GetWordScores) (THIS_ DWORD, long FAR *, DWORD, LPDWORD) PURE; +}; + +typedef ISRResScores FAR* PISRRESSCORES; + +// In case someone uses the A/W versions... + +#define ISRResScoresW ISRResScores +#define IID_ISRResScoresW IID_ISRResScores +#define PISRRESSCORESW PISRRESSCORES +#define ISRResScoresA ISRResScores +#define IID_ISRResScoresA IID_ISRResScores +#define PISRRESSCORESA PISRRESSCORES + + + +/* + * ISRResMerge + * This does not need an ANSI/UNICODE interface because no characters are passed + */ + +#undef INTERFACE +#define INTERFACE ISRResMerge + +DEFINE_GUID(IID_ISRResMerge, 0x090CD9A6, 0xDA1A, 0x11CD, 0xB3, 0xCA, 0x0, 0xAA, 0x0, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ISRResMerge, IUnknown) { + + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRResMerge members + STDMETHOD (Merge) (THIS_ LPUNKNOWN, PIUNKNOWN ) PURE; + STDMETHOD (Split) (THIS_ QWORD, PIUNKNOWN , PIUNKNOWN ) PURE; + }; + +typedef ISRResMerge FAR *PISRRESMERGE; + + + +/* + * ISRResAudio + * This does not need an ANSI/UNICODE interface because no characters are passed + */ + +#undef INTERFACE +#define INTERFACE ISRResAudio + +DEFINE_GUID(IID_ISRResAudio, 0x090CD9A7, 0xDA1A, 0x11CD, 0xB3, 0xCA, 0x0, 0xAA, 0x0, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ISRResAudio, IUnknown) { + + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRResAudio members + STDMETHOD (GetWAV) (THIS_ PSDATA) PURE; + }; + +typedef ISRResAudio FAR *PISRRESAUDIO; + + + +/* + * ISRResAudioEx + * This does not need an ANSI/UNICODE interface because no characters are passed + */ + +#undef INTERFACE +#define INTERFACE ISRResAudioEx + +DEFINE_GUID(IID_ISRResAudioEx, 0xaad74c30, 0x4b02, 0x11d1, 0xb7, 0x92, 0x0, 0x60, 0x97, 0x98, 0x41, 0xb4); + +DECLARE_INTERFACE_ (ISRResAudioEx, IUnknown) { + + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRResAudioEx members + STDMETHOD (GetWAV) (THIS_ PSDATA, QWORD, QWORD) PURE; + }; + +typedef ISRResAudioEx FAR *PISRRESAUDIOEX; + + + +/* + * ISRResCorrection + */ + +#undef INTERFACE +#define INTERFACE ISRResCorrectionW + +DEFINE_GUID(IID_ISRResCorrectionW, 0x090CD9A8L, 0xDA1A, 0x11CD, 0xB3, 0xCA, 0x00, 0xAA, 0x00, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ISRResCorrectionW, IUnknown) { + + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRResCorrectionW members + STDMETHOD (Correction) (THIS_ PSRPHRASEW, WORD) PURE; + STDMETHOD (Validate) (THIS_ WORD) PURE; + }; + +typedef ISRResCorrectionW FAR *PISRRESCORRECTIONW; + + +#undef INTERFACE +#define INTERFACE ISRResCorrectionA + +DEFINE_GUID(IID_ISRResCorrectionA, 0x05EB6C67L, 0xDBAB, 0x11CD, 0xB3, 0xCA, 0x00, 0xAA, 0x00, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ISRResCorrectionA, IUnknown) { + + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRResCorrectionA members + STDMETHOD (Correction) (THIS_ PSRPHRASEA, WORD) PURE; + STDMETHOD (Validate) (THIS_ WORD) PURE; + }; + +typedef ISRResCorrectionA FAR *PISRRESCORRECTIONA; + + +#ifdef _S_UNICODE + #define ISRResCorrection ISRResCorrectionW + #define IID_ISRResCorrection IID_ISRResCorrectionW + #define PISRRESCORRECTION PISRRESCORRECTIONW + +#else + #define ISRResCorrection ISRResCorrectionA + #define IID_ISRResCorrection IID_ISRResCorrectionA + #define PISRRESCORRECTION PISRRESCORRECTIONA + +#endif // _S_UNICODE + + + +// ISRResEval +// This does not need an ANSI/UNICODE interface because no characters are passed +#undef INTERFACE +#define INTERFACE ISRResEval + +// {90CD9A9-DA1A-11CD-B3CA-00AA0047BA4F} +DEFINE_GUID(IID_ISRResEval, +0x090CD9A9, 0xDA1A, 0x11CD, 0xB3, 0xCA, 0x0, 0xAA, 0x0, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ISRResEval, IUnknown) { + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // SRResEval members + STDMETHOD (ReEvaluate) (THIS_ BOOL *) PURE; + }; + +typedef ISRResEval FAR *PISRRESEVAL; + + + +/* + * ISRResGraph + */ + +#undef INTERFACE +#define INTERFACE ISRResGraphW + +DEFINE_GUID(IID_ISRResGraphW, 0x090CD9AA, 0xDA1A, 0x11CD, 0xB3, 0xCA, 0x0, 0xAA, 0x0, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ISRResGraphW, IUnknown) { + + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRResGraphW members + STDMETHOD (BestPathPhoneme) (THIS_ DWORD, DWORD *, DWORD, DWORD *) PURE; + STDMETHOD (BestPathWord) (THIS_ DWORD, DWORD *, DWORD, DWORD *) PURE; + STDMETHOD (GetPhonemeNode) (THIS_ DWORD, PSRRESPHONEMENODE, PWCHAR, + PWCHAR) PURE; + STDMETHOD (GetWordNode) (THIS_ DWORD, PSRRESWORDNODE, PSRWORDW, DWORD, + DWORD *) PURE; + STDMETHOD (PathScorePhoneme) (THIS_ DWORD *, DWORD, LONG *) PURE; + STDMETHOD (PathScoreWord) (THIS_ DWORD *, DWORD, LONG *) PURE; + }; + +typedef ISRResGraphW FAR *PISRRESGRAPHW; + + +#undef INTERFACE +#define INTERFACE ISRResGraphA + +DEFINE_GUID(IID_ISRResGraphA, 0x05EB6C68L, 0xDBAB, 0x11CD, 0xB3, 0xCA, 0x00, 0xAA, 0x00, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ISRResGraphA, IUnknown) { + + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRResGraphA members + STDMETHOD (BestPathPhoneme) (THIS_ DWORD, DWORD *, DWORD, DWORD *) PURE; + STDMETHOD (BestPathWord) (THIS_ DWORD, DWORD *, DWORD, DWORD *) PURE; + STDMETHOD (GetPhonemeNode) (THIS_ DWORD, PSRRESPHONEMENODE, PWCHAR, + PCHAR) PURE; + STDMETHOD (GetWordNode) (THIS_ DWORD, PSRRESWORDNODE, PSRWORDA, DWORD, + DWORD *) PURE; + STDMETHOD (PathScorePhoneme) (THIS_ DWORD *, DWORD, LONG *) PURE; + STDMETHOD (PathScoreWord) (THIS_ DWORD *, DWORD, LONG *) PURE; + }; + +typedef ISRResGraphA FAR *PISRRESGRAPHA; + + +#ifdef _S_UNICODE + #define ISRResGraph ISRResGraphW + #define IID_ISRResGraph IID_ISRResGraphW + #define PISRRESGRAPH PISRRESGRAPHW + +#else + #define ISRResGraph ISRResGraphA + #define IID_ISRResGraph IID_ISRResGraphA + #define PISRRESGRAPH PISRRESGRAPHA + +#endif // _S_UNICODE + + + +/* + * ISRResGraphEx + */ + +#undef INTERFACE +#define INTERFACE ISRResGraphEx + +DEFINE_GUID(IID_ISRResGraphEx, 0xbe8f63a0, 0xb915, 0x11d1, 0xb7, 0xbc, 0x0, 0x60, 0x97, 0x98, 0x41, 0xb4); + +DECLARE_INTERFACE_ (ISRResGraphEx, IUnknown) { + + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRResGraphEx members + STDMETHOD (NodeStartGet) (THIS_ DWORD *) PURE; + STDMETHOD (NodeEndGet) (THIS_ DWORD *) PURE; + STDMETHOD (ArcEnum) (THIS_ DWORD, DWORD *, DWORD, DWORD *, BOOL) PURE; + STDMETHOD (NodeGet) (THIS_ DWORD, DWORD *, BOOL) PURE; + STDMETHOD (DWORDGet) (THIS_ DWORD, GUID, DWORD *) PURE; + STDMETHOD (DataGet) (THIS_ DWORD, GUID, SDATA *) PURE; + STDMETHOD (ScoreGet) (THIS_ DWORD, DWORD *, DWORD, DWORD, DWORD, DWORD *) PURE; + STDMETHOD (BestPathEnum) (THIS_ DWORD, DWORD *, DWORD, DWORD *, DWORD, BOOL, SDATA *) PURE; + STDMETHOD (GetAllArcs) (THIS_ DWORD *, DWORD, DWORD *, DWORD *) PURE; + STDMETHOD (GetAllNodes) (THIS_ DWORD *, DWORD, DWORD *, DWORD *) PURE; +}; + +typedef ISRResGraphEx FAR *PISRRESGRAPHEX; + + + +// ISRResMemory +// This does not need an ANSI/UNICODE interface because no characters are passed +#undef INTERFACE +#define INTERFACE ISRResMemory + +DEFINE_GUID(IID_ISRResMemory, 0x090CD9AB, 0xDA1A, 0x11CD, 0xB3, 0xCA, 0x0, 0xAA, 0x0, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ISRResMemory, IUnknown) { + + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRResMemory members + STDMETHOD (Free) (THIS_ DWORD) PURE; + STDMETHOD (Get) (THIS_ DWORD *, DWORD *) PURE; + STDMETHOD (LockGet) (THIS_ BOOL *) PURE; + STDMETHOD (LockSet) (THIS_ BOOL) PURE; + }; + +typedef ISRResMemory FAR *PISRRESMEMORY; + + + +// ISRResModifyGUI +// This does not need an ANSI/UNICODE interface because no characters are passed +#undef INTERFACE +#define INTERFACE ISRResModifyGUI + +DEFINE_GUID(IID_ISRResModifyGUI, 0x090CD9AC, 0xDA1A, 0x11CD, 0xB3, 0xCA, 0x0, 0xAA, 0x0, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ISRResModifyGUI, IUnknown) { + + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRResModifyGUI members + STDMETHOD (Hide) (THIS) PURE; + STDMETHOD (Move) (THIS_ RECT *) PURE; + STDMETHOD (Show) (THIS_ HWND) PURE; + }; + +typedef ISRResModifyGUI FAR *PISRRESMODIFYGUI; + + + +/* + * ISRResSpeakerW + */ + +#undef INTERFACE +#define INTERFACE ISRResSpeakerW + +DEFINE_GUID(IID_ISRResSpeakerW, 0x090CD9AD, 0xDA1A, 0x11CD, 0xB3, 0xCA, 0x0, 0xAA, 0x0, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ISRResSpeakerW, IUnknown) { + + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRResSpeakerW members + STDMETHOD (Correction) (THIS_ PCWSTR, WORD) PURE; + STDMETHOD (Validate) (THIS_ WORD) PURE; + STDMETHOD (Identify) (THIS_ DWORD, PWSTR, DWORD, DWORD *, + LONG *) PURE; + STDMETHOD (IdentifyForFree) (THIS_ BOOL *) PURE; + }; + +typedef ISRResSpeakerW FAR *PISRRESSPEAKERW; + + +#undef INTERFACE +#define INTERFACE ISRResSpeakerA + +DEFINE_GUID(IID_ISRResSpeakerA, 0x05EB6C69L, 0xDBAB, 0x11CD, 0xB3, 0xCA, 0x00, 0xAA, 0x00, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ISRResSpeakerA, IUnknown) { + + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRResSpeakerA members + STDMETHOD (Correction) (THIS_ PCSTR, WORD) PURE; + STDMETHOD (Validate) (THIS_ WORD) PURE; + STDMETHOD (Identify) (THIS_ DWORD, PSTR, DWORD, DWORD *, + LONG *) PURE; + STDMETHOD (IdentifyForFree) (THIS_ BOOL *) PURE; + }; + +typedef ISRResSpeakerA FAR *PISRRESSPEAKERA; + + +#ifdef _S_UNICODE + #define ISRResSpeaker ISRResSpeakerW + #define IID_ISRResSpeaker IID_ISRResSpeakerW + #define PISRRESSPEAKER PISRRESSPEAKERW + +#else + #define ISRResSpeaker ISRResSpeakerA + #define IID_ISRResSpeaker IID_ISRResSpeakerA + #define PISRRESSPEAKER PISRRESSPEAKERA + +#endif // _S_UNICODE + + + +/* + * ISRSpeaker + */ + +#undef INTERFACE +#define INTERFACE ISRSpeakerW + +DEFINE_GUID(IID_ISRSpeakerW, 0x090CD9AE, 0xDA1A, 0x11CD, 0xB3, 0xCA, 0x0, 0xAA, 0x0, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ISRSpeakerW, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRSpeakerW members + STDMETHOD (Delete) (THIS_ PCWSTR) PURE; + STDMETHOD (Enum) (THIS_ PWSTR *, DWORD *) PURE; + STDMETHOD (Merge) (THIS_ PCWSTR, PVOID, DWORD) PURE; + STDMETHOD (New) (THIS_ PCWSTR) PURE; + STDMETHOD (Query) (THIS_ PWSTR, DWORD, DWORD *) PURE; + STDMETHOD (Read) (THIS_ PCWSTR, PVOID *, DWORD *) PURE; + STDMETHOD (Revert) (THIS_ PCWSTR) PURE; + STDMETHOD (Select) (THIS_ PCWSTR, BOOL) PURE; + STDMETHOD (Write) (THIS_ PCWSTR, PVOID, DWORD) PURE; + }; + +typedef ISRSpeakerW FAR *PISRSPEAKERW; + + +#undef INTERFACE +#define INTERFACE ISRSpeakerA + +DEFINE_GUID(IID_ISRSpeakerA, 0x090CD9AF, 0xDA1A, 0x11CD, 0xB3, 0xCA, 0x0, 0xAA, 0x0, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ISRSpeakerA, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRSpeakerA members + STDMETHOD (Delete) (THIS_ PCSTR) PURE; + STDMETHOD (Enum) (THIS_ PSTR *, DWORD *) PURE; + STDMETHOD (Merge) (THIS_ PCSTR, PVOID, DWORD) PURE; + STDMETHOD (New) (THIS_ PCSTR) PURE; + STDMETHOD (Query) (THIS_ PSTR, DWORD, DWORD *) PURE; + STDMETHOD (Read) (THIS_ PCSTR, PVOID *, DWORD *) PURE; + STDMETHOD (Revert) (THIS_ PCSTR) PURE; + STDMETHOD (Select) (THIS_ PCSTR, BOOL) PURE; + STDMETHOD (Write) (THIS_ PCSTR, PVOID, DWORD) PURE; + }; + +typedef ISRSpeakerA FAR *PISRSPEAKERA; + + +#ifdef _S_UNICODE + #define ISRSpeaker ISRSpeakerW + #define IID_ISRSpeaker IID_ISRSpeakerW + #define PISRSPEAKER PISRSPEAKERW + +#else + #define ISRSpeaker ISRSpeakerA + #define IID_ISRSpeaker IID_ISRSpeakerA + #define PISRSPEAKER PISRSPEAKERA + +#endif // _S_UNICODE + + +/* + * ISRSpeaker2 + */ + +#undef INTERFACE +#define INTERFACE ISRSpeaker2W + +// {9B445333-E39F-11d1-BED7-006008317CE8} +DEFINE_GUID(IID_ISRSpeaker2W, +0x9b445333, 0xe39f, 0x11d1, 0xbe, 0xd7, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +DECLARE_INTERFACE_ (ISRSpeaker2W, ISRSpeakerW) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRSpeaker2W members + STDMETHOD (Delete) (THIS_ PCWSTR) PURE; + STDMETHOD (Enum) (THIS_ PWSTR *, DWORD *) PURE; + STDMETHOD (Merge) (THIS_ PCWSTR, PVOID, DWORD) PURE; + STDMETHOD (New) (THIS_ PCWSTR) PURE; + STDMETHOD (Query) (THIS_ PWSTR, DWORD, DWORD *) PURE; + STDMETHOD (Read) (THIS_ PCWSTR, PVOID *, DWORD *) PURE; + STDMETHOD (Revert) (THIS_ PCWSTR) PURE; + STDMETHOD (Select) (THIS_ PCWSTR, BOOL) PURE; + STDMETHOD (Write) (THIS_ PCWSTR, PVOID, DWORD) PURE; + + STDMETHOD (Commit) (THIS) PURE; + STDMETHOD (Rename) (THIS_ PCWSTR, PCWSTR) PURE; + STDMETHOD (GetChangedInfo) (THIS_ BOOL *, FILETIME*) PURE; + }; + +typedef ISRSpeaker2W FAR *PISRSPEAKER2W; + + +#undef INTERFACE +#define INTERFACE ISRSpeaker2A + +// {9B445334-E39F-11d1-BED7-006008317CE8} +DEFINE_GUID(IID_ISRSpeaker2A, +0x9b445334, 0xe39f, 0x11d1, 0xbe, 0xd7, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +DECLARE_INTERFACE_ (ISRSpeaker2A, ISRSpeakerA) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISRSpeaker2A members + STDMETHOD (Delete) (THIS_ PCSTR) PURE; + STDMETHOD (Enum) (THIS_ PSTR *, DWORD *) PURE; + STDMETHOD (Merge) (THIS_ PCSTR, PVOID, DWORD) PURE; + STDMETHOD (New) (THIS_ PCSTR) PURE; + STDMETHOD (Query) (THIS_ PSTR, DWORD, DWORD *) PURE; + STDMETHOD (Read) (THIS_ PCSTR, PVOID *, DWORD *) PURE; + STDMETHOD (Revert) (THIS_ PCSTR) PURE; + STDMETHOD (Select) (THIS_ PCSTR, BOOL) PURE; + STDMETHOD (Write) (THIS_ PCSTR, PVOID, DWORD) PURE; + + STDMETHOD (Commit) (THIS) PURE; + STDMETHOD (Rename) (THIS_ PCSTR, PCSTR) PURE; + STDMETHOD (GetChangedInfo) (THIS_ BOOL *, FILETIME*) PURE; + }; + +typedef ISRSpeaker2A FAR *PISRSPEAKER2A; + + +#ifdef _S_UNICODE + #define ISRSpeaker2 ISRSpeaker2W + #define IID_ISRSpeaker2 IID_ISRSpeaker2W + #define PISRSPEAKER2 PISRSPEAKER2W + +#else + #define ISRSpeaker2 ISRSpeaker2A + #define IID_ISRSpeaker2 IID_ISRSpeaker2A + #define PISRSPEAKER2 PISRSPEAKER2A + +#endif // _S_UNICODE + + +/************************************************************************ +Low-Level text-to-speech API +*/ + + +/************************************************************************ +defines */ + +#define TTSI_NAMELEN SVFN_LEN +#define TTSI_STYLELEN SVFN_LEN + +#define GENDER_NEUTRAL (0) +#define GENDER_FEMALE (1) +#define GENDER_MALE (2) + +#define TTSFEATURE_ANYWORD SETBIT(0) +#define TTSFEATURE_VOLUME SETBIT(1) +#define TTSFEATURE_SPEED SETBIT(2) +#define TTSFEATURE_PITCH SETBIT(3) +#define TTSFEATURE_TAGGED SETBIT(4) +#define TTSFEATURE_IPAUNICODE SETBIT(5) +#define TTSFEATURE_VISUAL SETBIT(6) +#define TTSFEATURE_WORDPOSITION SETBIT(7) +#define TTSFEATURE_PCOPTIMIZED SETBIT(8) +#define TTSFEATURE_PHONEOPTIMIZED SETBIT(9) +#define TTSFEATURE_FIXEDAUDIO SETBIT(10) +#define TTSFEATURE_SINGLEINSTANCE SETBIT(11) +#define TTSFEATURE_THREADSAFE SETBIT(12) +#define TTSFEATURE_IPATEXTDATA SETBIT(13) +#define TTSFEATURE_PREFERRED SETBIT(14) +#define TTSFEATURE_TRANSPLANTED SETBIT(15) +#define TTSFEATURE_SAPI4 SETBIT(16) + +#define TTSI_ILEXPRONOUNCE SETBIT(0) +#define TTSI_ITTSATTRIBUTES SETBIT(1) +#define TTSI_ITTSCENTRAL SETBIT(2) +#define TTSI_ITTSDIALOGS SETBIT(3) +#define TTSI_ATTRIBUTES SETBIT(4) +#define TTSI_IATTRIBUTES SETBIT(4) +#define TTSI_ILEXPRONOUNCE2 SETBIT(5) + +#define TTSDATAFLAG_TAGGED SETBIT(0) + +#define TTSBNS_ABORTED SETBIT(0) + +// ITTSNotifySink +#define TTSNSAC_REALTIME 0 +#define TTSNSAC_PITCH 1 +#define TTSNSAC_SPEED 2 +#define TTSNSAC_VOLUME 3 + + +#define TTSNSHINT_QUESTION SETBIT(0) +#define TTSNSHINT_STATEMENT SETBIT(1) +#define TTSNSHINT_COMMAND SETBIT(2) +#define TTSNSHINT_EXCLAMATION SETBIT(3) +#define TTSNSHINT_EMPHASIS SETBIT(4) + + +// Ages +#define TTSAGE_BABY 1 +#define TTSAGE_TODDLER 3 +#define TTSAGE_CHILD 6 +#define TTSAGE_ADOLESCENT 14 +#define TTSAGE_ADULT 30 +#define TTSAGE_ELDERLY 70 + +// Attribute minimums and maximums +#define TTSATTR_MINPITCH 0 +#define TTSATTR_MAXPITCH 0xffff +#define TTSATTR_MINREALTIME 0 +#define TTSATTR_MAXREALTIME 0xffffffff +#define TTSATTR_MINSPEED 0 +#define TTSATTR_MAXSPEED 0xffffffff +#define TTSATTR_MINVOLUME 0 +#define TTSATTR_MAXVOLUME 0xffffffff + + +/************************************************************************ +typedefs */ + +typedef struct { + BYTE bMouthHeight; + BYTE bMouthWidth; + BYTE bMouthUpturn; + BYTE bJawOpen; + BYTE bTeethUpperVisible; + BYTE bTeethLowerVisible; + BYTE bTonguePosn; + BYTE bLipTension; + } TTSMOUTH, *PTTSMOUTH; + + + +typedef struct { + GUID gEngineID; + WCHAR szMfgName[TTSI_NAMELEN]; + WCHAR szProductName[TTSI_NAMELEN]; + GUID gModeID; + WCHAR szModeName[TTSI_NAMELEN]; + LANGUAGEW language; + WCHAR szSpeaker[TTSI_NAMELEN]; + WCHAR szStyle[TTSI_STYLELEN]; + WORD wGender; + WORD wAge; + DWORD dwFeatures; + DWORD dwInterfaces; + DWORD dwEngineFeatures; + } TTSMODEINFOW, *PTTSMODEINFOW; + +typedef struct { + GUID gEngineID; + CHAR szMfgName[TTSI_NAMELEN]; + CHAR szProductName[TTSI_NAMELEN]; + GUID gModeID; + CHAR szModeName[TTSI_NAMELEN]; + LANGUAGEA language; + CHAR szSpeaker[TTSI_NAMELEN]; + CHAR szStyle[TTSI_STYLELEN]; + WORD wGender; + WORD wAge; + DWORD dwFeatures; + DWORD dwInterfaces; + DWORD dwEngineFeatures; + } TTSMODEINFOA, *PTTSMODEINFOA; + +#ifdef _S_UNICODE + #define TTSMODEINFO TTSMODEINFOW + #define PTTSMODEINFO PTTSMODEINFOW + +#else + #define TTSMODEINFO TTSMODEINFOA + #define PTTSMODEINFO PTTSMODEINFOA + +#endif // _S_UNICODE + + + +typedef struct { + DWORD dwEngineID; + DWORD dwMfgName; + DWORD dwProductName; + DWORD dwModeID; + DWORD dwModeName; + DWORD dwLanguage; + DWORD dwDialect; + DWORD dwSpeaker; + DWORD dwStyle; + DWORD dwGender; + DWORD dwAge; + DWORD dwFeatures; + DWORD dwInterfaces; + DWORD dwEngineFeatures; + } TTSMODEINFORANK, * PTTSMODEINFORANK; + +/************************************************************************ +Class IDs */ +// {D67C0280-C743-11cd-80E5-00AA003E4B50} +DEFINE_GUID(CLSID_TTSEnumerator, +0xd67c0280, 0xc743, 0x11cd, 0x80, 0xe5, 0x0, 0xaa, 0x0, 0x3e, 0x4b, 0x50); + +/************************************************************************ +interfaces */ + +// ITTSAttributes + +#undef INTERFACE +#define INTERFACE ITTSAttributesW + +DEFINE_GUID(IID_ITTSAttributesW, 0x1287A280L, 0x4A47, 0x101B, 0x93, 0x1A, 0x00, 0xAA, 0x00, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ITTSAttributesW, IUnknown) { + +// IUnknown members + + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + +// ITTSAttributes members + + STDMETHOD (PitchGet) (THIS_ WORD *) PURE; + STDMETHOD (PitchSet) (THIS_ WORD) PURE; + STDMETHOD (RealTimeGet) (THIS_ DWORD *) PURE; + STDMETHOD (RealTimeSet) (THIS_ DWORD) PURE; + STDMETHOD (SpeedGet) (THIS_ DWORD *) PURE; + STDMETHOD (SpeedSet) (THIS_ DWORD) PURE; + STDMETHOD (VolumeGet) (THIS_ DWORD *) PURE; + STDMETHOD (VolumeSet) (THIS_ DWORD) PURE; + }; + +typedef ITTSAttributesW FAR * PITTSATTRIBUTESW; + + +#undef INTERFACE +#define INTERFACE ITTSAttributesA + +DEFINE_GUID(IID_ITTSAttributesA, +0x0FD6E2A1L, 0xE77D, 0x11CD, 0xB3, 0xCA, 0x00, 0xAA, 0x00, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ITTSAttributesA, IUnknown) { + +// IUnknown members + + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + +// ITTSAttributes members + + STDMETHOD (PitchGet) (THIS_ WORD *) PURE; + STDMETHOD (PitchSet) (THIS_ WORD) PURE; + STDMETHOD (RealTimeGet) (THIS_ DWORD *) PURE; + STDMETHOD (RealTimeSet) (THIS_ DWORD) PURE; + STDMETHOD (SpeedGet) (THIS_ DWORD *) PURE; + STDMETHOD (SpeedSet) (THIS_ DWORD) PURE; + STDMETHOD (VolumeGet) (THIS_ DWORD *) PURE; + STDMETHOD (VolumeSet) (THIS_ DWORD) PURE; + }; + +typedef ITTSAttributesA FAR * PITTSATTRIBUTESA; + + +#ifdef _S_UNICODE + #define ITTSAttributes ITTSAttributesW + #define IID_ITTSAttributes IID_ITTSAttributesW + #define PITTSATTRIBUTES PITTSATTRIBUTESW + +#else + #define ITTSAttributes ITTSAttributesA + #define IID_ITTSAttributes IID_ITTSAttributesA + #define PITTSATTRIBUTES PITTSATTRIBUTESA + +#endif // _S_UNICODE + + + +// ITTSBufNotifySink + +#undef INTERFACE +#define INTERFACE ITTSBufNotifySink + +// {E4963D40-C743-11cd-80E5-00AA003E4B50} +DEFINE_GUID(IID_ITTSBufNotifySink, +0xe4963d40, 0xc743, 0x11cd, 0x80, 0xe5, 0x0, 0xaa, 0x0, 0x3e, 0x4b, 0x50); + +DECLARE_INTERFACE_ (ITTSBufNotifySink, IUnknown) { + +// IUnknown members + + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + +// ITTSBufNotifySink members + + STDMETHOD (TextDataDone) (THIS_ QWORD, DWORD) PURE; + STDMETHOD (TextDataStarted)(THIS_ QWORD) PURE; + STDMETHOD (BookMark) (THIS_ QWORD, DWORD) PURE; + STDMETHOD (WordPosition) (THIS_ QWORD, DWORD) PURE; + }; + +typedef ITTSBufNotifySink FAR * PITTSBUFNOTIFYSINK; + +// In case anyone uses the W or A interface +#define ITTSBufNotifySinkW ITTSBufNotifySink +#define IID_ITTSBufNotifySinkW IID_ITTSBufNotifySink +#define PITTSBUFNOTIFYSINKW PITTSBUFNOTIFYSINK +#define ITTSBufNotifySinkA ITTSBufNotifySink +#define IID_ITTSBufNotifySinkA IID_ITTSBufNotifySink +#define PITTSBUFNOTIFYSINKA PITTSBUFNOTIFYSINK + + + +/* + * ITTSCentral + */ + +#undef INTERFACE +#define INTERFACE ITTSCentralW + +DEFINE_GUID(IID_ITTSCentralW, 0x28016060L, 0x4A47, 0x101B, 0x93, 0x1A, 0x00, 0xAA, 0x00, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ITTSCentralW, IUnknown) { + + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ITTSCentralW members + STDMETHOD (Inject) (THIS_ PCWSTR) PURE; + STDMETHOD (ModeGet) (THIS_ PTTSMODEINFOW) PURE; + STDMETHOD (Phoneme) (THIS_ VOICECHARSET, DWORD, SDATA, PSDATA) PURE; + STDMETHOD (PosnGet) (THIS_ PQWORD) PURE; + STDMETHOD (TextData) (THIS_ VOICECHARSET, DWORD, SDATA, PVOID, IID) PURE; + STDMETHOD (ToFileTime) (THIS_ PQWORD, FILETIME *) PURE; + STDMETHOD (AudioPause) (THIS) PURE; + STDMETHOD (AudioResume) (THIS) PURE; + STDMETHOD (AudioReset) (THIS) PURE; + STDMETHOD (Register) (THIS_ PVOID, IID, DWORD*) PURE; + STDMETHOD (UnRegister) (THIS_ DWORD) PURE; + }; + +typedef ITTSCentralW FAR * PITTSCENTRALW; + + +#undef INTERFACE +#define INTERFACE ITTSCentralA + +DEFINE_GUID(IID_ITTSCentralA, 0x05EB6C6AL, 0xDBAB, 0x11CD, 0xB3, 0xCA, 0x00, 0xAA, 0x00, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ITTSCentralA, IUnknown) { + + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ITTSCentralA members + STDMETHOD (Inject) (THIS_ PCSTR) PURE; + STDMETHOD (ModeGet) (THIS_ PTTSMODEINFOA) PURE; + STDMETHOD (Phoneme) (THIS_ VOICECHARSET, DWORD, SDATA, PSDATA) PURE; + STDMETHOD (PosnGet) (THIS_ PQWORD) PURE; + STDMETHOD (TextData) (THIS_ VOICECHARSET, DWORD, SDATA, PVOID, IID) PURE; + STDMETHOD (ToFileTime) (THIS_ PQWORD, FILETIME *) PURE; + STDMETHOD (AudioPause) (THIS) PURE; + STDMETHOD (AudioResume) (THIS) PURE; + STDMETHOD (AudioReset) (THIS) PURE; + STDMETHOD (Register) (THIS_ PVOID, IID, DWORD*) PURE; + STDMETHOD (UnRegister) (THIS_ DWORD) PURE; + }; + +typedef ITTSCentralA FAR * PITTSCENTRALA; + + +#ifdef _S_UNICODE + #define ITTSCentral ITTSCentralW + #define IID_ITTSCentral IID_ITTSCentralW + #define PITTSCENTRAL PITTSCENTRALW + +#else + #define ITTSCentral ITTSCentralA + #define IID_ITTSCentral IID_ITTSCentralA + #define PITTSCENTRAL PITTSCENTRALA + +#endif // _S_UNICODE + + + +/* + * ITTSDialogsW + */ + +#undef INTERFACE +#define INTERFACE ITTSDialogsW + +DEFINE_GUID(IID_ITTSDialogsW, 0x47F59D00L, 0x4A47, 0x101B, 0x93, 0x1A, 0x00, 0xAA, 0x00, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ITTSDialogsW, IUnknown) { + + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ITTSDialogsW members + STDMETHOD (AboutDlg) (THIS_ HWND, PCWSTR) PURE; + STDMETHOD (LexiconDlg) (THIS_ HWND, PCWSTR) PURE; + STDMETHOD (GeneralDlg) (THIS_ HWND, PCWSTR) PURE; + STDMETHOD (TranslateDlg) (THIS_ HWND, PCWSTR) PURE; + }; + +typedef ITTSDialogsW FAR * PITTSDIALOGSW; + + +#undef INTERFACE +#define INTERFACE ITTSDialogsA + +DEFINE_GUID(IID_ITTSDialogsA, 0x05EB6C6BL, 0xDBAB, 0x11CD, 0xB3, 0xCA, 0x00, 0xAA, 0x00, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ITTSDialogsA, IUnknown) { + + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ITTSDialogsA members + STDMETHOD (AboutDlg) (THIS_ HWND, PCSTR) PURE; + STDMETHOD (LexiconDlg) (THIS_ HWND, PCSTR) PURE; + STDMETHOD (GeneralDlg) (THIS_ HWND, PCSTR) PURE; + STDMETHOD (TranslateDlg) (THIS_ HWND, PCSTR) PURE; + }; + +typedef ITTSDialogsA FAR * PITTSDIALOGSA; + + +#ifdef _S_UNICODE + #define ITTSDialogs ITTSDialogsW + #define IID_ITTSDialogs IID_ITTSDialogsW + #define PITTSDIALOGS PITTSDIALOGSW + +#else + #define ITTSDialogs ITTSDialogsA + #define IID_ITTSDialogs IID_ITTSDialogsA + #define PITTSDIALOGS PITTSDIALOGSA + +#endif + + + +/* + * ITTSEnum + */ + +#undef INTERFACE +#define INTERFACE ITTSEnumW + +DEFINE_GUID(IID_ITTSEnumW, 0x6B837B20L, 0x4A47, 0x101B, 0x93, 0x1A, 0x00, 0xAA, 0x00, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ITTSEnumW, IUnknown) { + + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ITTSEnumW members + STDMETHOD (Next) (THIS_ ULONG, PTTSMODEINFOW, ULONG *) PURE; + STDMETHOD (Skip) (THIS_ ULONG) PURE; + STDMETHOD (Reset) (THIS) PURE; + STDMETHOD (Clone) (THIS_ ITTSEnumW * FAR *) PURE; + STDMETHOD (Select) (THIS_ GUID, PITTSCENTRALW *, LPUNKNOWN) PURE; + }; + +typedef ITTSEnumW FAR * PITTSENUMW; + + +#undef INTERFACE +#define INTERFACE ITTSEnumA + +DEFINE_GUID(IID_ITTSEnumA, 0x05EB6C6DL, 0xDBAB, 0x11CD, 0xB3, 0xCA, 0x00, 0xAA, 0x00, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ITTSEnumA, IUnknown) { + + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ITTSEnumA members + STDMETHOD (Next) (THIS_ ULONG, PTTSMODEINFOA, ULONG *) PURE; + STDMETHOD (Skip) (THIS_ ULONG) PURE; + STDMETHOD (Reset) (THIS) PURE; + STDMETHOD (Clone) (THIS_ ITTSEnumA * FAR *) PURE; + STDMETHOD (Select) (THIS_ GUID, PITTSCENTRALA *, LPUNKNOWN) PURE; + }; + +typedef ITTSEnumA FAR * PITTSENUMA; + + +#ifdef _S_UNICODE + #define ITTSEnum ITTSEnumW + #define IID_ITTSEnum IID_ITTSEnumW + #define PITTSENUM PITTSENUMW + +#else + #define ITTSEnum ITTSEnumA + #define IID_ITTSEnum IID_ITTSEnumA + #define PITTSENUM PITTSENUMA + +#endif + + + +/* + * ITTSFind + */ + +#undef INTERFACE +#define INTERFACE ITTSFindW + +DEFINE_GUID(IID_ITTSFindW, 0x7AA42960L, 0x4A47, 0x101B, 0x93, 0x1A, 0x00, 0xAA, 0x00, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ITTSFindW, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ITTSFindW members + STDMETHOD (Find) (THIS_ PTTSMODEINFOW, PTTSMODEINFORANK, PTTSMODEINFOW) PURE; + STDMETHOD (Select) (THIS_ GUID, PITTSCENTRALW *, LPUNKNOWN) PURE; + }; + +typedef ITTSFindW FAR * PITTSFINDW; + + +#undef INTERFACE +#define INTERFACE ITTSFindA + +DEFINE_GUID(IID_ITTSFindA, 0x05EB6C6EL, 0xDBAB, 0x11CD, 0xB3, 0xCA, 0x00, 0xAA, 0x00, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ITTSFindA, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ITTSFindA members + STDMETHOD (Find) (THIS_ PTTSMODEINFOA, PTTSMODEINFORANK, PTTSMODEINFOA) PURE; + STDMETHOD (Select) (THIS_ GUID, PITTSCENTRALA *, LPUNKNOWN) PURE; + }; + +typedef ITTSFindA FAR * PITTSFINDA; + + +#ifdef _S_UNICODE + #define ITTSFind ITTSFindW + #define IID_ITTSFind IID_ITTSFindW + #define PITTSFIND PITTSFINDW + +#else + #define ITTSFind ITTSFindA + #define IID_ITTSFind IID_ITTSFindA + #define PITTSFIND PITTSFINDA + +#endif + + + +/* + * ITTSNotifySink + */ + +#undef INTERFACE +#define INTERFACE ITTSNotifySinkW + +DEFINE_GUID(IID_ITTSNotifySinkW, 0xC0FA8F40L, 0x4A46, 0x101B, 0x93, 0x1A, 0x00, 0xAA, 0x00, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ITTSNotifySinkW, IUnknown) { + +// IUnknown members + + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + +// ITTSNotifySinkW members + + STDMETHOD (AttribChanged) (THIS_ DWORD) PURE; + STDMETHOD (AudioStart) (THIS_ QWORD) PURE; + STDMETHOD (AudioStop) (THIS_ QWORD) PURE; + STDMETHOD (Visual) (THIS_ QWORD, WCHAR, WCHAR, DWORD, PTTSMOUTH) PURE; + }; + +typedef ITTSNotifySinkW FAR * PITTSNOTIFYSINKW; + + +#undef INTERFACE +#define INTERFACE ITTSNotifySinkA + +DEFINE_GUID(IID_ITTSNotifySinkA, 0x05EB6C6FL, 0xDBAB, 0x11CD, 0xB3, 0xCA, 0x00, 0xAA, 0x00, 0x47, 0xBA, 0x4F); + +DECLARE_INTERFACE_ (ITTSNotifySinkA, IUnknown) { + + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ITTSNotifySinkA members + STDMETHOD (AttribChanged) (THIS_ DWORD) PURE; + STDMETHOD (AudioStart) (THIS_ QWORD) PURE; + STDMETHOD (AudioStop) (THIS_ QWORD) PURE; + STDMETHOD (Visual) (THIS_ QWORD, CHAR, CHAR, DWORD, PTTSMOUTH) PURE; + }; + +typedef ITTSNotifySinkA FAR * PITTSNOTIFYSINKA; + + +#ifdef _S_UNICODE + #define ITTSNotifySink ITTSNotifySinkW + #define IID_ITTSNotifySink IID_ITTSNotifySinkW + #define PITTSNOTIFYSINK PITTSNOTIFYSINKW + +#else + #define ITTSNotifySink ITTSNotifySinkA + #define IID_ITTSNotifySink IID_ITTSNotifySinkA + #define PITTSNOTIFYSINK PITTSNOTIFYSINKA + +#endif + + +/* ITTSNotifySink2 */ + +#undef INTERFACE +#define INTERFACE ITTSNotifySink2W + +// {599F77E1-E42E-11d1-BED8-006008317CE8} +DEFINE_GUID(IID_ITTSNotifySink2W, +0x599f77e1, 0xe42e, 0x11d1, 0xbe, 0xd8, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +DECLARE_INTERFACE_ (ITTSNotifySink2W, ITTSNotifySinkW) { + +// IUnknown members + + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + +// ITTSNotifySink2W members + + STDMETHOD (AttribChanged) (THIS_ DWORD) PURE; + STDMETHOD (AudioStart) (THIS_ QWORD) PURE; + STDMETHOD (AudioStop) (THIS_ QWORD) PURE; + STDMETHOD (Visual) (THIS_ QWORD, WCHAR, WCHAR, DWORD, PTTSMOUTH) PURE; + + STDMETHOD (Error) (THIS_ LPUNKNOWN) PURE; + STDMETHOD (Warning) (THIS_ LPUNKNOWN) PURE; + STDMETHOD (VisualFuture) (THIS_ DWORD, QWORD, WCHAR, WCHAR, DWORD, PTTSMOUTH) PURE; + }; + +typedef ITTSNotifySink2W FAR * PITTSNOTIFYSINK2W; + + +#undef INTERFACE +#define INTERFACE ITTSNotifySink2A + +// {599F77E2-E42E-11d1-BED8-006008317CE8} +DEFINE_GUID(IID_ITTSNotifySink2A, +0x599f77e2, 0xe42e, 0x11d1, 0xbe, 0xd8, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +DECLARE_INTERFACE_ (ITTSNotifySink2A, ITTSNotifySinkA) { + + // IUnknown members + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ITTSNotifySink2A members + STDMETHOD (AttribChanged) (THIS_ DWORD) PURE; + STDMETHOD (AudioStart) (THIS_ QWORD) PURE; + STDMETHOD (AudioStop) (THIS_ QWORD) PURE; + STDMETHOD (Visual) (THIS_ QWORD, CHAR, CHAR, DWORD, PTTSMOUTH) PURE; + + STDMETHOD (Error) (THIS_ LPUNKNOWN) PURE; + STDMETHOD (Warning) (THIS_ LPUNKNOWN) PURE; + STDMETHOD (VisualFuture) (THIS_ DWORD, QWORD, CHAR, CHAR, DWORD, PTTSMOUTH) PURE; + }; + +typedef ITTSNotifySink2A FAR * PITTSNOTIFYSINK2A; + + +#ifdef _S_UNICODE + #define ITTSNotifySink2 ITTSNotifySink2W + #define IID_ITTSNotifySink2 IID_ITTSNotifySink2W + #define PITTSNOTIFYSINK2 PITTSNOTIFYSINK2W + +#else + #define ITTSNotifySink2 ITTSNotifySink2A + #define IID_ITTSNotifySink2 IID_ITTSNotifySink2A + #define PITTSNOTIFYSINK2 PITTSNOTIFYSINK2A + +#endif + + +/************************************************************************ +High-Level command and control speech recognition API +*/ + +/************************************************************************ +defines */ + + +// VCMDNAME member lengths +#define VCMD_APPLEN ((DWORD)32) +#define VCMD_STATELEN VCMD_APPLEN +#define VCMD_MICLEN VCMD_APPLEN +#define VCMD_SPEAKERLEN VCMD_APPLEN + +// dwFlags parameter of IVoiceCmd::MenuCreate +#define VCMDMC_CREATE_TEMP 0x00000001 +#define VCMDMC_CREATE_NEW 0x00000002 +#define VCMDMC_CREATE_ALWAYS 0x00000004 +#define VCMDMC_OPEN_ALWAYS 0x00000008 +#define VCMDMC_OPEN_EXISTING 0x00000010 + +// dwFlags parameter of IVoiceCmd::Register +#define VCMDRF_NOMESSAGES 0 +#define VCMDRF_ALLBUTVUMETER 0x00000001 +#define VCMDRF_VUMETER 0x00000002 +#define VCMDRF_ALLMESSAGES (VCMDRF_ALLBUTVUMETER | VCMDRF_VUMETER) + +// dwFlags parameter of IVoiceCmd::MenuEnum +#define VCMDEF_DATABASE 0x00000000 +#define VCMDEF_ACTIVE 0x00000001 +#define VCMDEF_SELECTED 0x00000002 +#define VCMDEF_PERMANENT 0x00000004 +#define VCMDEF_TEMPORARY 0x00000008 + +// dwFlags parameter of IVCmdMenu::Activate +#define VWGFLAG_ASLEEP 0x00000001 + +// wPriority parameter of IVCmdMenu::Activate +#define VCMDACT_NORMAL (0x8000) +#define VCMDACT_LOW (0x4000) +#define VCMDACT_HIGH (0xC000) + +// dwFlags of the VCMDCOMMAND structure +#define VCMDCMD_VERIFY 0x00000001 +#define VCMDCMD_DISABLED_TEMP 0x00000002 +#define VCMDCMD_DISABLED_PERM 0x00000004 +#define VCMDCMD_CANTRENAME 0x00000008 + +// parameter to any function that processes individual commands +#define VCMD_BY_POSITION 0x00000001 +#define VCMD_BY_IDENTIFIER 0x00000002 + + +// values for dwAttributes field of IVCmdNotifySink::AttribChanged +#define IVCNSAC_AUTOGAINENABLE 0x00000001 +#define IVCNSAC_ENABLED 0x00000002 +#define IVCNSAC_AWAKE 0x00000004 +#define IVCNSAC_DEVICE 0x00000008 +#define IVCNSAC_MICROPHONE 0x00000010 +#define IVCNSAC_SPEAKER 0x00000020 +#define IVCNSAC_SRMODE 0x00000040 +#define IVCNSAC_THRESHOLD 0x00000080 +#define IVCNSAC_ORIGINAPP 0x00010000 + +// values for dwAttributes field of IVTxtNotifySink::AttribChanged +#define IVTNSAC_DEVICE 0x00000001 +#define IVTNSAC_ENABLED 0x00000002 +#define IVTNSAC_SPEED 0x00000004 +#define IVTNSAC_VOLUME 0x00000008 +#define IVTNSAC_TTSMODE 0x00000010 + + +// values used by IVXxxAttributes::SetMode to set the global speech +// recognition mode +#define VSRMODE_OFF 0x00000002 +#define VSRMODE_DISABLED 0x00000001 +#define VSRMODE_CMDPAUSED 0x00000004 +#define VSRMODE_CMDONLY 0x00000010 +#define VSRMODE_DCTONLY 0x00000020 +#define VSRMODE_CMDANDDCT 0x00000040 + + +/************************************************************************ +typedefs */ + +// voice command structure - passed to command menu functions (IVCmdMenu) +typedef struct { + DWORD dwSize; // size of struct including amount of abAction + DWORD dwFlags; + DWORD dwID; // Command ID + DWORD dwCommand; // DWORD aligned offset of command string + DWORD dwDescription; // DWORD aligned offset of description string + DWORD dwCategory; // DWORD aligned offset of category string + DWORD dwCommandText; // DWORD aligned offset of command text string + DWORD dwAction; // DWORD aligned offset of action data + DWORD dwActionSize; // size of the action data (could be string or binary) + BYTE abData[1]; // command, description, category, and action data + // (action data is NOT interpreted by voice command) +} VCMDCOMMAND, * PVCMDCOMMAND; + + + +// site information structure - possible parameter to IVoiceCmd::Register +typedef struct { + DWORD dwAutoGainEnable; + DWORD dwAwakeState; + DWORD dwThreshold; + DWORD dwDevice; + DWORD dwEnable; + WCHAR szMicrophone[VCMD_MICLEN]; + WCHAR szSpeaker[VCMD_SPEAKERLEN]; + GUID gModeID; +} VCSITEINFOW, *PVCSITEINFOW; + +typedef struct { + DWORD dwAutoGainEnable; + DWORD dwAwakeState; + DWORD dwThreshold; + DWORD dwDevice; + DWORD dwEnable; + CHAR szMicrophone[VCMD_MICLEN]; + CHAR szSpeaker[VCMD_SPEAKERLEN]; + GUID gModeID; +} VCSITEINFOA, *PVCSITEINFOA; + + + +// menu name structure +typedef struct { + WCHAR szApplication[VCMD_APPLEN]; // unique application name + WCHAR szState[VCMD_STATELEN]; // unique application state +} VCMDNAMEW, *PVCMDNAMEW; + +typedef struct { + CHAR szApplication[VCMD_APPLEN]; // unique application name + CHAR szState[VCMD_STATELEN]; // unique application state +} VCMDNAMEA, *PVCMDNAMEA; + + + +#ifdef _S_UNICODE + #define VCSITEINFO VCSITEINFOW + #define PVCSITEINFO PVCSITEINFOW + #define VCMDNAME VCMDNAMEW + #define PVCMDNAME PVCMDNAMEW +#else + #define VCSITEINFO VCSITEINFOA + #define PVCSITEINFO PVCSITEINFOA + #define VCMDNAME VCMDNAMEA + #define PVCMDNAME PVCMDNAMEA +#endif // _S_UNICODE + +/************************************************************************ +interfaces */ + +/* + * IVCmdNotifySink + */ +#undef INTERFACE +#define INTERFACE IVCmdNotifySinkW + +DEFINE_GUID(IID_IVCmdNotifySinkW, 0xCCFD7A60L, 0x604D, 0x101B, 0x99, 0x26, 0x00, 0xAA, 0x00, 0x3C, 0xFC, 0x2C); + +DECLARE_INTERFACE_ (IVCmdNotifySinkW, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVCmdNotifySink members + + STDMETHOD (CommandRecognize) (THIS_ DWORD, PVCMDNAMEW, DWORD, DWORD, PVOID, + DWORD, PWSTR, PWSTR) PURE; + STDMETHOD (CommandOther) (THIS_ PVCMDNAMEW, PWSTR) PURE; + STDMETHOD (CommandStart) (THIS) PURE; + STDMETHOD (MenuActivate) (THIS_ PVCMDNAMEW, BOOL) PURE; + STDMETHOD (UtteranceBegin) (THIS) PURE; + STDMETHOD (UtteranceEnd) (THIS) PURE; + STDMETHOD (VUMeter) (THIS_ WORD) PURE; + STDMETHOD (AttribChanged) (THIS_ DWORD) PURE; + STDMETHOD (Interference) (THIS_ DWORD) PURE; +}; + +typedef IVCmdNotifySinkW FAR * PIVCMDNOTIFYSINKW; + + +#undef INTERFACE +#define INTERFACE IVCmdNotifySinkA + +// {80B25CC0-5540-11b9-C000-5611722E1D15} +DEFINE_GUID(IID_IVCmdNotifySinkA, 0x80b25cc0, 0x5540, 0x11b9, 0xc0, 0x0, 0x56, 0x11, 0x72, 0x2e, 0x1d, 0x15); + +DECLARE_INTERFACE_ (IVCmdNotifySinkA, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVCmdNotifySinkA members + + STDMETHOD (CommandRecognize) (THIS_ DWORD, PVCMDNAMEA, DWORD, DWORD, PVOID, + DWORD, PSTR, PSTR) PURE; + STDMETHOD (CommandOther) (THIS_ PVCMDNAMEA, PSTR) PURE; + STDMETHOD (CommandStart) (THIS) PURE; + STDMETHOD (MenuActivate) (THIS_ PVCMDNAMEA, BOOL) PURE; + STDMETHOD (UtteranceBegin) (THIS) PURE; + STDMETHOD (UtteranceEnd) (THIS) PURE; + STDMETHOD (VUMeter) (THIS_ WORD) PURE; + STDMETHOD (AttribChanged) (THIS_ DWORD) PURE; + STDMETHOD (Interference) (THIS_ DWORD) PURE; +}; + +typedef IVCmdNotifySinkA FAR * PIVCMDNOTIFYSINKA; + + +#ifdef _S_UNICODE + #define IVCmdNotifySink IVCmdNotifySinkW + #define IID_IVCmdNotifySink IID_IVCmdNotifySinkW + #define PIVCMDNOTIFYSINK PIVCMDNOTIFYSINKW + +#else + #define IVCmdNotifySink IVCmdNotifySinkA + #define IID_IVCmdNotifySink IID_IVCmdNotifySinkA + #define PIVCMDNOTIFYSINK PIVCMDNOTIFYSINKA + +#endif // _S_UNICODE + + +/* + * IVCmdEnum + */ +#undef INTERFACE +#define INTERFACE IVCmdEnumW + +DEFINE_GUID(IID_IVCmdEnumW, 0xD3CC0820L, 0x604D, 0x101B, 0x99, 0x26, 0x00, 0xAA, 0x00, 0x3C, 0xFC, 0x2C); + +DECLARE_INTERFACE_ (IVCmdEnumW, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVCmdEnum members + STDMETHOD (Next) (THIS_ ULONG, PVCMDNAMEW, ULONG *) PURE; + STDMETHOD (Skip) (THIS_ ULONG) PURE; + STDMETHOD (Reset) (THIS) PURE; + STDMETHOD (Clone) (THIS_ IVCmdEnumW * FAR *) PURE; +}; +typedef IVCmdEnumW FAR * PIVCMDENUMW; + + +#undef INTERFACE +#define INTERFACE IVCmdEnumA + +// {E86F9540-DCA2-11CD-A166-00AA004CD65C} +DEFINE_GUID(IID_IVCmdEnumA, +0xE86F9540, 0xDCA2, 0x11CD, 0xA1, 0x66, 0x0, 0xAA, 0x0, 0x4C, 0xD6, 0x5C); + +DECLARE_INTERFACE_ (IVCmdEnumA, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVCmdEnum members + STDMETHOD (Next) (THIS_ ULONG, PVCMDNAMEA, ULONG *) PURE; + STDMETHOD (Skip) (THIS_ ULONG) PURE; + STDMETHOD (Reset) (THIS) PURE; + STDMETHOD (Clone) (THIS_ IVCmdEnumA * FAR *) PURE; +}; +typedef IVCmdEnumA FAR * PIVCMDENUMA; + + +#ifdef _S_UNICODE + #define IVCmdEnum IVCmdEnumW + #define IID_IVCmdEnum IID_IVCmdEnumW + #define PIVCMDENUM PIVCMDENUMW + +#else + #define IVCmdEnum IVCmdEnumA + #define IID_IVCmdEnum IID_IVCmdEnumA + #define PIVCMDENUM PIVCMDENUMA + +#endif // _S_UNICODE + + + + +/* + * IEnumSRShare + */ +#undef INTERFACE +#define INTERFACE IEnumSRShareW + +// {E97F05C0-81B3-11ce-B763-00AA004CD65C} +DEFINE_GUID(IID_IEnumSRShareW, +0xe97f05c0, 0x81b3, 0x11ce, 0xb7, 0x63, 0x0, 0xaa, 0x0, 0x4c, 0xd6, 0x5c); + +DECLARE_INTERFACE_ (IEnumSRShareW, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IEnumSRShare members + STDMETHOD (Next) (THIS_ ULONG, PSRSHAREW, ULONG *) PURE; + STDMETHOD (Skip) (THIS_ ULONG) PURE; + STDMETHOD (Reset) (THIS) PURE; + STDMETHOD (Clone) (THIS_ IEnumSRShareW * FAR *) PURE; + STDMETHOD (New) (THIS_ DWORD, GUID, PISRCENTRALW *, QWORD *) PURE; + STDMETHOD (Share) (THIS_ QWORD, PISRCENTRALW *) PURE; + STDMETHOD (Detach) (THIS_ QWORD) PURE; +}; +typedef IEnumSRShareW FAR * PIENUMSRSHAREW; + + +#undef INTERFACE +#define INTERFACE IEnumSRShareA + +// {E97F05C1-81B3-11ce-B763-00AA004CD65C} +DEFINE_GUID(IID_IEnumSRShareA, +0xe97f05c1, 0x81b3, 0x11ce, 0xb7, 0x63, 0x0, 0xaa, 0x0, 0x4c, 0xd6, 0x5c); + +DECLARE_INTERFACE_ (IEnumSRShareA, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IEnumSRShare members + STDMETHOD (Next) (THIS_ ULONG, PSRSHAREA, ULONG *) PURE; + STDMETHOD (Skip) (THIS_ ULONG) PURE; + STDMETHOD (Reset) (THIS) PURE; + STDMETHOD (Clone) (THIS_ IEnumSRShareA * FAR *) PURE; + STDMETHOD (New) (THIS_ DWORD, GUID, PISRCENTRALA *, QWORD *) PURE; + STDMETHOD (Share) (THIS_ QWORD, PISRCENTRALA *) PURE; + STDMETHOD (Detach) (THIS_ QWORD) PURE; +}; +typedef IEnumSRShareA FAR * PIENUMSRSHAREA; + + +#ifdef _S_UNICODE + #define IEnumSRShare IEnumSRShareW + #define IID_IEnumSRShare IID_IEnumSRShareW + #define PIENUMSRSHARE PIENUMSRSHAREW + +#else + #define IEnumSRShare IEnumSRShareA + #define IID_IEnumSRShare IID_IEnumSRShareA + #define PIENUMSRSHARE PIENUMSRSHAREA + +#endif // _S_UNICODE + + + + +/* + * IVCmdMenu + */ +#undef INTERFACE +#define INTERFACE IVCmdMenuW + +DEFINE_GUID(IID_IVCmdMenuW, 0xDAC54F60L, 0x604D, 0x101B, 0x99, 0x26, 0x00, 0xAA, 0x00, 0x3C, 0xFC, 0x2C); + +DECLARE_INTERFACE_ (IVCmdMenuW, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVCmdMenu members + STDMETHOD (Activate) (THIS_ HWND, DWORD) PURE; + STDMETHOD (Deactivate) (THIS) PURE; + STDMETHOD (TrainMenuDlg) (THIS_ HWND, PCWSTR) PURE; + STDMETHOD (Num) (THIS_ DWORD *) PURE; + STDMETHOD (Get) (THIS_ DWORD, DWORD, DWORD, PSDATA, DWORD *) PURE; + STDMETHOD (Set) (THIS_ DWORD, DWORD, DWORD, SDATA) PURE; + STDMETHOD (Add) (THIS_ DWORD, SDATA, DWORD *) PURE; + STDMETHOD (Remove) (THIS_ DWORD, DWORD, DWORD) PURE; + STDMETHOD (ListGet) (THIS_ PCWSTR, PSDATA, DWORD *) PURE; + STDMETHOD (ListSet) (THIS_ PCWSTR, DWORD, SDATA) PURE; + STDMETHOD (EnableItem) (THIS_ DWORD, DWORD, DWORD) PURE; + STDMETHOD (SetItem) (THIS_ DWORD, DWORD, DWORD) PURE; +}; + +typedef IVCmdMenuW FAR * PIVCMDMENUW; + + +#undef INTERFACE +#define INTERFACE IVCmdMenuA + +// {746141E0-5543-11b9-C000-5611722E1D15} +DEFINE_GUID(IID_IVCmdMenuA, 0x746141e0, 0x5543, 0x11b9, 0xc0, 0x0, 0x56, 0x11, 0x72, 0x2e, 0x1d, 0x15); + +DECLARE_INTERFACE_ (IVCmdMenuA, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVCmdMenu members + STDMETHOD (Activate) (THIS_ HWND, DWORD) PURE; + STDMETHOD (Deactivate) (THIS) PURE; + STDMETHOD (TrainMenuDlg) (THIS_ HWND, PCSTR) PURE; + STDMETHOD (Num) (THIS_ DWORD *) PURE; + STDMETHOD (Get) (THIS_ DWORD, DWORD, DWORD, PSDATA, DWORD *) PURE; + STDMETHOD (Set) (THIS_ DWORD, DWORD, DWORD, SDATA) PURE; + STDMETHOD (Add) (THIS_ DWORD, SDATA, DWORD *) PURE; + STDMETHOD (Remove) (THIS_ DWORD, DWORD, DWORD) PURE; + STDMETHOD (ListGet) (THIS_ PCSTR, PSDATA, DWORD *) PURE; + STDMETHOD (ListSet) (THIS_ PCSTR, DWORD, SDATA) PURE; + STDMETHOD (EnableItem) (THIS_ DWORD, DWORD, DWORD) PURE; + STDMETHOD (SetItem) (THIS_ DWORD, DWORD, DWORD) PURE; +}; + +typedef IVCmdMenuA FAR * PIVCMDMENUA; + + +#ifdef _S_UNICODE + #define IVCmdMenu IVCmdMenuW + #define IID_IVCmdMenu IID_IVCmdMenuW + #define PIVCMDMENU PIVCMDMENUW + +#else + #define IVCmdMenu IVCmdMenuA + #define IID_IVCmdMenu IID_IVCmdMenuA + #define PIVCMDMENU PIVCMDMENUA + +#endif // _S_UNICODE + + + +/* + * IVoiceCmd + */ +#undef INTERFACE +#define INTERFACE IVoiceCmdW + +DEFINE_GUID(IID_IVoiceCmdW, 0xE0DCC220L, 0x604D, 0x101B, 0x99, 0x26, 0x00, 0xAA, 0x00, 0x3C, 0xFC, 0x2C); + +DECLARE_INTERFACE_ (IVoiceCmdW, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVoiceCmd members + STDMETHOD (Register) (THIS_ PCWSTR, LPUNKNOWN, GUID, DWORD, + PVCSITEINFOW) PURE; + STDMETHOD (MenuEnum) (THIS_ DWORD, PCWSTR, PCWSTR, PIVCMDENUMW *) PURE; + STDMETHOD (MenuCreate) (THIS_ PVCMDNAMEW, PLANGUAGEW, DWORD, + PIVCMDMENUW *) PURE; + STDMETHOD (MenuDelete) (THIS_ PVCMDNAMEW) PURE; + STDMETHOD (CmdMimic) (THIS_ PVCMDNAMEW, PCWSTR) PURE; +}; + +typedef IVoiceCmdW FAR * PIVOICECMDW; + + +#undef INTERFACE +#define INTERFACE IVoiceCmdA + +// {C63A2B30-5543-11b9-C000-5611722E1D15} +DEFINE_GUID(IID_IVoiceCmdA, 0xc63a2b30, 0x5543, 0x11b9, 0xc0, 0x0, 0x56, 0x11, 0x72, 0x2e, 0x1d, 0x15); + +DECLARE_INTERFACE_ (IVoiceCmdA, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVoiceCmd members + STDMETHOD (Register) (THIS_ PCSTR, LPUNKNOWN, GUID, DWORD, + PVCSITEINFOA) PURE; + STDMETHOD (MenuEnum) (THIS_ DWORD, PCSTR, PCSTR, PIVCMDENUMA *) PURE; + STDMETHOD (MenuCreate) (THIS_ PVCMDNAMEA, PLANGUAGEA, DWORD, + PIVCMDMENUA *) PURE; + STDMETHOD (MenuDelete) (THIS_ PVCMDNAMEA) PURE; + STDMETHOD (CmdMimic) (THIS_ PVCMDNAMEA, PCSTR) PURE; +}; + +typedef IVoiceCmdA FAR * PIVOICECMDA; + + +#ifdef _S_UNICODE + #define IVoiceCmd IVoiceCmdW + #define IID_IVoiceCmd IID_IVoiceCmdW + #define PIVOICECMD PIVOICECMDW + +#else + #define IVoiceCmd IVoiceCmdA + #define IID_IVoiceCmd IID_IVoiceCmdA + #define PIVOICECMD PIVOICECMDA + +#endif //_S_UNICODE + + +/* + * IVCmdAttributes + */ +#undef INTERFACE +#define INTERFACE IVCmdAttributesW + +DEFINE_GUID(IID_IVCmdAttributesW, 0xE5F24680L, 0x6053, 0x101B, 0x99, 0x26, 0x00, 0xAA, 0x00, 0x3C, 0xFC, 0x2C); + +DECLARE_INTERFACE_ (IVCmdAttributesW, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVCmdAttributes members + STDMETHOD (AutoGainEnableGet) (THIS_ DWORD *) PURE; + STDMETHOD (AutoGainEnableSet) (THIS_ DWORD) PURE; + STDMETHOD (AwakeStateGet) (THIS_ DWORD *) PURE; + STDMETHOD (AwakeStateSet) (THIS_ DWORD) PURE; + STDMETHOD (ThresholdGet) (THIS_ DWORD *) PURE; + STDMETHOD (ThresholdSet) (THIS_ DWORD) PURE; + STDMETHOD (DeviceGet) (THIS_ DWORD *) PURE; + STDMETHOD (DeviceSet) (THIS_ DWORD) PURE; + STDMETHOD (EnabledGet) (THIS_ DWORD *) PURE; + STDMETHOD (EnabledSet) (THIS_ DWORD) PURE; + STDMETHOD (MicrophoneGet) (THIS_ PWSTR, DWORD, DWORD *) PURE; + STDMETHOD (MicrophoneSet) (THIS_ PCWSTR) PURE; + STDMETHOD (SpeakerGet) (THIS_ PWSTR, DWORD, DWORD *) PURE; + STDMETHOD (SpeakerSet) (THIS_ PCWSTR) PURE; + STDMETHOD (SRModeGet) (THIS_ GUID *) PURE; + STDMETHOD (SRModeSet) (THIS_ GUID) PURE; +}; + +typedef IVCmdAttributesW FAR * PIVCMDATTRIBUTESW; + + +#undef INTERFACE +#define INTERFACE IVCmdAttributesA + +// {FFF5DF80-5544-11b9-C000-5611722E1D15} +DEFINE_GUID(IID_IVCmdAttributesA, 0xfff5df80, 0x5544, 0x11b9, 0xc0, 0x0, 0x56, 0x11, 0x72, 0x2e, 0x1d, 0x15); + +DECLARE_INTERFACE_ (IVCmdAttributesA, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVCmdAttributes members + STDMETHOD (AutoGainEnableGet) (THIS_ DWORD *) PURE; + STDMETHOD (AutoGainEnableSet) (THIS_ DWORD) PURE; + STDMETHOD (AwakeStateGet) (THIS_ DWORD *) PURE; + STDMETHOD (AwakeStateSet) (THIS_ DWORD) PURE; + STDMETHOD (ThresholdGet) (THIS_ DWORD *) PURE; + STDMETHOD (ThresholdSet) (THIS_ DWORD) PURE; + STDMETHOD (DeviceGet) (THIS_ DWORD *) PURE; + STDMETHOD (DeviceSet) (THIS_ DWORD) PURE; + STDMETHOD (EnabledGet) (THIS_ DWORD *) PURE; + STDMETHOD (EnabledSet) (THIS_ DWORD) PURE; + STDMETHOD (MicrophoneGet) (THIS_ PSTR, DWORD, DWORD *) PURE; + STDMETHOD (MicrophoneSet) (THIS_ PCSTR) PURE; + STDMETHOD (SpeakerGet) (THIS_ PSTR, DWORD, DWORD *) PURE; + STDMETHOD (SpeakerSet) (THIS_ PCSTR) PURE; + STDMETHOD (SRModeGet) (THIS_ GUID *) PURE; + STDMETHOD (SRModeSet) (THIS_ GUID) PURE; +}; + +typedef IVCmdAttributesA FAR * PIVCMDATTRIBUTESA; + + +#ifdef _S_UNICODE + #define IVCmdAttributes IVCmdAttributesW + #define IID_IVCmdAttributes IID_IVCmdAttributesW + #define PIVCMDATTRIBUTES PIVCMDATTRIBUTESW + +#else + #define IVCmdAttributes IVCmdAttributesA + #define IID_IVCmdAttributes IID_IVCmdAttributesA + #define PIVCMDATTRIBUTES PIVCMDATTRIBUTESA + +#endif // _S_UNICODE + + + +/* + * IVCmdDialog + */ +#undef INTERFACE +#define INTERFACE IVCmdDialogsW + +DEFINE_GUID(IID_IVCmdDialogsW, 0xEE39B8A0L, 0x6053, 0x101B, 0x99, 0x26, 0x00, 0xAA, 0x00, 0x3C, 0xFC, 0x2C); + +DECLARE_INTERFACE_ (IVCmdDialogsW, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVCmdDialogs members + STDMETHOD (AboutDlg) (THIS_ HWND, PCWSTR) PURE; + STDMETHOD (GeneralDlg) (THIS_ HWND, PCWSTR) PURE; + STDMETHOD (LexiconDlg) (THIS_ HWND, PCWSTR) PURE; + STDMETHOD (TrainGeneralDlg) (THIS_ HWND, PCWSTR) PURE; + STDMETHOD (TrainMicDlg) (THIS_ HWND, PCWSTR) PURE; +}; + +typedef IVCmdDialogsW FAR * PIVCMDDIALOGSW; + + +#undef INTERFACE +#define INTERFACE IVCmdDialogsA + +// {AA8FE260-5545-11b9-C000-5611722E1D15} +DEFINE_GUID(IID_IVCmdDialogsA, 0xaa8fe260, 0x5545, 0x11b9, 0xc0, 0x0, 0x56, 0x11, 0x72, 0x2e, 0x1d, 0x15); + +DECLARE_INTERFACE_ (IVCmdDialogsA, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVCmdDialogs members + STDMETHOD (AboutDlg) (THIS_ HWND, PCSTR) PURE; + STDMETHOD (GeneralDlg) (THIS_ HWND, PCSTR) PURE; + STDMETHOD (LexiconDlg) (THIS_ HWND, PCSTR) PURE; + STDMETHOD (TrainGeneralDlg) (THIS_ HWND, PCSTR) PURE; + STDMETHOD (TrainMicDlg) (THIS_ HWND, PCSTR) PURE; +}; + +typedef IVCmdDialogsA FAR * PIVCMDDIALOGSA; + + +#ifdef _S_UNICODE + #define IVCmdDialogs IVCmdDialogsW + #define IID_IVCmdDialogs IID_IVCmdDialogsW + #define PIVCMDDIALOGS PIVCMDDIALOGSW + +#else + #define IVCmdDialogs IVCmdDialogsA + #define IID_IVCmdDialogs IID_IVCmdDialogsA + #define PIVCMDDIALOGS PIVCMDDIALOGSA + +#endif // _S_UNICODE + + + +/************************************************************************ +class guids */ + +// DEFINE_GUID(CLSID_VCmd, 0x93898800L, 0x604D, 0x101B, 0x99, 0x26, 0x00, 0xAA, 0x00, 0x3C, 0xFC, 0x2C); +// {6D40D820-0BA7-11ce-A166-00AA004CD65C} +DEFINE_GUID(CLSID_VCmd, +0x6d40d820, 0xba7, 0x11ce, 0xa1, 0x66, 0x0, 0xaa, 0x0, 0x4c, 0xd6, 0x5c); +// {89F70C30-8636-11ce-B763-00AA004CD65C} +DEFINE_GUID(CLSID_SRShare, +0x89f70c30, 0x8636, 0x11ce, 0xb7, 0x63, 0x0, 0xaa, 0x0, 0x4c, 0xd6, 0x5c); + + + +/************************************************************************ +High-Level dictation speech recognition API +*/ + +/************************************************************************ +defines */ +#define VDCT_TOPICNAMELEN 32 + +// bit flags for the dwReason field of IVDctNotifySink::TextChanged +#define VDCT_TEXTADDED 0x00000001 +#define VDCT_TEXTREMOVED 0x00000002 +#define VDCT_TEXTREPLACED 0x00000004 + +// bit flags for the dwReason field of IVDctText::TextRemove/TextSet +#define VDCT_TEXTCLEAN 0x00010000 +#define VDCT_TEXTKEEPRESULTS 0x00020000 + +// bit flags for dwFlags of IVDctGUI::FlagsSet +#define VDCTGUIF_VISIBLE 0x00000001 +#define VDCTGUIF_DONTMOVE 0x00000002 +#define VDCTGUIF_ADDWORD 0x00000004 + +// bit flags for dwFX of IVDctText::FX +#define VDCTFX_CAPFIRST 0x00000001 +#define VDCTFX_LOWERFIRST 0x00000002 +#define VDCTFX_TOGGLEFIRST 0x00000003 +#define VDCTFX_CAPALL 0x00000004 +#define VDCTFX_LOWERALL 0x00000005 +#define VDCTFX_REMOVESPACES 0x00000006 +#define VDCTFX_KEEPONLYFIRSTLETTER 0x00000007 + +/************************************************************************ +typedefs */ + +// site information structure - used for IVoiceDictation::SiteInfoGet/Set +typedef struct { + DWORD dwAutoGainEnable; + DWORD dwAwakeState; + DWORD dwThreshold; + DWORD dwDevice; + DWORD dwEnable; + WCHAR szMicrophone[VCMD_MICLEN]; + WCHAR szSpeaker[VCMD_SPEAKERLEN]; + GUID gModeID; +} VDSITEINFOW, *PVDSITEINFOW; + +typedef struct { + DWORD dwAutoGainEnable; + DWORD dwAwakeState; + DWORD dwThreshold; + DWORD dwDevice; + DWORD dwEnable; + CHAR szMicrophone[VCMD_MICLEN]; + CHAR szSpeaker[VCMD_SPEAKERLEN]; + GUID gModeID; +} VDSITEINFOA, *PVDSITEINFOA; + + +// topic structure used by the IVoiceDictation object +typedef struct { + WCHAR szTopic[VDCT_TOPICNAMELEN]; + LANGUAGEW language; +} VDCTTOPICW, *PVDCTTOPICW; + +typedef struct { + CHAR szTopic[VDCT_TOPICNAMELEN]; + LANGUAGEA language; +} VDCTTOPICA, *PVDCTTOPICA; + + +#ifdef _S_UNICODE + #define VDSITEINFO VDSITEINFOW + #define PVDSITEINFO PVDSITEINFOW + #define VDCTTOPIC VDCTTOPICW + #define PVDCTTOPIC PVDCTTOPICW +#else + #define VDSITEINFO VDSITEINFOA + #define PVDSITEINFO PVDSITEINFOA + #define VDCTTOPIC VDCTTOPICA + #define PVDCTTOPIC PVDCTTOPICA +#endif // _S_UNICODE + + +// memory maintenance structure used by MemoryGet/Set in IVDctAttributes +typedef struct { + DWORD dwMaxRAM; + DWORD dwMaxTime; + DWORD dwMaxWords; + BOOL fKeepAudio; + BOOL fKeepCorrection; + BOOL fKeepEval; +} VDCTMEMORY, *PVDCTMEMORY; + + +// bookmark definition +typedef struct { + DWORD dwID; + DWORD dwPosn; +} VDCTBOOKMARK, *PVDCTBOOKMARK; + + + +/************************************************************************ +interfaces */ + +/* + * IVDctNotifySink + */ +#undef INTERFACE +#define INTERFACE IVDctNotifySinkW + +// {5FEB8800-67D5-11cf-9B8B-08005AFC3A41} +DEFINE_GUID(IID_IVDctNotifySinkW, +0x5feb8800, 0x67d5, 0x11cf, 0x9b, 0x8b, 0x8, 0x0, 0x5a, 0xfc, 0x3a, 0x41); + +DECLARE_INTERFACE_ (IVDctNotifySinkW, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVDctNotifySink members + STDMETHOD (CommandBuiltIn) (THIS_ PWSTR) PURE; + STDMETHOD (CommandOther) (THIS_ PWSTR) PURE; + STDMETHOD (CommandRecognize) (THIS_ DWORD, DWORD, DWORD, PVOID, PWSTR) PURE; + STDMETHOD (TextSelChanged) (THIS) PURE; + STDMETHOD (TextChanged) (THIS_ DWORD) PURE; + STDMETHOD (TextBookmarkChanged) (THIS_ DWORD) PURE; + STDMETHOD (PhraseStart) (THIS) PURE; + STDMETHOD (PhraseFinish) (THIS_ DWORD, PSRPHRASEW) PURE; + STDMETHOD (PhraseHypothesis) (THIS_ DWORD, PSRPHRASEW) PURE; + STDMETHOD (UtteranceBegin) (THIS) PURE; + STDMETHOD (UtteranceEnd) (THIS) PURE; + STDMETHOD (VUMeter) (THIS_ WORD) PURE; + STDMETHOD (AttribChanged) (THIS_ DWORD) PURE; + STDMETHOD (Interference) (THIS_ DWORD) PURE; + STDMETHOD (Training) (THIS_ DWORD) PURE; + STDMETHOD (Dictating) (THIS_ PCWSTR, BOOL) PURE; +}; + +typedef IVDctNotifySinkW FAR * PIVDCTNOTIFYSINKW; + + +#undef INTERFACE +#define INTERFACE IVDctNotifySinkA + +// {88AD7DC0-67D5-11cf-9B8B-08005AFC3A41} +DEFINE_GUID(IID_IVDctNotifySinkA, +0x88ad7dc0, 0x67d5, 0x11cf, 0x9b, 0x8b, 0x8, 0x0, 0x5a, 0xfc, 0x3a, 0x41); + +DECLARE_INTERFACE_ (IVDctNotifySinkA, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVDctNotifySinkA members + STDMETHOD (CommandBuiltIn) (THIS_ PSTR) PURE; + STDMETHOD (CommandOther) (THIS_ PSTR) PURE; + STDMETHOD (CommandRecognize) (THIS_ DWORD, DWORD, DWORD, PVOID, PSTR) PURE; + STDMETHOD (TextSelChanged) (THIS) PURE; + STDMETHOD (TextChanged) (THIS_ DWORD) PURE; + STDMETHOD (TextBookmarkChanged) (THIS_ DWORD) PURE; + STDMETHOD (PhraseStart) (THIS) PURE; + STDMETHOD (PhraseFinish) (THIS_ DWORD, PSRPHRASEA) PURE; + STDMETHOD (PhraseHypothesis) (THIS_ DWORD, PSRPHRASEA) PURE; + STDMETHOD (UtteranceBegin) (THIS) PURE; + STDMETHOD (UtteranceEnd) (THIS) PURE; + STDMETHOD (VUMeter) (THIS_ WORD) PURE; + STDMETHOD (AttribChanged) (THIS_ DWORD) PURE; + STDMETHOD (Interference) (THIS_ DWORD) PURE; + STDMETHOD (Training) (THIS_ DWORD) PURE; + STDMETHOD (Dictating) (THIS_ PCSTR, BOOL) PURE; +}; + +typedef IVDctNotifySinkA FAR * PIVDCTNOTIFYSINKA; + + +#ifdef _S_UNICODE + #define IVDctNotifySink IVDctNotifySinkW + #define IID_IVDctNotifySink IID_IVDctNotifySinkW + #define PIVDCTNOTIFYSINK PIVDCTNOTIFYSINKW + +#else + #define IVDctNotifySink IVDctNotifySinkA + #define IID_IVDctNotifySink IID_IVDctNotifySinkA + #define PIVDCTNOTIFYSINK PIVDCTNOTIFYSINKA + +#endif // _S_UNICODE + + + + +/* + * IVDctNotifySink2 + */ +#undef INTERFACE +#define INTERFACE IVDctNotifySink2W + +// {599F77E3-E42E-11d1-BED8-006008317CE8} +DEFINE_GUID(IID_IVDctNotifySink2W, +0x599f77e3, 0xe42e, 0x11d1, 0xbe, 0xd8, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +DECLARE_INTERFACE_ (IVDctNotifySink2W, IVDctNotifySinkW) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVDctNotifySink2 members + STDMETHOD (CommandBuiltIn) (THIS_ PWSTR) PURE; + STDMETHOD (CommandOther) (THIS_ PWSTR) PURE; + STDMETHOD (CommandRecognize) (THIS_ DWORD, DWORD, DWORD, PVOID, PWSTR) PURE; + STDMETHOD (TextSelChanged) (THIS) PURE; + STDMETHOD (TextChanged) (THIS_ DWORD) PURE; + STDMETHOD (TextBookmarkChanged) (THIS_ DWORD) PURE; + STDMETHOD (PhraseStart) (THIS) PURE; + STDMETHOD (PhraseFinish) (THIS_ DWORD, PSRPHRASEW) PURE; + STDMETHOD (PhraseHypothesis) (THIS_ DWORD, PSRPHRASEW) PURE; + STDMETHOD (UtteranceBegin) (THIS) PURE; + STDMETHOD (UtteranceEnd) (THIS) PURE; + STDMETHOD (VUMeter) (THIS_ WORD) PURE; + STDMETHOD (AttribChanged) (THIS_ DWORD) PURE; + STDMETHOD (Interference) (THIS_ DWORD) PURE; + STDMETHOD (Training) (THIS_ DWORD) PURE; + STDMETHOD (Dictating) (THIS_ PCWSTR, BOOL) PURE; + + STDMETHOD (Error) (THIS_ LPUNKNOWN) PURE; + STDMETHOD (Warning) (THIS_ LPUNKNOWN) PURE; +}; + +typedef IVDctNotifySink2W FAR * PIVDCTNOTIFYSINK2W; + + +#undef INTERFACE +#define INTERFACE IVDctNotifySink2A + +// {599F77E4-E42E-11d1-BED8-006008317CE8} +DEFINE_GUID(IID_IVDctNotifySink2A, +0x599f77e4, 0xe42e, 0x11d1, 0xbe, 0xd8, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +DECLARE_INTERFACE_ (IVDctNotifySink2A, IVDctNotifySinkA) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVDctNotifySink2A members + STDMETHOD (CommandBuiltIn) (THIS_ PSTR) PURE; + STDMETHOD (CommandOther) (THIS_ PSTR) PURE; + STDMETHOD (CommandRecognize) (THIS_ DWORD, DWORD, DWORD, PVOID, PSTR) PURE; + STDMETHOD (TextSelChanged) (THIS) PURE; + STDMETHOD (TextChanged) (THIS_ DWORD) PURE; + STDMETHOD (TextBookmarkChanged) (THIS_ DWORD) PURE; + STDMETHOD (PhraseStart) (THIS) PURE; + STDMETHOD (PhraseFinish) (THIS_ DWORD, PSRPHRASEA) PURE; + STDMETHOD (PhraseHypothesis) (THIS_ DWORD, PSRPHRASEA) PURE; + STDMETHOD (UtteranceBegin) (THIS) PURE; + STDMETHOD (UtteranceEnd) (THIS) PURE; + STDMETHOD (VUMeter) (THIS_ WORD) PURE; + STDMETHOD (AttribChanged) (THIS_ DWORD) PURE; + STDMETHOD (Interference) (THIS_ DWORD) PURE; + STDMETHOD (Training) (THIS_ DWORD) PURE; + STDMETHOD (Dictating) (THIS_ PCSTR, BOOL) PURE; + + STDMETHOD (Error) (THIS_ LPUNKNOWN) PURE; + STDMETHOD (Warning) (THIS_ LPUNKNOWN) PURE; +}; + +typedef IVDctNotifySink2A FAR * PIVDCTNOTIFYSINK2A; + + +#ifdef _S_UNICODE + #define IVDctNotifySink2 IVDctNotifySink2W + #define IID_IVDctNotifySink2 IID_IVDctNotifySink2W + #define PIVDCTNOTIFYSINK2 PIVDCTNOTIFYSINK2W + +#else + #define IVDctNotifySink2 IVDctNotifySink2A + #define IID_IVDctNotifySink2 IID_IVDctNotifySink2A + #define PIVDCTNOTIFYSINK2 PIVDCTNOTIFYSINK2A + +#endif // _S_UNICODE + + + +/* + * IVoiceDictation + */ +#undef INTERFACE +#define INTERFACE IVoiceDictationW + +// {88AD7DC3-67D5-11cf-9B8B-08005AFC3A41} +DEFINE_GUID(IID_IVoiceDictationW, +0x88ad7dc3, 0x67d5, 0x11cf, 0x9b, 0x8b, 0x8, 0x0, 0x5a, 0xfc, 0x3a, 0x41); + +DECLARE_INTERFACE_ (IVoiceDictationW, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVoiceDictation members + STDMETHOD (Register) (THIS_ PCWSTR, PCWSTR, LPSTORAGE, PCWSTR, + PIVDCTNOTIFYSINK, GUID, DWORD) PURE; + STDMETHOD (SiteInfoGet) (THIS_ PCWSTR, PVDSITEINFOW) PURE; + STDMETHOD (SiteInfoSet) (THIS_ PCWSTR, PVDSITEINFOW) PURE; + STDMETHOD (SessionSerialize) (THIS_ LPSTORAGE) PURE; + STDMETHOD (SessionDeserialize) (THIS_ LPSTORAGE) PURE; + STDMETHOD (TopicEnum) (THIS_ PSDATA) PURE; + STDMETHOD (TopicAddString) (THIS_ PCWSTR, LANGUAGEW *) PURE; + STDMETHOD (TopicRemove) (THIS_ PCWSTR) PURE; + STDMETHOD (TopicSerialize) (THIS_ LPSTORAGE) PURE; + STDMETHOD (TopicDeserialize) (THIS_ LPSTORAGE) PURE; + STDMETHOD (Activate) (THIS_ HWND) PURE; + STDMETHOD (Deactivate) (THIS) PURE; + STDMETHOD (TopicAddGrammar) (THIS_ PCWSTR, SDATA) PURE; + STDMETHOD (CFGSet) (THIS_ LANGID, PCWSTR, PCWSTR) PURE; +}; + +typedef IVoiceDictationW FAR * PIVOICEDICTATIONW; + + +#undef INTERFACE +#define INTERFACE IVoiceDictationA + +// {88AD7DC4-67D5-11cf-9B8B-08005AFC3A41} +DEFINE_GUID(IID_IVoiceDictationA, +0x88ad7dc4, 0x67d5, 0x11cf, 0x9b, 0x8b, 0x8, 0x0, 0x5a, 0xfc, 0x3a, 0x41); + +DECLARE_INTERFACE_ (IVoiceDictationA, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVoiceDictation members + STDMETHOD (Register) (THIS_ PCSTR, PCSTR, LPSTORAGE, PCSTR, + PIVDCTNOTIFYSINK, GUID, DWORD) PURE; + STDMETHOD (SiteInfoGet) (THIS_ PCSTR, PVDSITEINFOA) PURE; + STDMETHOD (SiteInfoSet) (THIS_ PCSTR, PVDSITEINFOA) PURE; + STDMETHOD (SessionSerialize) (THIS_ LPSTORAGE) PURE; + STDMETHOD (SessionDeserialize) (THIS_ LPSTORAGE) PURE; + STDMETHOD (TopicEnum) (THIS_ PSDATA) PURE; + STDMETHOD (TopicAddString) (THIS_ PCSTR, LANGUAGEA *) PURE; + STDMETHOD (TopicRemove) (THIS_ PCSTR) PURE; + STDMETHOD (TopicSerialize) (THIS_ LPSTORAGE) PURE; + STDMETHOD (TopicDeserialize) (THIS_ LPSTORAGE) PURE; + STDMETHOD (Activate) (THIS_ HWND) PURE; + STDMETHOD (Deactivate) (THIS) PURE; + STDMETHOD (TopicAddGrammar) (THIS_ PCSTR, SDATA) PURE; + STDMETHOD (CFGSet) (THIS_ LANGID, PCSTR, PCSTR) PURE; +}; + +typedef IVoiceDictationA FAR * PIVOICEDICTATIONA; + + +#ifdef _S_UNICODE + #define IVoiceDictation IVoiceDictationW + #define IID_IVoiceDictation IID_IVoiceDictationW + #define PIVOICEDICTATION PIVOICEDICTATIONW + +#else + #define IVoiceDictation IVoiceDictationA + #define IID_IVoiceDictation IID_IVoiceDictationA + #define PIVOICEDICTATION PIVOICEDICTATIONA + +#endif //_S_UNICODE + + + +/* + * IVDctText + */ +#undef INTERFACE +#define INTERFACE IVDctTextW + +// {6D62B3A0-6893-11cf-9B8B-08005AFC3A41} +DEFINE_GUID(IID_IVDctTextW, +0x6d62b3a0, 0x6893, 0x11cf, 0x9b, 0x8b, 0x8, 0x0, 0x5a, 0xfc, 0x3a, 0x41); + +DECLARE_INTERFACE_ (IVDctTextW, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVDctText members + STDMETHOD (Lock) (THIS) PURE; + STDMETHOD (UnLock) (THIS) PURE; + STDMETHOD (TextGet) (THIS_ DWORD, DWORD, PSDATA) PURE; + STDMETHOD (TextSet) (THIS_ DWORD, DWORD, PCWSTR, DWORD) PURE; + STDMETHOD (TextMove) (THIS_ DWORD, DWORD, DWORD, DWORD) PURE; + STDMETHOD (TextRemove) (THIS_ DWORD, DWORD, DWORD) PURE; + STDMETHOD (TextSelSet) (THIS_ DWORD, DWORD) PURE; + STDMETHOD (TextSelGet) (THIS_ DWORD *, DWORD *) PURE; + STDMETHOD (TextLengthGet) (THIS_ DWORD *) PURE; + STDMETHOD (GetChanges) (THIS_ DWORD *, DWORD *, DWORD *, DWORD *) PURE; + STDMETHOD (BookmarkAdd) (THIS_ PVDCTBOOKMARK) PURE; + STDMETHOD (BookmarkRemove) (THIS_ DWORD) PURE; + STDMETHOD (BookmarkMove) (THIS_ DWORD, DWORD) PURE; + STDMETHOD (BookmarkQuery) (THIS_ DWORD, PVDCTBOOKMARK) PURE; + STDMETHOD (BookmarkEnum) (THIS_ DWORD, DWORD, PVDCTBOOKMARK *, + DWORD *) PURE; + STDMETHOD (Hint) (THIS_ PCWSTR) PURE; + STDMETHOD (Words) (THIS_ PCWSTR) PURE; + STDMETHOD (ResultsGet) (THIS_ DWORD, DWORD, DWORD *, DWORD *, + LPUNKNOWN *) PURE; + STDMETHOD (FX) (THIS_ DWORD) PURE; +}; +typedef IVDctTextW FAR * PIVDCTTEXTW; + + +#undef INTERFACE +#define INTERFACE IVDctTextA + +// {6D62B3A1-6893-11cf-9B8B-08005AFC3A41} +DEFINE_GUID(IID_IVDctTextA, +0x6d62b3a1, 0x6893, 0x11cf, 0x9b, 0x8b, 0x8, 0x0, 0x5a, 0xfc, 0x3a, 0x41); + +DECLARE_INTERFACE_ (IVDctTextA, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVDctText members + STDMETHOD (Lock) (THIS) PURE; + STDMETHOD (UnLock) (THIS) PURE; + STDMETHOD (TextGet) (THIS_ DWORD, DWORD, PSDATA) PURE; + STDMETHOD (TextSet) (THIS_ DWORD, DWORD, PCSTR, DWORD) PURE; + STDMETHOD (TextMove) (THIS_ DWORD, DWORD, DWORD, DWORD) PURE; + STDMETHOD (TextRemove) (THIS_ DWORD, DWORD, DWORD) PURE; + STDMETHOD (TextSelSet) (THIS_ DWORD, DWORD) PURE; + STDMETHOD (TextSelGet) (THIS_ DWORD *, DWORD *) PURE; + STDMETHOD (TextLengthGet) (THIS_ DWORD *) PURE; + STDMETHOD (GetChanges) (THIS_ DWORD *, DWORD *, DWORD *, DWORD *) PURE; + STDMETHOD (BookmarkAdd) (THIS_ PVDCTBOOKMARK) PURE; + STDMETHOD (BookmarkRemove) (THIS_ DWORD) PURE; + STDMETHOD (BookmarkMove) (THIS_ DWORD, DWORD) PURE; + STDMETHOD (BookmarkQuery) (THIS_ DWORD, PVDCTBOOKMARK) PURE; + STDMETHOD (BookmarkEnum) (THIS_ DWORD, DWORD, PVDCTBOOKMARK *, + DWORD *) PURE; + STDMETHOD (Hint) (THIS_ PCSTR) PURE; + STDMETHOD (Words) (THIS_ PCSTR) PURE; + STDMETHOD (ResultsGet) (THIS_ DWORD, DWORD, DWORD *, DWORD *, + LPUNKNOWN *) PURE; + STDMETHOD (FX) (THIS_ DWORD) PURE; +}; +typedef IVDctTextA FAR * PIVDCTTEXTA; + + +#ifdef _S_UNICODE + #define IVDctText IVDctTextW + #define IID_IVDctText IID_IVDctTextW + #define PIVDCTTEXT PIVDCTTEXTW + +#else + #define IVDctText IVDctTextA + #define IID_IVDctText IID_IVDctTextA + #define PIVDCTTEXT PIVDCTTEXTA + +#endif //_S_UNICODE + + + +/* + * IVDctText2 + */ +#undef INTERFACE +#define INTERFACE IVDctText2W + +// {238004E1-F0C4-11d1-BED9-006008317CE8} +DEFINE_GUID(IID_IVDctText2W, +0x238004e1, 0xf0c4, 0x11d1, 0xbe, 0xd9, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +DECLARE_INTERFACE_ (IVDctText2W, IVDctTextW) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVDctText members + STDMETHOD (Lock) (THIS) PURE; + STDMETHOD (UnLock) (THIS) PURE; + STDMETHOD (TextGet) (THIS_ DWORD, DWORD, PSDATA) PURE; + STDMETHOD (TextSet) (THIS_ DWORD, DWORD, PCWSTR, DWORD) PURE; + STDMETHOD (TextMove) (THIS_ DWORD, DWORD, DWORD, DWORD) PURE; + STDMETHOD (TextRemove) (THIS_ DWORD, DWORD, DWORD) PURE; + STDMETHOD (TextSelSet) (THIS_ DWORD, DWORD) PURE; + STDMETHOD (TextSelGet) (THIS_ DWORD *, DWORD *) PURE; + STDMETHOD (TextLengthGet) (THIS_ DWORD *) PURE; + STDMETHOD (GetChanges) (THIS_ DWORD *, DWORD *, DWORD *, DWORD *) PURE; + STDMETHOD (BookmarkAdd) (THIS_ PVDCTBOOKMARK) PURE; + STDMETHOD (BookmarkRemove) (THIS_ DWORD) PURE; + STDMETHOD (BookmarkMove) (THIS_ DWORD, DWORD) PURE; + STDMETHOD (BookmarkQuery) (THIS_ DWORD, PVDCTBOOKMARK) PURE; + STDMETHOD (BookmarkEnum) (THIS_ DWORD, DWORD, PVDCTBOOKMARK *, + DWORD *) PURE; + STDMETHOD (Hint) (THIS_ PCWSTR) PURE; + STDMETHOD (Words) (THIS_ PCWSTR) PURE; + STDMETHOD (ResultsGet) (THIS_ DWORD, DWORD, DWORD *, DWORD *, + LPUNKNOWN *) PURE; + STDMETHOD (FX) (THIS_ DWORD) PURE; + + // IVDctText2 + STDMETHOD (ITNApply) (THIS_ DWORD, DWORD) PURE; + STDMETHOD (ITNExpand) (THIS_ DWORD, DWORD) PURE; + STDMETHOD (ResultsGet2) (THIS_ DWORD, DWORD, DWORD *, DWORD *, + LPUNKNOWN *, DWORD*, DWORD*) PURE; + STDMETHOD (ResultsSet) (THIS_ DWORD, DWORD, + LPUNKNOWN, DWORD, DWORD) PURE; + +}; +typedef IVDctText2W FAR * PIVDCTTEXT2W; + + +#undef INTERFACE +#define INTERFACE IVDctText2A + +// {238004E2-F0C4-11d1-BED9-006008317CE8} +DEFINE_GUID(IID_IVDctText2A, +0x238004e2, 0xf0c4, 0x11d1, 0xbe, 0xd9, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +DECLARE_INTERFACE_ (IVDctText2A, IVDctTextA) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVDctText members + STDMETHOD (Lock) (THIS) PURE; + STDMETHOD (UnLock) (THIS) PURE; + STDMETHOD (TextGet) (THIS_ DWORD, DWORD, PSDATA) PURE; + STDMETHOD (TextSet) (THIS_ DWORD, DWORD, PCSTR, DWORD) PURE; + STDMETHOD (TextMove) (THIS_ DWORD, DWORD, DWORD, DWORD) PURE; + STDMETHOD (TextRemove) (THIS_ DWORD, DWORD, DWORD) PURE; + STDMETHOD (TextSelSet) (THIS_ DWORD, DWORD) PURE; + STDMETHOD (TextSelGet) (THIS_ DWORD *, DWORD *) PURE; + STDMETHOD (TextLengthGet) (THIS_ DWORD *) PURE; + STDMETHOD (GetChanges) (THIS_ DWORD *, DWORD *, DWORD *, DWORD *) PURE; + STDMETHOD (BookmarkAdd) (THIS_ PVDCTBOOKMARK) PURE; + STDMETHOD (BookmarkRemove) (THIS_ DWORD) PURE; + STDMETHOD (BookmarkMove) (THIS_ DWORD, DWORD) PURE; + STDMETHOD (BookmarkQuery) (THIS_ DWORD, PVDCTBOOKMARK) PURE; + STDMETHOD (BookmarkEnum) (THIS_ DWORD, DWORD, PVDCTBOOKMARK *, + DWORD *) PURE; + STDMETHOD (Hint) (THIS_ PCSTR) PURE; + STDMETHOD (Words) (THIS_ PCSTR) PURE; + STDMETHOD (ResultsGet) (THIS_ DWORD, DWORD, DWORD *, DWORD *, + LPUNKNOWN *) PURE; + STDMETHOD (FX) (THIS_ DWORD) PURE; + + // IVDctText2 + STDMETHOD (ITNApply) (THIS_ DWORD, DWORD) PURE; + STDMETHOD (ITNExpand) (THIS_ DWORD, DWORD) PURE; + STDMETHOD (ResultsGet2) (THIS_ DWORD, DWORD, DWORD *, DWORD *, + LPUNKNOWN *, DWORD*, DWORD*) PURE; + STDMETHOD (ResultsSet) (THIS_ DWORD, DWORD, + LPUNKNOWN, DWORD, DWORD) PURE; +}; +typedef IVDctText2A FAR * PIVDCTTEXT2A; + + +#ifdef _S_UNICODE + #define IVDctText2 IVDctText2W + #define IID_IVDctText2 IID_IVDctText2W + #define PIVDCTTEXT2 PIVDCTTEXT2W + +#else + #define IVDctText2 IVDctText2A + #define IID_IVDctText2 IID_IVDctText2A + #define PIVDCTTEXT2 PIVDCTTEXT2A + +#endif //_S_UNICODE + + + + +/* + * IVDctTextCache + */ +#undef INTERFACE +#define INTERFACE IVDctTextCache + +// {238004E3-F0C4-11d1-BED9-006008317CE8} +DEFINE_GUID(IID_IVDctTextCache, +0x238004e3, 0xf0c4, 0x11d1, 0xbe, 0xd9, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +DECLARE_INTERFACE_ (IVDctTextCache, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVDctTextCache members + STDMETHOD (CopyToBin) (THIS_ DWORD, DWORD, DWORD) PURE; + STDMETHOD (CopyToMemory) (THIS_ DWORD, DWORD, PVOID*, DWORD*, LPUNKNOWN**, DWORD*) PURE; + STDMETHOD (PasteFromBin) (THIS_ DWORD, DWORD, DWORD) PURE; + STDMETHOD (PasteFromMemory) (THIS_ DWORD, DWORD, PVOID, DWORD, LPUNKNOWN*, DWORD) PURE; +}; +typedef IVDctTextCache FAR * PIVDCTTEXTCACHE; + + + +/* + * IVDctInvTextNorm + */ +#undef INTERFACE +#define INTERFACE IVDctInvTextNormW + +// {90A84EA0-6E51-11d0-9BC2-08005AFC3A41} +DEFINE_GUID(IID_IVDctInvTextNormW, +0x90a84ea0, 0x6e51, 0x11d0, 0x9b, 0xc2, 0x8, 0x0, 0x5a, 0xfc, 0x3a, 0x41); + +DECLARE_INTERFACE_ (IVDctInvTextNormW, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVDctInvTextNorm members + STDMETHOD (OptionsEnum) (THIS_ PWSTR *, DWORD *) PURE; + STDMETHOD (OptionsGet) (THIS_ PCWSTR, BOOL *) PURE; + STDMETHOD (OptionsSet) (THIS_ PCWSTR, BOOL) PURE; +}; + +typedef IVDctInvTextNormW FAR * PIVDCTINVTEXTNORMW; + + +#undef INTERFACE +#define INTERFACE IVDctInvTextNormA + +// {90A84EA1-6E51-11d0-9BC2-08005AFC3A41} +DEFINE_GUID(IID_IVDctInvTextNormA, +0x90a84ea1, 0x6e51, 0x11d0, 0x9b, 0xc2, 0x8, 0x0, 0x5a, 0xfc, 0x3a, 0x41); + +DECLARE_INTERFACE_ (IVDctInvTextNormA, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVDctInvTextNorm members + STDMETHOD (OptionsEnum) (THIS_ PSTR *, DWORD *) PURE; + STDMETHOD (OptionsGet) (THIS_ PCSTR, BOOL *) PURE; + STDMETHOD (OptionsSet) (THIS_ PCSTR, BOOL) PURE; +}; + +typedef IVDctInvTextNormA FAR * PIVDCTINVTEXTNORMA; + + +#ifdef _S_UNICODE + #define IVDctInvTextNorm IVDctInvTextNormW + #define IID_IVDctInvTextNorm IID_IVDctInvTextNormW + #define PIVDCTINVTEXTNORM PIVDCTINVTEXTNORMW + +#else + #define IVDctInvTextNorm IVDctInvTextNormA + #define IID_IVDctInvTextNorm IID_IVDctInvTextNormA + #define PIVDCTINVTEXTNORM PIVDCTINVTEXTNORMA + +#endif // _S_UNICODE + + + +/* + * IVDctAttributes + */ +#undef INTERFACE +#define INTERFACE IVDctAttributesW + +// {88AD7DC5-67D5-11cf-9B8B-08005AFC3A41} +DEFINE_GUID(IID_IVDctAttributesW, +0x88ad7dc5, 0x67d5, 0x11cf, 0x9b, 0x8b, 0x8, 0x0, 0x5a, 0xfc, 0x3a, 0x41); + +DECLARE_INTERFACE_ (IVDctAttributesW, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVDctAttributes members + STDMETHOD (AutoGainEnableGet) (THIS_ DWORD *) PURE; + STDMETHOD (AutoGainEnableSet) (THIS_ DWORD) PURE; + STDMETHOD (AwakeStateGet) (THIS_ DWORD *) PURE; + STDMETHOD (AwakeStateSet) (THIS_ DWORD) PURE; + STDMETHOD (ThresholdGet) (THIS_ DWORD *) PURE; + STDMETHOD (ThresholdSet) (THIS_ DWORD) PURE; + STDMETHOD (EchoGet) (THIS_ BOOL *) PURE; + STDMETHOD (EchoSet) (THIS_ BOOL) PURE; + STDMETHOD (EnergyFloorGet) (THIS_ WORD *) PURE; + STDMETHOD (EnergyFloorSet) (THIS_ WORD) PURE; + STDMETHOD (RealTimeGet) (THIS_ DWORD *) PURE; + STDMETHOD (RealTimeSet) (THIS_ DWORD) PURE; + STDMETHOD (TimeOutGet) (THIS_ DWORD *, DWORD *) PURE; + STDMETHOD (TimeOutSet) (THIS_ DWORD, DWORD) PURE; + STDMETHOD (ModeGet) (THIS_ DWORD *) PURE; + STDMETHOD (ModeSet) (THIS_ DWORD) PURE; + STDMETHOD (MemoryGet) (THIS_ VDCTMEMORY *) PURE; + STDMETHOD (MemorySet) (THIS_ VDCTMEMORY *) PURE; + STDMETHOD (IsAnyoneDictating) (THIS_ HWND, PWSTR, DWORD, DWORD *) PURE; + STDMETHOD (MicrophoneGet) (THIS_ PWSTR, DWORD, DWORD *) PURE; + STDMETHOD (MicrophoneSet) (THIS_ PCWSTR) PURE; + STDMETHOD (SpeakerGet) (THIS_ PWSTR, DWORD, DWORD *) PURE; + STDMETHOD (SpeakerSet) (THIS_ PCWSTR) PURE; +}; + +typedef IVDctAttributesW FAR * PIVDCTATTRIBUTESW; + + +#undef INTERFACE +#define INTERFACE IVDctAttributesA + +// {88AD7DC6-67D5-11cf-9B8B-08005AFC3A41} +DEFINE_GUID(IID_IVDctAttributesA, +0x88ad7dc6, 0x67d5, 0x11cf, 0x9b, 0x8b, 0x8, 0x0, 0x5a, 0xfc, 0x3a, 0x41); + +DECLARE_INTERFACE_ (IVDctAttributesA, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVDctAttributes members + STDMETHOD (AutoGainEnableGet) (THIS_ DWORD *) PURE; + STDMETHOD (AutoGainEnableSet) (THIS_ DWORD) PURE; + STDMETHOD (AwakeStateGet) (THIS_ DWORD *) PURE; + STDMETHOD (AwakeStateSet) (THIS_ DWORD) PURE; + STDMETHOD (ThresholdGet) (THIS_ DWORD *) PURE; + STDMETHOD (ThresholdSet) (THIS_ DWORD) PURE; + STDMETHOD (EchoGet) (THIS_ BOOL *) PURE; + STDMETHOD (EchoSet) (THIS_ BOOL) PURE; + STDMETHOD (EnergyFloorGet) (THIS_ WORD *) PURE; + STDMETHOD (EnergyFloorSet) (THIS_ WORD) PURE; + STDMETHOD (RealTimeGet) (THIS_ DWORD *) PURE; + STDMETHOD (RealTimeSet) (THIS_ DWORD) PURE; + STDMETHOD (TimeOutGet) (THIS_ DWORD *, DWORD *) PURE; + STDMETHOD (TimeOutSet) (THIS_ DWORD, DWORD) PURE; + STDMETHOD (ModeGet) (THIS_ DWORD *) PURE; + STDMETHOD (ModeSet) (THIS_ DWORD) PURE; + STDMETHOD (MemoryGet) (THIS_ VDCTMEMORY *) PURE; + STDMETHOD (MemorySet) (THIS_ VDCTMEMORY *) PURE; + STDMETHOD (IsAnyoneDictating) (THIS_ HWND, PSTR, DWORD, DWORD *) PURE; + STDMETHOD (MicrophoneGet) (THIS_ PSTR, DWORD, DWORD *) PURE; + STDMETHOD (MicrophoneSet) (THIS_ PCSTR) PURE; + STDMETHOD (SpeakerGet) (THIS_ PSTR, DWORD, DWORD *) PURE; + STDMETHOD (SpeakerSet) (THIS_ PCSTR) PURE; +}; + +typedef IVDctAttributesA FAR * PIVDCTATTRIBUTESA; + + +#ifdef _S_UNICODE + #define IVDctAttributes IVDctAttributesW + #define IID_IVDctAttributes IID_IVDctAttributesW + #define PIVDCTATTRIBUTES PIVDCTATTRIBUTESW + +#else + #define IVDctAttributes IVDctAttributesA + #define IID_IVDctAttributes IID_IVDctAttributesA + #define PIVDCTATTRIBUTES PIVDCTATTRIBUTESA + +#endif // _S_UNICODE + + + + +/* + * IVDctCommandsBuiltInW Interface + */ +// {D4E3F8E0-6521-11d1-8C35-006097DF5D01} +DEFINE_GUID(IID_IVDctCommandsBuiltInW, +0xd4e3f8e0, 0x6521, 0x11d1, 0x8c, 0x35, 0x0, 0x60, 0x97, 0xdf, 0x5d, 0x1); + +// {8763AFD1-7ADE-11d1-BEA7-006008317CE8} +DEFINE_GUID(IID_IVDctCommandsBuiltInA, +0x8763afd1, 0x7ade, 0x11d1, 0xbe, 0xa7, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +#undef INTERFACE +#define INTERFACE IVDctCommandsBuiltInW + +DECLARE_INTERFACE_ (IVDctCommandsBuiltInW, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVDctCommandsBuiltInW members + STDMETHOD (Activate) (THIS_ HWND, DWORD) PURE; + STDMETHOD (Deactivate) (THIS) PURE; + STDMETHOD (FromMemory) (THIS_ PVOID, DWORD) PURE; + STDMETHOD (FromFile) (THIS_ PCWSTR) PURE; + STDMETHOD (FromStream) (THIS_ IStream *) PURE; + STDMETHOD (ListSet) (THIS_ PCWSTR, PVOID, DWORD) PURE; + STDMETHOD (TextGet) (THIS_ LPWSTR*, DWORD*) PURE; + STDMETHOD (ToMemory) (THIS_ PVOID*, DWORD*) PURE; + STDMETHOD (ToFile) (THIS_ PCWSTR) PURE; + STDMETHOD (ToStream) (THIS_ IStream *) PURE; +}; + +typedef IVDctCommandsBuiltInW * PIVDCTCOMMANDSBUILTINW; + + +#undef INTERFACE +#define INTERFACE IVDctCommandsBuiltInA + +DECLARE_INTERFACE_ (IVDctCommandsBuiltInA, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVDctCommandsBuiltInA members + STDMETHOD (Activate) (THIS_ HWND, DWORD) PURE; + STDMETHOD (Deactivate) (THIS) PURE; + STDMETHOD (FromMemory) (THIS_ PVOID, DWORD) PURE; + STDMETHOD (FromFile) (THIS_ PCSTR) PURE; + STDMETHOD (FromStream) (THIS_ IStream *) PURE; + STDMETHOD (ListSet) (THIS_ PCSTR, PVOID, DWORD) PURE; + STDMETHOD (TextGet) (THIS_ LPSTR*, DWORD*) PURE; + STDMETHOD (ToMemory) (THIS_ PVOID*, DWORD*) PURE; + STDMETHOD (ToFile) (THIS_ PCSTR) PURE; + STDMETHOD (ToStream) (THIS_ IStream *) PURE; +}; + +typedef IVDctCommandsBuiltInA * PIVDCTCOMMANDSBUILTINA; + +#ifdef _S_UNICODE + #define IVDctCommandsBuiltIn IVDctCommandsBuiltInW + #define IID_IVDctCommandsBuiltIn IID_IVDctCommandsBuiltInW + #define PIVDCTCOMMANDSBUILTIN PIVDCTCOMMANDSBUILTINW + +#else + #define IVDctCommandsBuiltIn IVDctCommandsBuiltInA + #define IID_IVDctCommandsBuiltIn IID_IVDctCommandsBuiltInA + #define PIVDCTCOMMANDSBUILTIN PIVDCTCOMMANDSBUILTINA + +#endif // _S_UNICODE + + + +/* + * IVDctCommandsApp Interface + */ +// {D4E3F8E1-6521-11d1-8C35-006097DF5D01} +DEFINE_GUID(IID_IVDctCommandsAppW, +0xd4e3f8e1, 0x6521, 0x11d1, 0x8c, 0x35, 0x0, 0x60, 0x97, 0xdf, 0x5d, 0x1); + +// {8763AFD2-7ADE-11d1-BEA7-006008317CE8} +DEFINE_GUID(IID_IVDctCommandsAppA, +0x8763afd2, 0x7ade, 0x11d1, 0xbe, 0xa7, 0x0, 0x60, 0x8, 0x31, 0x7c, 0xe8); + +typedef IVDctCommandsBuiltInA IVDctCommandsAppA; +typedef IVDctCommandsAppA * PIVDCTCOMMANDSAPPA; +typedef IVDctCommandsBuiltInW IVDctCommandsAppW; +typedef IVDctCommandsAppW * PIVDCTCOMMANDSAPPW; + +#ifdef _S_UNICODE + #define IVDctCommandsApp IVDctCommandsAppW + #define IID_IVDctCommandsApp IID_IVDctCommandsAppW + #define PIVDCTCOMMANDSAPP PIVDCTCOMMANDSAPPW +#else + #define IVDctCommandsApp IVDctCommandsAppA + #define IID_IVDctCommandsApp IID_IVDctCommandsAppA + #define PIVDCTCOMMANDSAPP PIVDCTCOMMANDSAPPA +#endif // _S_UNICODE + + + +/* + * IVDctCommands + */ +#undef INTERFACE +#define INTERFACE IVDctCommandsW + +// {A02C2CA0-AE50-11cf-833A-00AA00A21A29} +DEFINE_GUID(IID_IVDctCommandsW, +0xA02C2CA0, 0xAE50, 0x11cf, 0x83, 0x3A, 0x00, 0xAA, 0x00, 0xA2, 0x1A, 0x29); + +DECLARE_INTERFACE_ (IVDctCommandsW, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVDctCommands members + STDMETHOD (Add) (THIS_ BOOL, DWORD, SDATA, DWORD *) PURE; + STDMETHOD (Remove) (THIS_ BOOL, DWORD, DWORD, DWORD) PURE; + STDMETHOD (Get) (THIS_ BOOL, DWORD, DWORD, DWORD, SDATA*, DWORD *) PURE; + STDMETHOD (Set) (THIS_ BOOL, DWORD, DWORD, DWORD, SDATA) PURE; + STDMETHOD (EnableItem) (THIS_ BOOL, DWORD, DWORD, DWORD) PURE; + STDMETHOD (Num) (THIS_ BOOL, DWORD *) PURE; +}; + +typedef IVDctCommandsW FAR * PIVDCTCOMMANDSW; + + +#undef INTERFACE +#define INTERFACE IVDctCommandsA + +// {A02C2CA1-AE50-11cf-833A-00AA00A21A29} +DEFINE_GUID(IID_IVDctCommandsA, +0xA02C2CA1, 0xAE50, 0x11cf, 0x83, 0x3A, 0x00, 0xAA, 0x00, 0xA2, 0x1A, 0x29); + +DECLARE_INTERFACE_ (IVDctCommandsA, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVDctCommands members + STDMETHOD (Add) (THIS_ BOOL, DWORD, SDATA, DWORD *) PURE; + STDMETHOD (Remove) (THIS_ BOOL, DWORD, DWORD, DWORD) PURE; + STDMETHOD (Get) (THIS_ BOOL, DWORD, DWORD, DWORD, SDATA*, DWORD *) PURE; + STDMETHOD (Set) (THIS_ BOOL, DWORD, DWORD, DWORD, SDATA) PURE; + STDMETHOD (EnableItem) (THIS_ BOOL, DWORD, DWORD, DWORD) PURE; + STDMETHOD (Num) (THIS_ BOOL, DWORD *) PURE; +}; + +typedef IVDctCommandsA FAR * PIVDCTCOMMANDSA; + + +#ifdef _S_UNICODE + #define IVDctCommands IVDctCommandsW + #define IID_IVDctCommands IID_IVDctCommandsW + #define PIVDCTCOMMANDS PIVDCTCOMMANDSW + +#else + #define IVDctCommands IVDctCommandsA + #define IID_IVDctCommands IID_IVDctCommandsA + #define PIVDCTCOMMANDS PIVDCTCOMMANDSA + +#endif // _S_UNICODE + + + +/* + * IVDctGlossary + */ +#undef INTERFACE +#define INTERFACE IVDctGlossaryW + +// {A02C2CA2-AE50-11cf-833A-00AA00A21A29} +DEFINE_GUID(IID_IVDctGlossaryW, +0xA02C2CA2, 0xAE50, 0x11cf, 0x83, 0x3A, 0x00, 0xAA, 0x00, 0xA2, 0x1A, 0x29); + +DECLARE_INTERFACE_ (IVDctGlossaryW, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVDctGlossary members + STDMETHOD (Add) (THIS_ BOOL, DWORD, SDATA, DWORD *) PURE; + STDMETHOD (Remove) (THIS_ BOOL, DWORD, DWORD, DWORD) PURE; + STDMETHOD (Get) (THIS_ BOOL, DWORD, DWORD, DWORD, SDATA*, DWORD *) PURE; + STDMETHOD (Set) (THIS_ BOOL, DWORD, DWORD, DWORD, SDATA) PURE; + STDMETHOD (EnableItem) (THIS_ BOOL, DWORD, DWORD, DWORD) PURE; + STDMETHOD (Num) (THIS_ BOOL, DWORD *) PURE; +}; + +typedef IVDctGlossaryW FAR * PIVDCTGLOSSARYW; + + +#undef INTERFACE +#define INTERFACE IVDctGlossaryA + +// {A02C2CA3-AE50-11cf-833A-00AA00A21A29} +DEFINE_GUID(IID_IVDctGlossaryA, +0xA02C2CA3, 0xAE50, 0x11cf, 0x83, 0x3A, 0x00, 0xAA, 0x00, 0xA2, 0x1A, 0x29); + +DECLARE_INTERFACE_ (IVDctGlossaryA, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVDctGlossary members + STDMETHOD (Add) (THIS_ BOOL, DWORD, SDATA, DWORD *) PURE; + STDMETHOD (Remove) (THIS_ BOOL, DWORD, DWORD, DWORD) PURE; + STDMETHOD (Get) (THIS_ BOOL, DWORD, DWORD, DWORD, SDATA*, DWORD *) PURE; + STDMETHOD (Set) (THIS_ BOOL, DWORD, DWORD, DWORD, SDATA) PURE; + STDMETHOD (EnableItem) (THIS_ BOOL, DWORD, DWORD, DWORD) PURE; + STDMETHOD (Num) (THIS_ BOOL, DWORD *) PURE; +}; + +typedef IVDctGlossaryA FAR * PIVDCTGLOSSARYA; + + +#ifdef _S_UNICODE + #define IVDctGlossary IVDctGlossaryW + #define IID_IVDctGlossary IID_IVDctGlossaryW + #define PIVDCTGLOSSARY PIVDCTGLOSSARYW + +#else + #define IVDctGlossary IVDctGlossaryA + #define IID_IVDctGlossary IID_IVDctGlossaryA + #define PIVDCTGLOSSARY PIVDCTGLOSSARYA + +#endif // _S_UNICODE + + + + +/* + * IVDctDialog + */ +#undef INTERFACE +#define INTERFACE IVDctDialogsW + +// {88AD7DC7-67D5-11cf-9B8B-08005AFC3A41} +DEFINE_GUID(IID_IVDctDialogsW, +0x88ad7dc7, 0x67d5, 0x11cf, 0x9b, 0x8b, 0x8, 0x0, 0x5a, 0xfc, 0x3a, 0x41); + +DECLARE_INTERFACE_ (IVDctDialogsW, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVDctDialogs members + STDMETHOD (AboutDlg) (THIS_ HWND, PCWSTR) PURE; + STDMETHOD (GeneralDlg) (THIS_ HWND, PCWSTR) PURE; + STDMETHOD (LexiconDlg) (THIS_ HWND, PCWSTR) PURE; + STDMETHOD (TrainGeneralDlg) (THIS_ HWND, PCWSTR) PURE; + STDMETHOD (TrainMicDlg) (THIS_ HWND, PCWSTR) PURE; +}; + +typedef IVDctDialogsW FAR * PIVDCTDIALOGSW; + + +#undef INTERFACE +#define INTERFACE IVDctDialogsA + +// {88AD7DC8-67D5-11cf-9B8B-08005AFC3A41} +DEFINE_GUID(IID_IVDctDialogsA, +0x88ad7dc8, 0x67d5, 0x11cf, 0x9b, 0x8b, 0x8, 0x0, 0x5a, 0xfc, 0x3a, 0x41); + +DECLARE_INTERFACE_ (IVDctDialogsA, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVDctDialogs members + STDMETHOD (AboutDlg) (THIS_ HWND, PCSTR) PURE; + STDMETHOD (GeneralDlg) (THIS_ HWND, PCSTR) PURE; + STDMETHOD (LexiconDlg) (THIS_ HWND, PCSTR) PURE; + STDMETHOD (TrainGeneralDlg) (THIS_ HWND, PCSTR) PURE; + STDMETHOD (TrainMicDlg) (THIS_ HWND, PCSTR) PURE; +}; + +typedef IVDctDialogsA FAR * PIVDCTDIALOGSA; + + +#ifdef _S_UNICODE + #define IVDctDialogs IVDctDialogsW + #define IID_IVDctDialogs IID_IVDctDialogsW + #define PIVDCTDIALOGS PIVDCTDIALOGSW + +#else + #define IVDctDialogs IVDctDialogsA + #define IID_IVDctDialogs IID_IVDctDialogsA + #define PIVDCTDIALOGS PIVDCTDIALOGSA + +#endif // _S_UNICODE + + +#undef INTERFACE +#define INTERFACE IVDctGUI + +// {8953F1A0-7E80-11cf-8D15-00A0C9034A7E} +DEFINE_GUID(IID_IVDctGUI, +0x8953f1a0, 0x7e80, 0x11cf, 0x8d, 0x15, 0x0, 0xa0, 0xc9, 0x3, 0x4a, 0x7e); + +DECLARE_INTERFACE_ (IVDctGUI, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVDctDialogs members + STDMETHOD (SetSelRect) (THIS_ RECT *) PURE; + STDMETHOD (FlagsSet) (THIS_ DWORD) PURE; + STDMETHOD (FlagsGet) (THIS_ DWORD *) PURE; +}; + +typedef IVDctGUI FAR * PIVDCTGUI; + + + +/************************************************************************ +class guids */ + +// {25522CA0-67CE-11cf-9B8B-08005AFC3A41} +DEFINE_GUID(CLSID_VDct, +0x35522ca0, 0x67ce, 0x11cf, 0x9b, 0x8b, 0x8, 0x0, 0x5a, 0xfc, 0x3a, 0x41); + + + +/************************************************************************ +High-Level text-to-speech API +*/ + + +/************************************************************************ +defines */ + +#define ONE (1) + +// dwFlags parameter of IVoiceText::Register +#define VTXTF_ALLMESSAGES (ONE<<0) + +/* + * dwFlags parameter of IVoiceText::Speak + */ + +// type of speech +#define VTXTST_STATEMENT 0x00000001 +#define VTXTST_QUESTION 0x00000002 +#define VTXTST_COMMAND 0x00000004 +#define VTXTST_WARNING 0x00000008 +#define VTXTST_READING 0x00000010 +#define VTXTST_NUMBERS 0x00000020 +#define VTXTST_SPREADSHEET 0x00000040 + +// priorities +#define VTXTSP_VERYHIGH 0x00000080 +#define VTXTSP_HIGH 0x00000100 +#define VTXTSP_NORMAL 0x00000200 + +/************************************************************************ +typedefs */ + +// possible parameter to IVoiceText::Register +typedef struct { + DWORD dwDevice; + DWORD dwEnable; + DWORD dwSpeed; + GUID gModeID; +} VTSITEINFO, *PVTSITEINFO; + + +/************************************************************************ +interfaces */ + +/* + * IVCmdNotifySink + */ +#undef INTERFACE +#define INTERFACE IVTxtNotifySinkW + +// {FD3A2430-E090-11cd-A166-00AA004CD65C} +DEFINE_GUID(IID_IVTxtNotifySinkW, 0xfd3a2430, 0xe090, 0x11cd, 0xa1, 0x66, 0x0, 0xaa, 0x0, 0x4c, 0xd6, 0x5c); + +DECLARE_INTERFACE_ (IVTxtNotifySinkW, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVTxtNotifySinkW members + STDMETHOD (AttribChanged) (THIS_ DWORD) PURE; + STDMETHOD (Visual) (THIS_ WCHAR, WCHAR, DWORD, PTTSMOUTH) PURE; + STDMETHOD (Speak) (THIS_ PWSTR, PWSTR, DWORD) PURE; + STDMETHOD (SpeakingStarted) (THIS) PURE; + STDMETHOD (SpeakingDone) (THIS) PURE; +}; + +typedef IVTxtNotifySinkW FAR * PIVTXTNOTIFYSINKW; + + +#undef INTERFACE +#define INTERFACE IVTxtNotifySinkA + +// {D2C840E0-E092-11cd-A166-00AA004CD65C} +DEFINE_GUID(IID_IVTxtNotifySinkA, 0xd2c840e0, 0xe092, 0x11cd, 0xa1, 0x66, 0x0, 0xaa, 0x0, 0x4c, 0xd6, 0x5c); + +DECLARE_INTERFACE_ (IVTxtNotifySinkA, IUnknown) { + + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVTxtNotifySinkA members + STDMETHOD (AttribChanged) (THIS_ DWORD) PURE; + STDMETHOD (Visual) (THIS_ WCHAR, CHAR, DWORD, PTTSMOUTH) PURE; + STDMETHOD (Speak) (THIS_ PSTR, PSTR, DWORD) PURE; + STDMETHOD (SpeakingStarted) (THIS) PURE; + STDMETHOD (SpeakingDone) (THIS) PURE; +}; + +typedef IVTxtNotifySinkA FAR * PIVTXTNOTIFYSINKA; + + +#ifdef _S_UNICODE + #define IVTxtNotifySink IVTxtNotifySinkW + #define IID_IVTxtNotifySink IID_IVTxtNotifySinkW + #define PIVTXTNOTIFYSINK PIVTXTNOTIFYSINKW + +#else + #define IVTxtNotifySink IVTxtNotifySinkA + #define IID_IVTxtNotifySink IID_IVTxtNotifySinkA + #define PIVTXTNOTIFYSINK PIVTXTNOTIFYSINKA + +#endif // _S_UNICODE + + + +/* + * IVoiceText + */ +#undef INTERFACE +#define INTERFACE IVoiceTextW + +// {C4FE8740-E093-11cd-A166-00AA004CD65C} +DEFINE_GUID(IID_IVoiceTextW, 0xc4fe8740, 0xe093, 0x11cd, 0xa1, 0x66, 0x0, 0xaa, 0x0, 0x4c, 0xd6, 0x5c); + +DECLARE_INTERFACE_ (IVoiceTextW, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVoiceText members + + STDMETHOD (Register) (THIS_ PCWSTR, PCWSTR, + PIVTXTNOTIFYSINK, GUID, + DWORD, PVTSITEINFO) PURE; + STDMETHOD (Speak) (THIS_ PCWSTR, DWORD, PCWSTR) PURE; + STDMETHOD (StopSpeaking) (THIS) PURE; + STDMETHOD (AudioFastForward) (THIS) PURE; + STDMETHOD (AudioPause) (THIS) PURE; + STDMETHOD (AudioResume) (THIS) PURE; + STDMETHOD (AudioRewind) (THIS) PURE; +}; + +typedef IVoiceTextW FAR * PIVOICETEXTW; + + +#undef INTERFACE +#define INTERFACE IVoiceTextA + +// {E1B7A180-E093-11cd-A166-00AA004CD65C} +DEFINE_GUID(IID_IVoiceTextA, 0xe1b7a180, 0xe093, 0x11cd, 0xa1, 0x66, 0x0, 0xaa, 0x0, 0x4c, 0xd6, 0x5c); + +DECLARE_INTERFACE_ (IVoiceTextA, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVoiceText members + + STDMETHOD (Register) (THIS_ PCSTR, PCSTR, + PIVTXTNOTIFYSINK, GUID, + DWORD, PVTSITEINFO) PURE; + STDMETHOD (Speak) (THIS_ PCSTR, DWORD, PCSTR) PURE; + STDMETHOD (StopSpeaking) (THIS) PURE; + STDMETHOD (AudioFastForward) (THIS) PURE; + STDMETHOD (AudioPause) (THIS) PURE; + STDMETHOD (AudioResume) (THIS) PURE; + STDMETHOD (AudioRewind) (THIS) PURE; +}; + +typedef IVoiceTextA FAR * PIVOICETEXTA; + + +#ifdef _S_UNICODE + #define IVoiceText IVoiceTextW + #define IID_IVoiceText IID_IVoiceTextW + #define PIVOICETEXT PIVOICETEXTW + +#else + #define IVoiceText IVoiceTextA + #define IID_IVoiceText IID_IVoiceTextA + #define PIVOICETEXT PIVOICETEXTA + +#endif //_S_UNICODE + + + +/* + * IVTxtAttributes + */ +#undef INTERFACE +#define INTERFACE IVTxtAttributesW + +// {6A8D6140-E095-11cd-A166-00AA004CD65C} +DEFINE_GUID(IID_IVTxtAttributesW, 0x6a8d6140, 0xe095, 0x11cd, 0xa1, 0x66, 0x0, 0xaa, 0x0, 0x4c, 0xd6, 0x5c); + +DECLARE_INTERFACE_ (IVTxtAttributesW, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVTxtAttributes members + STDMETHOD (DeviceGet) (THIS_ DWORD *) PURE; + STDMETHOD (DeviceSet) (THIS_ DWORD) PURE; + STDMETHOD (EnabledGet) (THIS_ DWORD *) PURE; + STDMETHOD (EnabledSet) (THIS_ DWORD) PURE; + STDMETHOD (IsSpeaking) (THIS_ BOOL *) PURE; + STDMETHOD (SpeedGet) (THIS_ DWORD *) PURE; + STDMETHOD (SpeedSet) (THIS_ DWORD) PURE; + STDMETHOD (TTSModeGet) (THIS_ GUID *) PURE; + STDMETHOD (TTSModeSet) (THIS_ GUID) PURE; +}; + +typedef IVTxtAttributesW FAR * PIVTXTATTRIBUTESW; + + +#undef INTERFACE +#define INTERFACE IVTxtAttributesA + +// {8BE9CC30-E095-11cd-A166-00AA004CD65C} +DEFINE_GUID(IID_IVTxtAttributesA, 0x8be9cc30, 0xe095, 0x11cd, 0xa1, 0x66, 0x0, 0xaa, 0x0, 0x4c, 0xd6, 0x5c); + +DECLARE_INTERFACE_ (IVTxtAttributesA, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVTxtAttributes members + STDMETHOD (DeviceGet) (THIS_ DWORD *) PURE; + STDMETHOD (DeviceSet) (THIS_ DWORD) PURE; + STDMETHOD (EnabledGet) (THIS_ DWORD *) PURE; + STDMETHOD (EnabledSet) (THIS_ DWORD) PURE; + STDMETHOD (IsSpeaking) (THIS_ BOOL *) PURE; + STDMETHOD (SpeedGet) (THIS_ DWORD *) PURE; + STDMETHOD (SpeedSet) (THIS_ DWORD) PURE; + STDMETHOD (TTSModeGet) (THIS_ GUID *) PURE; + STDMETHOD (TTSModeSet) (THIS_ GUID) PURE; +}; + +typedef IVTxtAttributesA FAR * PIVTXTATTRIBUTESA; + + +#ifdef _S_UNICODE + #define IVTxtAttributes IVTxtAttributesW + #define IID_IVTxtAttributes IID_IVTxtAttributesW + #define PIVTXTATTRIBUTES PIVTXTATTRIBUTESW + +#else + #define IVTxtAttributes IVTxtAttributesA + #define IID_IVTxtAttributes IID_IVTxtAttributesA + #define PIVTXTATTRIBUTES PIVTXTATTRIBUTESA + +#endif // _S_UNICODE + + + +/* + * IVTxtDialog + */ +#undef INTERFACE +#define INTERFACE IVTxtDialogsW + +// {D6469210-E095-11cd-A166-00AA004CD65C} +DEFINE_GUID(IID_IVTxtDialogsW, 0xd6469210, 0xe095, 0x11cd, 0xa1, 0x66, 0x0, 0xaa, 0x0, 0x4c, 0xd6, 0x5c); + +DECLARE_INTERFACE_ (IVTxtDialogsW, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVTxtDialogs members + + STDMETHOD (AboutDlg) (THIS_ HWND, PCWSTR) PURE; + STDMETHOD (LexiconDlg) (THIS_ HWND, PCWSTR) PURE; + STDMETHOD (GeneralDlg) (THIS_ HWND, PCWSTR) PURE; + STDMETHOD (TranslateDlg) (THIS_ HWND, PCWSTR) PURE; +}; + +typedef IVTxtDialogsW FAR * PIVTXTDIALOGSW; + + +#undef INTERFACE +#define INTERFACE IVTxtDialogsA + +// {E8F6FA20-E095-11cd-A166-00AA004CD65C} +DEFINE_GUID(IID_IVTxtDialogsA, 0xe8f6fa20, 0xe095, 0x11cd, 0xa1, 0x66, 0x0, 0xaa, 0x0, 0x4c, 0xd6, 0x5c); + +DECLARE_INTERFACE_ (IVTxtDialogsA, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IVTxtDialogs members + STDMETHOD (AboutDlg) (THIS_ HWND, PCSTR) PURE; + STDMETHOD (LexiconDlg) (THIS_ HWND, PCSTR) PURE; + STDMETHOD (GeneralDlg) (THIS_ HWND, PCSTR) PURE; + STDMETHOD (TranslateDlg) (THIS_ HWND, PCSTR) PURE; +}; + +typedef IVTxtDialogsA FAR * PIVTXTDIALOGSA; + + +#ifdef _S_UNICODE + #define IVTxtDialogs IVTxtDialogsW + #define IID_IVTxtDialogs IID_IVTxtDialogsW + #define PIVTXTDIALOGS PIVTXTDIALOGSW + +#else + #define IVTxtDialogs IVTxtDialogsA + #define IID_IVTxtDialogs IID_IVTxtDialogsA + #define PIVTXTDIALOGS PIVTXTDIALOGSA + +#endif // _S_UNICODE + + + +/************************************************************************ +class guids */ + +// {080EB9D0-E096-11cd-A166-00AA004CD65C} +// DEFINE_GUID(CLSID_VTxt, 0x80eb9d0, 0xe096, 0x11cd, 0xa1, 0x66, 0x0, 0xaa, 0x0, 0x4c, 0xd6, 0x5c); +// {F1DC95A0-0BA7-11ce-A166-00AA004CD65C} +DEFINE_GUID(CLSID_VTxt, +0xf1dc95a0, 0xba7, 0x11ce, 0xa1, 0x66, 0x0, 0xaa, 0x0, 0x4c, 0xd6, 0x5c); + + +// {70618F72-D1ED-11d0-8FAC-08002BE4E62A} +DEFINE_GUID(CLSID_STGramComp, +0x70618f72, 0xd1ed, 0x11d0, 0x8f, 0xac, 0x8, 0x0, 0x2b, 0xe4, 0xe6, 0x2a); + +// {EFD0E6BA-DB5F-11d0-8FAC-08002BE4E62A} +DEFINE_GUID(CLSID_STTTSQueue, +0xefd0e6ba, 0xdb5f, 0x11d0, 0x8f, 0xac, 0x8, 0x0, 0x2b, 0xe4, 0xe6, 0x2a); + +// {B3613D9F-E26E-11d0-8FAC-08002BE4E62A} +DEFINE_GUID(CLSID_STLog, +0xb3613d9f, 0xe26e, 0x11d0, 0x8f, 0xac, 0x8, 0x0, 0x2b, 0xe4, 0xe6, 0x2a); + +// {B3613DA0-E26E-11d0-8FAC-08002BE4E62A} +DEFINE_GUID(CLSID_AudioSourceLog, +0xb3613da0, 0xe26e, 0x11d0, 0x8f, 0xac, 0x8, 0x0, 0x2b, 0xe4, 0xe6, 0x2a); + +// {2EC5A8A5-E65B-11d0-8FAC-08002BE4E62A} +DEFINE_GUID(CLSID_AudioSourceTel, +0x2ec5a8a5, 0xe65b, 0x11d0, 0x8f, 0xac, 0x8, 0x0, 0x2b, 0xe4, 0xe6, 0x2a); + +// {2EC5A8A6-E65B-11d0-8FAC-08002BE4E62A} +DEFINE_GUID(CLSID_AudioDestTel, +0x2ec5a8a6, 0xe65b, 0x11d0, 0x8f, 0xac, 0x8, 0x0, 0x2b, 0xe4, 0xe6, 0x2a); + +// {61935832-FC85-11d0-8FAE-08002BE4E62A} +DEFINE_GUID(CLSID_STRecord, +0x61935832, 0xfc85, 0x11d0, 0x8f, 0xae, 0x8, 0x0, 0x2b, 0xe4, 0xe6, 0x2a); + +/* interfaces */ +// ISTRecord Interface + +#undef INTERFACE +#define INTERFACE ISTRecord + +// {61935833-FC85-11d0-8FAE-08002BE4E62A} +DEFINE_GUID(IID_ISTRecord, +0x61935833, 0xfc85, 0x11d0, 0x8f, 0xae, 0x8, 0x0, 0x2b, 0xe4, 0xe6, 0x2a); + +typedef struct { + DWORD dwBetweenUtt; // acceptable time between utterance, milliseconds + DWORD dwInitialBuf; // milliseconds of audio in the initial buffer + DWORD dwReallocBuf; // amount to increase a buffer every time new audio + DWORD dwMaxBuf; // maximum number of milliseconds that buffer can be + DWORD dwNoAnswer; // milliseconds of silence before get no-answer +} STRECORDPARAM, *PSTRECORDPARAM; + +DECLARE_INTERFACE_ (ISTRecord, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISTGramComp members + STDMETHOD (Init) (THIS_ LPUNKNOWN, DWORD, LPUNKNOWN) PURE; + STDMETHOD (ParamsSet) (THIS_ PSTRECORDPARAM) PURE; + STDMETHOD (Start) (THIS) PURE; + STDMETHOD (Stop) (THIS_ DWORD) PURE; + STDMETHOD (GetWAV) (THIS_ PVOID*, DWORD*) PURE; + STDMETHOD (ClearWAV) (THIS) PURE; + }; + +typedef ISTRecord FAR * PISTRECORD; + + +// ISTRecordNotifySink Interface + +#undef INTERFACE +#define INTERFACE ISTRecordNotifySink + +// {61935834-FC85-11d0-8FAE-08002BE4E62A} +DEFINE_GUID(IID_ISTRecordNotifySink, +0x61935834, 0xfc85, 0x11d0, 0x8f, 0xae, 0x8, 0x0, 0x2b, 0xe4, 0xe6, 0x2a); + +DECLARE_INTERFACE_ (ISTRecordNotifySink, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISTGramComp members + STDMETHOD (AutoStop) (THIS) PURE; + STDMETHOD (VU) (THIS_ WORD) PURE; + }; + +typedef ISTRecordNotifySink FAR * PISTRECORDNOTIFYSINK; + + + +// ISTGramComp Interface + +#undef INTERFACE +#define INTERFACE ISTGramComp + +// {70618F73-D1ED-11d0-8FAC-08002BE4E62A} +DEFINE_GUID(IID_ISTGramComp, +0x70618f73, 0xd1ed, 0x11d0, 0x8f, 0xac, 0x8, 0x0, 0x2b, 0xe4, 0xe6, 0x2a); + +DECLARE_INTERFACE_ (ISTGramComp, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISTGramComp members + STDMETHOD (FromMemory) (THIS_ PVOID, DWORD) PURE; + STDMETHOD (FromResource) (THIS_ HINSTANCE, DWORD) PURE; + STDMETHOD (FromFile) (THIS_ PCWSTR) PURE; + STDMETHOD (FromStream) (THIS_ IStream *) PURE; + STDMETHOD (Compile) (THIS_ LPWSTR*, DWORD*) PURE; + STDMETHOD (IsCompiled) (THIS_ BOOL*) PURE; + STDMETHOD (ToMemory) (THIS_ PVOID*, DWORD*) PURE; + STDMETHOD (ToFile) (THIS_ PCWSTR) PURE; + STDMETHOD (ToStream) (THIS_ IStream *) PURE; + STDMETHOD (TextGet) (THIS_ LPWSTR*, DWORD*) PURE; + STDMETHOD (LanguageGet) (THIS_ LANGUAGEW*) PURE; + STDMETHOD (GrammarFormatGet) (THIS_ SRGRMFMT*) PURE; + STDMETHOD (GrammarDataGet) (THIS_ BOOL, PVOID*, DWORD*) PURE; + STDMETHOD (GrammarDataSet) (THIS_ PVOID, DWORD) PURE; + STDMETHOD (AutoList) (THIS_ PISRGRAMCFGW) PURE; + STDMETHOD (PhraseParse) (THIS_ PSRPHRASEW, DWORD *, LPWSTR *, DWORD *) PURE; + STDMETHOD (GrammarLoad) (THIS_ LPUNKNOWN, PVOID, IID, LPUNKNOWN *) PURE; + STDMETHOD (PhraseParseAlt) (THIS_ DWORD, DWORD *, LPWSTR *, DWORD *) PURE; + STDMETHOD (PhraseParseRule) (THIS_ PCWSTR, PSRPHRASEW, DWORD *, LPWSTR *, DWORD *) PURE; + }; + +typedef ISTGramComp FAR * PISTGRAMCOMP; + + + +// ISTTTSQueue Interface + +#undef INTERFACE +#define INTERFACE ISTTTSQueue + +// {EFD0E6BB-DB5F-11d0-8FAC-08002BE4E62A} +DEFINE_GUID(IID_ISTTTSQueue, +0xefd0e6bb, 0xdb5f, 0x11d0, 0x8f, 0xac, 0x8, 0x0, 0x2b, 0xe4, 0xe6, 0x2a); + +DECLARE_INTERFACE_ (ISTTTSQueue, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISTTTSQueue members + STDMETHOD (WaveAddFromFile) (THIS_ PCWSTR, PCWSTR) PURE; + STDMETHOD (WaveAddFromStream) (THIS_ PCWSTR, IStream *) PURE; + STDMETHOD (WaveAddFromMemory) (THIS_ PCWSTR, PVOID, DWORD) PURE; + STDMETHOD (WaveAddFromResource) (THIS_ PCWSTR, HMODULE, DWORD) PURE; + STDMETHOD (WaveAddFromList) (THIS_ PCWSTR, HMODULE) PURE; + STDMETHOD (WaveRemove) (THIS_ PCWSTR) PURE; + STDMETHOD (WaveAudioDestSet) (THIS_ LPUNKNOWN) PURE; + STDMETHOD (WaveLevelSet) (THIS_ DWORD) PURE; + STDMETHOD (WaveLevelGet) (THIS_ DWORD *) PURE; + STDMETHOD (TTSAdd) (THIS_ PCWSTR, LPUNKNOWN) PURE; + STDMETHOD (TTSRemove) (THIS_ PCWSTR) PURE; + STDMETHOD (TTSGet) (THIS_ PCWSTR, LPUNKNOWN *) PURE; + STDMETHOD (Speak) (THIS_ PCWSTR, PCWSTR, DWORD) PURE; + STDMETHOD (TextData) (THIS_ VOICECHARSET, DWORD, SDATA, PCWSTR, DWORD) PURE; + STDMETHOD (AudioPause) (THIS) PURE; + STDMETHOD (AudioResume) (THIS) PURE; + STDMETHOD (AudioReset) (THIS) PURE; + STDMETHOD (Register) (THIS_ PVOID, REFIID) PURE; + STDMETHOD (UseLogging) (THIS_ LPUNKNOWN) PURE; + STDMETHOD (IsSpeaking) (THIS_ DWORD*) PURE; + }; + +typedef ISTTTSQueue FAR * PISTTTSQUEUE; + + +// ISTTTSQueueNotifySink Interface + +#undef INTERFACE +#define INTERFACE ISTTTSQueueNotifySink + +// {8412FA0C-DB6A-11d0-8FAC-08002BE4E62A} +DEFINE_GUID(IID_ISTTTSQueueNotifySink, +0x8412fa0c, 0xdb6a, 0x11d0, 0x8f, 0xac, 0x8, 0x0, 0x2b, 0xe4, 0xe6, 0x2a); + +DECLARE_INTERFACE_ (ISTTTSQueueNotifySink, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISTTTSQueueNotifySink members + STDMETHOD (Start) (THIS) PURE; + STDMETHOD (Stop) (THIS) PURE; + STDMETHOD (SpeakID) (THIS_ DWORD) PURE; + STDMETHOD (Error) (THIS_ HRESULT) PURE; + STDMETHOD (Bookmark) (THIS_ DWORD) PURE; + }; + +typedef ISTTTSQueueNotifySink FAR * PISTTTSQUEUENOTIFYSINK; + + +// ISTLog Interface + +#undef INTERFACE +#define INTERFACE ISTLog + +// {B3613DA1-E26E-11d0-8FAC-08002BE4E62A} +DEFINE_GUID(IID_ISTLog, +0xb3613da1, 0xe26e, 0x11d0, 0x8f, 0xac, 0x8, 0x0, 0x2b, 0xe4, 0xe6, 0x2a); + +DECLARE_INTERFACE_ (ISTLog, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // ISTLog members + STDMETHOD (ToFile) (THIS_ PCWSTR) PURE; + STDMETHOD (ToStream) (THIS_ IStream *) PURE; + STDMETHOD (Text) (THIS_ PCWSTR, PCWSTR, WORD) PURE; + STDMETHOD (Data) (THIS_ PCWSTR, PCWSTR, WORD, PVOID, DWORD) PURE; + STDMETHOD (MaxDetailSet) (THIS_ WORD) PURE; + STDMETHOD (MaxDetailGet) (THIS_ WORD*) PURE; + STDMETHOD (ShowOutput) (THIS_ BOOL) PURE; + }; + +typedef ISTLog FAR * PISTLOG; + + +// IAudioSourceLog Interface + +#undef INTERFACE +#define INTERFACE IAudioSourceLog + +// {B3613DA2-E26E-11d0-8FAC-08002BE4E62A} +DEFINE_GUID(IID_IAudioSourceLog, +0xb3613da2, 0xe26e, 0x11d0, 0x8f, 0xac, 0x8, 0x0, 0x2b, 0xe4, 0xe6, 0x2a); + +DECLARE_INTERFACE_ (IAudioSourceLog, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IAudioSourceLog members + STDMETHOD (AudioSource) (THIS_ LPUNKNOWN) PURE; + STDMETHOD (UseLogging) (THIS_ LPUNKNOWN) PURE; + }; + +typedef IAudioSourceLog FAR * PIAUDIOSOURCELOG; + + + +// IAudioTel Interface + +#undef INTERFACE +#define INTERFACE IAudioTel + +// {2EC5A8A7-E65B-11d0-8FAC-08002BE4E62A} +DEFINE_GUID(IID_IAudioTel, +0x2ec5a8a7, 0xe65b, 0x11d0, 0x8f, 0xac, 0x8, 0x0, 0x2b, 0xe4, 0xe6, 0x2a); + +DECLARE_INTERFACE_ (IAudioTel, IUnknown) { + // IUnknown members + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + // IAudioTel members + STDMETHOD (AudioObject) (THIS_ LPUNKNOWN) PURE; + STDMETHOD (WaveFormatSet) (THIS_ SDATA) PURE; + }; + +typedef IAudioTel FAR * PIAUDIOTEL; + + + + + +/************************************************************************ +External speech synthesizer - This is for using external, hardware +based speech synthesizers with SAPI */ + + +/************************************************************************ +defines */ + + +// Synthesizer Attributes +#define TTS_LANGUAGE SETBIT(0) +#define TTS_VOICE SETBIT(1) +#define TTS_GENDER SETBIT(2) +#define TTS_VOLUME SETBIT(3) +#define TTS_PITCH SETBIT(4) +#define TTS_SPEED SETBIT(5) +#define TTS_ABBREVIATION SETBIT(6) +#define TTS_PUNCTUATION SETBIT(7) +#define TTS_PAUSEWORD SETBIT(8) +#define TTS_PAUSEPHRASE SETBIT(9) +#define TTS_PAUSESENTENCE SETBIT(10) +#define TTS_SPELLING SETBIT(11) +#define TTS_QUALITY SETBIT(12) +#define TTS_FRICATION SETBIT(13) +#define TTS_ASPIRATION SETBIT(14) +#define TTS_INTONATION SETBIT(15) + + +// Attribute minimums and maximums +#define TTSATTR_MINPAUSEWORD 0x00000000 +#define TTSATTR_MAXPAUSEWORD 0xffffffff +#define TTSATTR_MINPAUSEPHRASE 0x00000000 +#define TTSATTR_MAXPAUSEPHRASE 0xffffffff +#define TTSATTR_MINPAUSESENTENCE 0x00000000 +#define TTSATTR_MAXPAUSESENTENCE 0xffffffff +#define TTSATTR_MINASPIRATION 0x00000000 +#define TTSATTR_MAXASPIRATION 0xffffffff +#define TTSATTR_MINFRICATION 0x00000000 +#define TTSATTR_MAXFRICATION 0xffffffff +#define TTSATTR_MININTONATION 0x00000000 +#define TTSATTR_MAXINTONATION 0xffffffff + + +// ITTSNotifySink +#define TTSNSAC_LANGUAGE 100 +#define TTSNSAC_VOICE 101 +#define TTSNSAC_GENDER 102 +#define TTSNSAC_ABBREVIATION 103 +#define TTSNSAC_PUNCTUATION 104 +#define TTSNSAC_PAUSEWORD 105 +#define TTSNSAC_PAUSEPHRASE 106 +#define TTSNSAC_PAUSESENTENCE 107 +#define TTSNSAC_SPELLING 108 +#define TTSNSAC_QUALITY 109 +#define TTSNSAC_FRICATION 110 +#define TTSNSAC_ASPIRATION 111 +#define TTSNSAC_INTONATION 112 + + +// Interfaces +#define TTSI_ITTSEXTERNALSYNTHESIZER SETBIT(4) + + +// TTSERR Result codes +#define TTSERR_SYNTHESIZERBUSY TTSERROR(100) +#define TTSERR_ALREADYDISPLAYED TTSERROR(101) +#define TTSERR_INVALIDATTRIB TTSERROR(102) +#define TTSERR_SYNTHESIZERACCESSERROR TTSERROR(103) +#define TTSERR_DRIVERERROR TTSERROR(104) +#define TTSERR_UNRECOVERABLEERROR TTSERROR(105) +#define TTSERR_DRIVERACCESSERROR TTSERROR(106) +#define TTSERR_BUFFERTOOSMALL TTSERROR(107) +#define TTSERR_DRIVERNOTFOUND TTSERROR(108) +#define TTSERR_CANNOTREGISTER TTSERROR(109) +#define TTSERR_LANGUAGENOTSUPPORTED TTSERROR(110) + + +/************************************************************************ +Class IDs */ + +// {479DFDCB-01A8-11d1-A7A5-00C04FBBE8AB} +DEFINE_GUID(CLSID_SynthAudioDest, +0x479dfdcb, 0x1a8, 0x11d1, 0xa7, 0xa5, 0x0, 0xc0, 0x4f, 0xbb, 0xe8, 0xab); + +// {26C328C1-F26F-11d0-9DFF-006097622195} +DEFINE_GUID(CLSID_SynthEngine, +0x26c328c1, 0xf26f, 0x11d0, 0x9d, 0xff, 0x0, 0x60, 0x97, 0x62, 0x21, 0x95); + +// {AC8FCCA1-FFD7-11d0-9E22-006097622195} +DEFINE_GUID(CLSID_SynthEngineEnumerator, +0xac8fcca1, 0xffd7, 0x11d0, 0x9e, 0x22, 0x0, 0x60, 0x97, 0x62, 0x21, 0x95); + + + +/************************************************************************ +typedefs */ + +// Definition of Preset +typedef struct +{ + LANGID Language; + DWORD Voice; + DWORD Gender; + + DWORD Volume; + DWORD Pitch; + DWORD Speed; + + DWORD Abbreviation; + DWORD Punctuation; + DWORD PauseWord; + DWORD PausePhrase; + DWORD PauseSentence; + + DWORD Spelling; + DWORD Quality; + + DWORD Frication; + DWORD Aspiration; + DWORD Intonation; +} +TTSPRESET, *PTTSPRESET; + + +/************************************************************************ +interfaces */ + + +/* + * ITTSExternalSynthesizer + */ + + +#undef INTERFACE +#define INTERFACE ITTSExternalSynthesizerW + +// {A3F8B9C0-2010-11d1-A306-006097622195} +DEFINE_GUID(IID_ITTSExternalSynthesizerW, +0xa3f8b9c0, 0x2010, 0x11d1, 0xa3, 0x6, 0x0, 0x60, 0x97, 0x62, 0x21, 0x95); + +DECLARE_INTERFACE_(ITTSExternalSynthesizerW, IUnknown) +{ + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + STDMETHOD (AttributeGet) (THIS_ DWORD dwAttribute, DWORD *pdwValue) PURE; + STDMETHOD (AttributeSet) (THIS_ DWORD dwAttribute, DWORD dwValue) PURE; + STDMETHOD (PresetGet) (THIS_ PTTSPRESET pPreset, DWORD *pdwResult) PURE; + STDMETHOD (PresetSet) (THIS_ TTSPRESET Preset, DWORD *pdwResult) PURE; + + STDMETHOD (GetAttributeElements) (THIS_ DWORD dwAttr, DWORD *pdwNumElems) PURE; + STDMETHOD (GetAttributeRange) (THIS_ DWORD dwAttr, DWORD *pdwMin, DWORD *pdwMax) PURE; + STDMETHOD (GetAttributeValue) (THIS_ DWORD dwAttr, DWORD dwIndex, DWORD *pdwValue, PWSTR szText, DWORD dwMaxChars) PURE; + STDMETHOD (GetAttributeIndex) (THIS_ DWORD dwAttr, DWORD dwValue, DWORD *pdwIndex, PWSTR szText, DWORD dwMaxChars) PURE; + + STDMETHOD (AudioFlush) (THIS) PURE; + + STDMETHOD (TextDataInterrupt)(THIS_ VOICECHARSET eCharacterSet, DWORD dwFlags, SDATA dText, PVOID pNotifyInterface, IID IIDNotifyInterface) PURE; + STDMETHOD (TextDataCritical) (THIS_ SDATA) PURE; + + STDMETHOD (MiscellaneousDlg) (THIS_ HWND hWndParent, PCWSTR pszTitle) PURE; +}; +typedef ITTSExternalSynthesizerW *PITTSEXTERNALSYNTHESIZERW; + + +#undef INTERFACE +#define INTERFACE ITTSExternalSynthesizerA + +// {3D11C963-F210-11d0-A788-00C04FBBE8AB} +DEFINE_GUID(IID_ITTSExternalSynthesizerA, +0x3d11c963, 0xf210, 0x11d0, 0xa7, 0x88, 0x0, 0xc0, 0x4f, 0xbb, 0xe8, 0xab); + +DECLARE_INTERFACE_(ITTSExternalSynthesizerA, IUnknown) +{ + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + + STDMETHOD (AttributeGet) (THIS_ DWORD dwAttribute, DWORD *pdwValue) PURE; + STDMETHOD (AttributeSet) (THIS_ DWORD dwAttribute, DWORD dwValue) PURE; + STDMETHOD (PresetGet) (THIS_ PTTSPRESET pPreset, DWORD *pdwResult) PURE; + STDMETHOD (PresetSet) (THIS_ TTSPRESET Preset, DWORD *pdwResult) PURE; + + STDMETHOD (GetAttributeElements) (THIS_ DWORD dwAttr, DWORD *pdwNumElems) PURE; + STDMETHOD (GetAttributeRange) (THIS_ DWORD dwAttr, DWORD *pdwMin, DWORD *pdwMax) PURE; + STDMETHOD (GetAttributeValue) (THIS_ DWORD dwAttr, DWORD dwIndex, DWORD *pdwValue, PSTR szText, DWORD dwMaxChars) PURE; + STDMETHOD (GetAttributeIndex) (THIS_ DWORD dwAttr, DWORD dwValue, DWORD *pdwIndex, PSTR szText, DWORD dwMaxChars) PURE; + + STDMETHOD (AudioFlush) (THIS) PURE; + + STDMETHOD (TextDataInterrupt)(THIS_ VOICECHARSET eCharacterSet, DWORD dwFlags, SDATA dText, PVOID pNotifyInterface, IID IIDNotifyInterface) PURE; + STDMETHOD (TextDataCritical) (THIS_ SDATA) PURE; + + STDMETHOD (MiscellaneousDlg) (THIS_ HWND hWndParent, PCSTR pszTitle) PURE; +}; +typedef ITTSExternalSynthesizerA *PITTSEXTERNALSYNTHESIZERA; + + +#ifdef _S_UNICODE + #define ITTSExternalSynthesizer ITTSExternalSynthesizerW + #define IID_ITTSExternalSynthesizer IID_ITTSExternalSynthesizerW + #define PITTSEXTERNALSYNTHESIZER PITTSEXTERNALSYNTHESIZERW + +#else + #define ITTSExternalSynthesizer ITTSExternalSynthesizerA + #define IID_ITTSExternalSynthesizer IID_ITTSExternalSynthesizerA + #define PITTSEXTERNALSYNTHESIZER PITTSEXTERNALSYNTHESIZERA + +#endif // _S_UNICODE + + + +/* + * IAudioExternalSynthesizer + */ + +#undef INTERFACE +#define INTERFACE IAudioExternalSynthesizer + +// {33E0E76B-70CE-11d1-A826-00C04FBBE8AB} +DEFINE_GUID(IID_IAudioExternalSynthesizer, +0x33e0e76b, 0x70ce, 0x11d1, 0xa8, 0x26, 0x0, 0xc0, 0x4f, 0xbb, 0xe8, 0xab); + +DECLARE_INTERFACE_(IAudioExternalSynthesizer, IUnknown) +{ + STDMETHOD (QueryInterface) (THIS_ REFIID riid, LPVOID *ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; +}; +typedef IAudioExternalSynthesizer *PIAUDIOEXTERNALSYNTHESIZER; + + +#endif // _SPEECH_ diff --git a/speech2/third_party/sapi4/lib/spchwrap.lib b/speech2/third_party/sapi4/lib/spchwrap.lib new file mode 100644 index 0000000..7e73f8b Binary files /dev/null and b/speech2/third_party/sapi4/lib/spchwrap.lib differ diff --git a/speech2/third_party/sapi5/idl/sapi.idl b/speech2/third_party/sapi5/idl/sapi.idl new file mode 100644 index 0000000..130efbd --- /dev/null +++ b/speech2/third_party/sapi5/idl/sapi.idl @@ -0,0 +1,2197 @@ +/**************************************************************************** +* sapi.idl +* +* This is the interface definition file for the Microsoft Speech API +* Version 5.0. +* +* Copyright (c) Microsoft Corporation. All rights reserved. +*****************************************************************************/ + +//--- Compiler Directive ---------------------------------------------------- +cpp_quote("#pragma warning(disable:4201) // Allow nameless structs/unions") + +//--- Includes -------------------------------------------------------------- +import "oaidl.idl"; +import "ocidl.idl"; + +//--- Locally scoped define for LANGID +#ifndef LANGID +#define LANGID WORD +#endif + +//--- Link with sapi.lib +cpp_quote("#pragma comment(lib, \"sapi.lib\")") + +//--- Forward and External Declarations ------------------------------------- + +cpp_quote("#if 0") // Ignore our definition in the .H file +typedef [restricted, hidden] struct WAVEFORMATEX +{ + WORD wFormatTag; /* format type */ + WORD nChannels; /* number of channels (i.e. mono, stereo...) */ + DWORD nSamplesPerSec; /* sample rate */ + DWORD nAvgBytesPerSec; /* for buffer estimation */ + WORD nBlockAlign; /* block size of data */ + WORD wBitsPerSample; /* Number of bits per sample of mono data */ + WORD cbSize; /* The count in bytes of the size of + extra information (after cbSize) */ + +} WAVEFORMATEX; +cpp_quote("#else") +cpp_quote("#include ") +cpp_quote("#endif") + + +//--- Notifications +interface ISpNotifySource; +interface ISpNotifySink; +interface ISpNotifyTranslator; + +//--- Object tokens +interface ISpDataKey; +interface ISpObjectTokenCategory; +interface ISpObjectToken; +interface IEnumSpObjectTokens; +interface ISpObjectWithToken; + +//--- Resource management +interface ISpResourceManager; + +//--- Speech specific events +interface ISpEventSource; +interface ISpEventSink; + +//--- Audio streams +interface ISpStreamFormat; +interface ISpStream; +interface ISpStreamFormatConverter; +interface ISpAudio; +interface ISpMMSysAudio; +interface ISpTranscript; + + +//--- TTS interface +interface ISpVoice; + +//--- SR interfaces +interface ISpRecoResult; +interface ISpRecoContext; +interface ISpRecognizer; +interface ISpProperties; + +//--- Lexicon interfaces +interface ISpLexicon; + +//--- Phone Converter +interface ISpPhoneConverter; + +//--- Phrase interface +interface ISpPhrase; + +// +//--- Constants ------------------------------------------------------------- +// + +//--- DataKey locations +typedef [hidden] enum SPDATAKEYLOCATION +{ + SPDKL_DefaultLocation = 0, + SPDKL_CurrentUser = 1, + SPDKL_LocalMachine = 2, + SPDKL_CurrentConfig = 5 +} SPDATAKEYLOCATION; + +//--- TokenUI constants +cpp_quote("#define SPDUI_EngineProperties L\"EngineProperties\"") +cpp_quote("#define SPDUI_AddRemoveWord L\"AddRemoveWord\"") +cpp_quote("#define SPDUI_UserTraining L\"UserTraining\"") +cpp_quote("#define SPDUI_MicTraining L\"MicTraining\"") +cpp_quote("#define SPDUI_RecoProfileProperties L\"RecoProfileProperties\"") +cpp_quote("#define SPDUI_AudioProperties L\"AudioProperties\"") +cpp_quote("#define SPDUI_AudioVolume L\"AudioVolume\"") + +//--- Data formats - these are used by the CSpStreamFormat class in sphelper.h +typedef [hidden] enum SPSTREAMFORMAT +{ + SPSF_Default = -1, + SPSF_NoAssignedFormat = 0, // Similar to GUID_NULL + SPSF_Text, + SPSF_NonStandardFormat, // Non-SAPI 5.1 standard format with no WAVEFORMATEX description + SPSF_ExtendedAudioFormat, // Non-SAPI 5.1 standard format but has WAVEFORMATEX description + // Standard PCM wave formats + SPSF_8kHz8BitMono, + SPSF_8kHz8BitStereo, + SPSF_8kHz16BitMono, + SPSF_8kHz16BitStereo, + SPSF_11kHz8BitMono, + SPSF_11kHz8BitStereo, + SPSF_11kHz16BitMono, + SPSF_11kHz16BitStereo, + SPSF_12kHz8BitMono, + SPSF_12kHz8BitStereo, + SPSF_12kHz16BitMono, + SPSF_12kHz16BitStereo, + SPSF_16kHz8BitMono, + SPSF_16kHz8BitStereo, + SPSF_16kHz16BitMono, + SPSF_16kHz16BitStereo, + SPSF_22kHz8BitMono, + SPSF_22kHz8BitStereo, + SPSF_22kHz16BitMono, + SPSF_22kHz16BitStereo, + SPSF_24kHz8BitMono, + SPSF_24kHz8BitStereo, + SPSF_24kHz16BitMono, + SPSF_24kHz16BitStereo, + SPSF_32kHz8BitMono, + SPSF_32kHz8BitStereo, + SPSF_32kHz16BitMono, + SPSF_32kHz16BitStereo, + SPSF_44kHz8BitMono, + SPSF_44kHz8BitStereo, + SPSF_44kHz16BitMono, + SPSF_44kHz16BitStereo, + SPSF_48kHz8BitMono, + SPSF_48kHz8BitStereo, + SPSF_48kHz16BitMono, + SPSF_48kHz16BitStereo, + // TrueSpeech format + SPSF_TrueSpeech_8kHz1BitMono, + // A-Law formats + SPSF_CCITT_ALaw_8kHzMono, + SPSF_CCITT_ALaw_8kHzStereo, + SPSF_CCITT_ALaw_11kHzMono, + SPSF_CCITT_ALaw_11kHzStereo, + SPSF_CCITT_ALaw_22kHzMono, + SPSF_CCITT_ALaw_22kHzStereo, + SPSF_CCITT_ALaw_44kHzMono, + SPSF_CCITT_ALaw_44kHzStereo, + // u-Law formats + SPSF_CCITT_uLaw_8kHzMono, + SPSF_CCITT_uLaw_8kHzStereo, + SPSF_CCITT_uLaw_11kHzMono, + SPSF_CCITT_uLaw_11kHzStereo, + SPSF_CCITT_uLaw_22kHzMono, + SPSF_CCITT_uLaw_22kHzStereo, + SPSF_CCITT_uLaw_44kHzMono, + SPSF_CCITT_uLaw_44kHzStereo, + // ADPCM formats + SPSF_ADPCM_8kHzMono, + SPSF_ADPCM_8kHzStereo, + SPSF_ADPCM_11kHzMono, + SPSF_ADPCM_11kHzStereo, + SPSF_ADPCM_22kHzMono, + SPSF_ADPCM_22kHzStereo, + SPSF_ADPCM_44kHzMono, + SPSF_ADPCM_44kHzStereo, + // GSM 6.10 formats + SPSF_GSM610_8kHzMono, + SPSF_GSM610_11kHzMono, + SPSF_GSM610_22kHzMono, + SPSF_GSM610_44kHzMono, + SPSF_NUM_FORMATS +} SPSTREAMFORMAT; + +cpp_quote("EXTERN_C const GUID SPDFID_Text;") +cpp_quote("EXTERN_C const GUID SPDFID_WaveFormatEx;") + +//--- Root of registry entries for speech use +cpp_quote("#define SPREG_USER_ROOT L\"HKEY_CURRENT_USER\\\\SOFTWARE\\\\Microsoft\\\\Speech\"") +cpp_quote("#define SPREG_LOCAL_MACHINE_ROOT L\"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Speech\"") + +//--- Categories for speech resource management +cpp_quote("#define SPCAT_AUDIOOUT L\"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Speech\\\\AudioOutput\"") +cpp_quote("#define SPCAT_AUDIOIN L\"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Speech\\\\AudioInput\"") +cpp_quote("#define SPCAT_VOICES L\"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Speech\\\\Voices\"") +cpp_quote("#define SPCAT_RECOGNIZERS L\"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Speech\\\\Recognizers\"") +cpp_quote("#define SPCAT_APPLEXICONS L\"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Speech\\\\AppLexicons\"") +cpp_quote("#define SPCAT_PHONECONVERTERS L\"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Speech\\\\PhoneConverters\"") +cpp_quote("#define SPCAT_RECOPROFILES L\"HKEY_CURRENT_USER\\\\SOFTWARE\\\\Microsoft\\\\Speech\\\\RecoProfiles\"") + +//--- Specific token ids of interest +cpp_quote("#define SPMMSYS_AUDIO_IN_TOKEN_ID L\"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Speech\\\\AudioInput\\\\TokenEnums\\\\MMAudioIn\\\\\"") +cpp_quote("#define SPMMSYS_AUDIO_OUT_TOKEN_ID L\"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Speech\\\\AudioOutput\\\\TokenEnums\\\\MMAudioOut\\\\\"") +cpp_quote("#define SPCURRENT_USER_LEXICON_TOKEN_ID L\"HKEY_CURRENT_USER\\\\SOFTWARE\\\\Microsoft\\\\Speech\\\\CurrentUserLexicon\"") + +//--- Standard token values +cpp_quote("#define SPTOKENVALUE_CLSID L\"CLSID\"") +cpp_quote("#define SPTOKENKEY_FILES L\"Files\"") +cpp_quote("#define SPTOKENKEY_UI L\"UI\"") +cpp_quote("#define SPTOKENKEY_ATTRIBUTES L\"Attributes\"") + +//--- Standard voice category values +cpp_quote("#define SPVOICECATEGORY_TTSRATE L\"DefaultTTSRate\"") + +//--- Standard SR Engine properties +cpp_quote("#define SPPROP_RESOURCE_USAGE L\"ResourceUsage\"") +cpp_quote("#define SPPROP_HIGH_CONFIDENCE_THRESHOLD L\"HighConfidenceThreshold\"") +cpp_quote("#define SPPROP_NORMAL_CONFIDENCE_THRESHOLD L\"NormalConfidenceThreshold\"") +cpp_quote("#define SPPROP_LOW_CONFIDENCE_THRESHOLD L\"LowConfidenceThreshold\"") +cpp_quote("#define SPPROP_RESPONSE_SPEED L\"ResponseSpeed\"") +cpp_quote("#define SPPROP_COMPLEX_RESPONSE_SPEED L\"ComplexResponseSpeed\"") +cpp_quote("#define SPPROP_ADAPTATION_ON L\"AdaptationOn\"") + +//--- Standard SAPI Recognition Topics +cpp_quote("#define SPTOPIC_SPELLING L\"Spelling\"") + +// CFG Wildcard token +cpp_quote("#define SPWILDCARD L\"...\"") + +// CFG Dication token +cpp_quote("#define SPDICTATION L\"*\"") +cpp_quote("#define SPINFDICTATION L\"*+\"") + +// CFG confidence scores +const signed char SP_LOW_CONFIDENCE = -1; +const signed char SP_NORMAL_CONFIDENCE = 0; +const signed char SP_HIGH_CONFIDENCE = +1; + +// CFG default weight +const float DEFAULT_WEIGHT = 1.0; + +// Lexicon word and pronunciation limits +const ULONG SP_MAX_WORD_LENGTH = 128; +const ULONG SP_MAX_PRON_LENGTH = 384; + +// +//--- Interface definitions ------------------------------------------------- +// + +//--- ISpNotifyCallback ----------------------------------------------------- + +cpp_quote("#if defined(__cplusplus)") +cpp_quote("interface ISpNotifyCallback") +cpp_quote("{") +cpp_quote("virtual HRESULT STDMETHODCALLTYPE NotifyCallback(") +cpp_quote(" WPARAM wParam,") +cpp_quote(" LPARAM lParam) = 0;") +cpp_quote("};") +cpp_quote("#else") +typedef void * ISpNotifyCallback; +cpp_quote("#endif") + +cpp_quote("#if 0") +typedef void * SPNOTIFYCALLBACK; +cpp_quote("#else") +cpp_quote("typedef void __stdcall SPNOTIFYCALLBACK(WPARAM wParam, LPARAM lParam);") +cpp_quote("#endif") + +//--- ISpNotifySource ------------------------------------------------------- +[ + object, + uuid(5EFF4AEF-8487-11D2-961C-00C04F8EE628), + helpstring("ISpNotifySource Interface"), + pointer_default(unique), + restricted +] +interface ISpNotifySource : IUnknown +{ + HRESULT SetNotifySink([in] ISpNotifySink * pNotifySink); + [local] HRESULT SetNotifyWindowMessage( + [in] HWND hWnd, + [in] UINT Msg, + [in] WPARAM wParam, + [in] LPARAM lParam); + [local] HRESULT SetNotifyCallbackFunction( + [in] SPNOTIFYCALLBACK * pfnCallback, + [in] WPARAM wParam, + [in] LPARAM lParam); + [local] HRESULT SetNotifyCallbackInterface( + [in] ISpNotifyCallback * pSpCallback, + [in] WPARAM wParam, + [in] LPARAM lParam); + [local] HRESULT SetNotifyWin32Event(void); + [local] HRESULT WaitForNotifyEvent([in] DWORD dwMilliseconds); + [local] HANDLE GetNotifyEventHandle(); +} + +//--- ISpNotifySink --------------------------------------------------------- +[ + object, + uuid(259684DC-37C3-11D2-9603-00C04F8EE628), + helpstring("ISpNotifySink Interface"), + pointer_default(unique), + restricted +] +interface ISpNotifySink : IUnknown +{ + HRESULT Notify(void); +} + + +//--- ISpNotifyTranslator --------------------------------------------------- +[ + object, + uuid(ACA16614-5D3D-11D2-960E-00C04F8EE628), + helpstring("ISpNotifyTranslator Interface"), + pointer_default(unique), + local, + restricted +] +interface ISpNotifyTranslator : ISpNotifySink +{ + HRESULT InitWindowMessage( + [in] HWND hWnd, + [in] UINT Msg, + [in] WPARAM wParam, + [in] LPARAM lParam); + HRESULT InitCallback( + [in] SPNOTIFYCALLBACK * pfnCallback, + [in] WPARAM wParam, + [in] LPARAM lParam); + HRESULT InitSpNotifyCallback( + [in] ISpNotifyCallback * pSpCallback, + [in] WPARAM wParam, + [in] LPARAM lParam); + + HRESULT InitWin32Event( + HANDLE hEvent, + BOOL fCloseHandleOnRelease); + HRESULT Wait([in] DWORD dwMilliseconds); + HANDLE GetEventHandle(); +} + + +//--- ISpDataKey ------------------------------------------------------------ +[ + object, + uuid(14056581-E16C-11D2-BB90-00C04F8EE6C0), + helpstring("ISpDataKey Interface"), + pointer_default(unique), + restricted +] +interface ISpDataKey : IUnknown +{ + HRESULT SetData( const WCHAR * pszValueName, ULONG cbData, const BYTE * pData); + HRESULT GetData( const WCHAR * pszValueName, ULONG * pcbData, BYTE * pData); + HRESULT SetStringValue( const WCHAR * pszValueName, const WCHAR * pszValue ); + HRESULT GetStringValue( const WCHAR * pszValueName, WCHAR ** ppszValue); + HRESULT SetDWORD(const WCHAR * pszValueName, DWORD dwValue ); + HRESULT GetDWORD(const WCHAR * pszValueName, DWORD *pdwValue ); + HRESULT OpenKey(const WCHAR * pszSubKeyName, ISpDataKey ** ppSubKey); + HRESULT CreateKey(const WCHAR * pszSubKey, ISpDataKey ** ppSubKey); + HRESULT DeleteKey(const WCHAR * pszSubKey); + HRESULT DeleteValue(const WCHAR * pszValueName); + HRESULT EnumKeys(ULONG Index, WCHAR ** ppszSubKeyName); + HRESULT EnumValues(ULONG Index, WCHAR ** ppszValueName); +}; + +//--- ISpRegDataKey --------------------------------------------------------- +[ + object, + uuid(92A66E2B-C830-4149-83DF-6FC2BA1E7A5B), + helpstring("ISpRegDataKey"), + pointer_default(unique), + restricted +] +interface ISpRegDataKey : ISpDataKey +{ + [local] HRESULT SetKey([in] HKEY hkey, [in] BOOL fReadOnly); +} + +//--- ISpObjectTokenCategory ------------------------------------------------ +[ + object, + uuid(2D3D3845-39AF-4850-BBF9-40B49780011D), + helpstring("ISpObjectTokenCategory"), + pointer_default(unique), + restricted +] +interface ISpObjectTokenCategory : ISpDataKey +{ + HRESULT SetId([in] const WCHAR * pszCategoryId, BOOL fCreateIfNotExist); + HRESULT GetId([out] WCHAR ** ppszCoMemCategoryId); + HRESULT GetDataKey(SPDATAKEYLOCATION spdkl, ISpDataKey ** ppDataKey); + + HRESULT EnumTokens( + [in, string] const WCHAR * pzsReqAttribs, + [in, string] const WCHAR * pszOptAttribs, + [out] IEnumSpObjectTokens ** ppEnum); + + HRESULT SetDefaultTokenId([in] const WCHAR * pszTokenId); + HRESULT GetDefaultTokenId([out] WCHAR ** ppszCoMemTokenId); +}; + +//--- ISpObjectToken -------------------------------------------------------- +[ + object, + uuid(14056589-E16C-11D2-BB90-00C04F8EE6C0), + helpstring("ISpObjectToken Interface"), + pointer_default(unique), + restricted +] +interface ISpObjectToken : ISpDataKey +{ + HRESULT SetId(const WCHAR * pszCategoryId, const WCHAR * pszTokenId, BOOL fCreateIfNotExist); + HRESULT GetId(WCHAR ** ppszCoMemTokenId); + HRESULT GetCategory(ISpObjectTokenCategory ** ppTokenCategory); + + HRESULT CreateInstance( + [in] IUnknown * pUnkOuter, + [in] DWORD dwClsContext, + [in] REFIID riid, + [out, iid_is(riid)] void ** ppvObject); + + HRESULT GetStorageFileName( + [in] REFCLSID clsidCaller, + [in] const WCHAR * pszValueName, + [in] const WCHAR * pszFileNameSpecifier, + [in] ULONG nFolder, // Same as SHGetFolderPath -- If non-zero, must set CSIDL_FLAG_CREATE + [out] WCHAR ** ppszFilePath); + HRESULT RemoveStorageFileName( + [in] REFCLSID clsidCaller, + [in] const WCHAR * pszKeyName, + [in] BOOL fDeleteFile); + + HRESULT Remove(const CLSID * pclsidCaller); + + [local] HRESULT IsUISupported( + [in] const WCHAR * pszTypeOfUI, + [in] void * pvExtraData, + [in] ULONG cbExtraData, + [in] IUnknown * punkObject, + [out] BOOL *pfSupported); + [local] HRESULT DisplayUI( + [in] HWND hwndParent, + [in] const WCHAR * pszTitle, + [in] const WCHAR * pszTypeOfUI, + [in] void * pvExtraData, + [in] ULONG cbExtraData, + [in] IUnknown * punkObject); + HRESULT MatchesAttributes( + [in] const WCHAR * pszAttributes, + [out] BOOL *pfMatches); +}; + +[ + object, + uuid(B8AAB0CF-346F-49D8-9499-C8B03F161D51), + helpstring("ISpObjectTokenInit Interface"), + pointer_default(unique), + restricted +] +interface ISpObjectTokenInit : ISpObjectToken +{ + HRESULT InitFromDataKey( + [in] const WCHAR * pszCategoryId, + [in] const WCHAR * pszTokenId, + [in] ISpDataKey * pDataKey); +}; + +//--- IEnumSpObjectTokens --------------------------------------------------- +// This interface is used to enumerate speech object tokens + +[ + object, + uuid(06B64F9E-7FDA-11D2-B4F2-00C04F797396), + helpstring("IEnumSpObjectTokens Interface"), + pointer_default(unique), + restricted +] +interface IEnumSpObjectTokens : IUnknown +{ + HRESULT Next([in] ULONG celt, + [out, size_is(celt), length_is(*pceltFetched)] ISpObjectToken ** pelt, + [out] ULONG *pceltFetched); + HRESULT Skip([in] ULONG celt); + + HRESULT Reset(void); + HRESULT Clone([out] IEnumSpObjectTokens **ppEnum); + + HRESULT Item([in] ULONG Index, [out] ISpObjectToken ** ppToken); + + HRESULT GetCount([out] ULONG* pCount); +}; + +//--- ISpObjectWithToken ---------------------------------------------------- +[ + object, + uuid(5B559F40-E952-11D2-BB91-00C04F8EE6C0), + helpstring("ISpObjectWithToken Interface"), + pointer_default(unique), + restricted +] +interface ISpObjectWithToken : IUnknown +{ + HRESULT SetObjectToken(ISpObjectToken * pToken); + HRESULT GetObjectToken(ISpObjectToken ** ppToken); +}; + +//--- ISpResourceManager ---------------------------------------------------- +[ + object, + uuid(93384E18-5014-43D5-ADBB-A78E055926BD), + helpstring("ISpResourceManager Interface"), + pointer_default(unique), + restricted +] +#ifdef _WIN32_WCE +interface ISpResourceManager : IUnknown //IServiceProvider +#else +interface ISpResourceManager : IServiceProvider +#endif // _WIN32_WCE +{ + HRESULT SetObject( + [in] REFGUID guidServiceId, + [in] IUnknown *pUnkObject); + HRESULT GetObject( + [in] REFGUID guidServiceId, + [in] REFCLSID ObjectCLSID, + [in] REFIID ObjectIID, + [in] BOOL fReleaseWhenLastExternalRefReleased, + [out, iid_is(ObjectIID)] void** ppObject); +}; + +//--- ISpEventSource -------------------------------------------------------- +typedef [hidden] enum SPEVENTLPARAMTYPE +{ + SPET_LPARAM_IS_UNDEFINED = 0, + SPET_LPARAM_IS_TOKEN, + SPET_LPARAM_IS_OBJECT, + SPET_LPARAM_IS_POINTER, + SPET_LPARAM_IS_STRING, +} SPEVENTLPARAMTYPE; + +typedef [hidden] enum SPEVENTENUM +{ + SPEI_UNDEFINED = 0, + + //--- TTS engine + SPEI_START_INPUT_STREAM = 1, + SPEI_END_INPUT_STREAM = 2, + SPEI_VOICE_CHANGE = 3, // LPARAM_IS_TOKEN + SPEI_TTS_BOOKMARK = 4, // LPARAM_IS_STRING + SPEI_WORD_BOUNDARY = 5, + SPEI_PHONEME = 6, + SPEI_SENTENCE_BOUNDARY = 7, + SPEI_VISEME = 8, + SPEI_TTS_AUDIO_LEVEL = 9, // wParam contains current output audio level + + //--- Engine vendors use these reserved bits + SPEI_TTS_PRIVATE = 15, + + SPEI_MIN_TTS = 1, + SPEI_MAX_TTS = 15, + + //--- Speech Recognition + SPEI_END_SR_STREAM = 34, // LPARAM contains HRESULT, WPARAM contains flags (SPESF_xxx) + SPEI_SOUND_START = 35, + SPEI_SOUND_END = 36, + SPEI_PHRASE_START = 37, + SPEI_RECOGNITION = 38, + SPEI_HYPOTHESIS = 39, + SPEI_SR_BOOKMARK = 40, + SPEI_PROPERTY_NUM_CHANGE = 41, // LPARAM points to a string, WPARAM is the attrib value + SPEI_PROPERTY_STRING_CHANGE= 42, // LPARAM pointer to buffer. Two concatinated null terminated strings. + SPEI_FALSE_RECOGNITION = 43, // apparent speech with no valid recognition + SPEI_INTERFERENCE = 44, // LPARAM is any combination of SPINTERFERENCE flags + SPEI_REQUEST_UI = 45, // LPARAM is string. + SPEI_RECO_STATE_CHANGE = 46, // wParam contains new reco state + SPEI_ADAPTATION = 47, // we are now ready to accept the adaptation buffer + SPEI_START_SR_STREAM = 48, + SPEI_RECO_OTHER_CONTEXT = 49, // Phrase finished and recognized, but for other context + SPEI_SR_AUDIO_LEVEL = 50, // wParam contains current input audio level + + //--- Engine vendors use these reserved bits + SPEI_SR_PRIVATE = 52, + + SPEI_MIN_SR = 34, + SPEI_MAX_SR = 52, + + SPEI_RESERVED1 = 30, // do not use + SPEI_RESERVED2 = 33, // do not use + SPEI_RESERVED3 = 63 // do not use +} SPEVENTENUM; + +cpp_quote("#define SPFEI_FLAGCHECK ( (1ui64 << SPEI_RESERVED1) | (1ui64 << SPEI_RESERVED2) )") + +cpp_quote("#define SPFEI_ALL_TTS_EVENTS (0x000000000000FFFEui64 | SPFEI_FLAGCHECK)") +cpp_quote("#define SPFEI_ALL_SR_EVENTS (0x001FFFFC00000000ui64 | SPFEI_FLAGCHECK)") +cpp_quote("#define SPFEI_ALL_EVENTS 0xEFFFFFFFFFFFFFFFui64") + +// The SPFEI macro converts an SPEVENTENUM event value into a 64-bit value. +// Multiple values can then be OR-ed together and passed to SetInterest. +cpp_quote("#define SPFEI(SPEI_ord) ((1ui64 << SPEI_ord) | SPFEI_FLAGCHECK)") + +// SPEVENT is defined 2 ways, because the current version of MIDL does not allow enumerations +// to be used as bit fields. So we define eEventId and elParamType as int bitfields for MIDL +// and redefine them as their appropriate enumerations for C++ +cpp_quote("#if 0") +typedef [restricted, hidden] struct SPEVENT +{ + WORD eEventId; //SPEVENTENUM + WORD elParamType; //SPEVENTLPARAMTYPE + ULONG ulStreamNum; // Input stream number this event is associated with + ULONGLONG ullAudioStreamOffset; + WPARAM wParam; + LPARAM lParam; +} SPEVENT; + +typedef [restricted, hidden] struct SPSERIALIZEDEVENT +{ + WORD eEventId; //SPEVENTENUM + WORD elParamType; //SPEVENTLPARAMTYPE + ULONG ulStreamNum; // Input stream number this event is associated with + ULONGLONG ullAudioStreamOffset; + ULONG SerializedwParam; + LONG SerializedlParam; +} SPSERIALIZEDEVENT; + +typedef [restricted, hidden] struct SPSERIALIZEDEVENT64 +{ + WORD eEventId; //SPEVENTENUM + WORD elParamType; //SPEVENTLPARAMTYPE + ULONG ulStreamNum; // Input stream number this event is associated with + ULONGLONG ullAudioStreamOffset; + ULONGLONG SerializedwParam; + LONGLONG SerializedlParam; +} SPSERIALIZEDEVENT64; + +cpp_quote("#else") +cpp_quote("typedef struct SPEVENT") +cpp_quote("{") +cpp_quote(" SPEVENTENUM eEventId : 16;") +cpp_quote(" SPEVENTLPARAMTYPE elParamType : 16;") +cpp_quote(" ULONG ulStreamNum;") +cpp_quote(" ULONGLONG ullAudioStreamOffset;") +cpp_quote(" WPARAM wParam;") +cpp_quote(" LPARAM lParam;") +cpp_quote("} SPEVENT;") +cpp_quote("typedef struct SPSERIALIZEDEVENT") +cpp_quote("{") +cpp_quote(" SPEVENTENUM eEventId : 16;") +cpp_quote(" SPEVENTLPARAMTYPE elParamType : 16;") +cpp_quote(" ULONG ulStreamNum;") +cpp_quote(" ULONGLONG ullAudioStreamOffset;") +cpp_quote(" ULONG SerializedwParam;") +cpp_quote(" LONG SerializedlParam;") +cpp_quote("} SPSERIALIZEDEVENT;") +cpp_quote("typedef struct SPSERIALIZEDEVENT64") +cpp_quote("{") +cpp_quote(" SPEVENTENUM eEventId : 16;") +cpp_quote(" SPEVENTLPARAMTYPE elParamType : 16;") +cpp_quote(" ULONG ulStreamNum;") +cpp_quote(" ULONGLONG ullAudioStreamOffset;") +cpp_quote(" ULONGLONG SerializedwParam;") +cpp_quote(" LONGLONG SerializedlParam;") +cpp_quote("} SPSERIALIZEDEVENT64;") +cpp_quote("#endif") + +//--- Types of interference +typedef [hidden] enum SPINTERFERENCE +{ + SPINTERFERENCE_NONE = 0, + SPINTERFERENCE_NOISE, + SPINTERFERENCE_NOSIGNAL, + SPINTERFERENCE_TOOLOUD, + SPINTERFERENCE_TOOQUIET, + SPINTERFERENCE_TOOFAST, + SPINTERFERENCE_TOOSLOW +} SPINTERFERENCE; + +//--- Flags for END_SR_STREAM event (in WPARAM) +typedef [hidden] enum SPENDSRSTREAMFLAGS +{ + SPESF_NONE = 0, + SPESF_STREAM_RELEASED = (1 << 0) +} SPENDSRSTREAMFLAGS; + +//--- Viseme features +typedef [hidden] enum SPVFEATURE +{ + SPVFEATURE_STRESSED = (1L << 0), + SPVFEATURE_EMPHASIS = (1L << 1) +} SPVFEATURE; + + +//--- Viseme event groups +typedef [hidden] enum SPVISEMES +{ + // English examples + //------------------ + SP_VISEME_0 = 0, // Silence + SP_VISEME_1, // AE, AX, AH + SP_VISEME_2, // AA + SP_VISEME_3, // AO + SP_VISEME_4, // EY, EH, UH + SP_VISEME_5, // ER + SP_VISEME_6, // y, IY, IH, IX + SP_VISEME_7, // w, UW + SP_VISEME_8, // OW + SP_VISEME_9, // AW + SP_VISEME_10, // OY + SP_VISEME_11, // AY + SP_VISEME_12, // h + SP_VISEME_13, // r + SP_VISEME_14, // l + SP_VISEME_15, // s, z + SP_VISEME_16, // SH, CH, JH, ZH + SP_VISEME_17, // TH, DH + SP_VISEME_18, // f, v + SP_VISEME_19, // d, t, n + SP_VISEME_20, // k, g, NG + SP_VISEME_21, // p, b, m +} SPVISEMES; + +typedef [restricted, hidden] struct SPEVENTSOURCEINFO +{ + ULONGLONG ullEventInterest; + ULONGLONG ullQueuedInterest; + ULONG ulCount; +} SPEVENTSOURCEINFO; + +[ + object, + uuid(BE7A9CCE-5F9E-11D2-960F-00C04F8EE628), + helpstring("ISpEventSource Interface"), + pointer_default(unique), + local, + restricted +] +interface ISpEventSource : ISpNotifySource +{ + // It is neccessary to use the SPFEI macro to convert the + // SPEVENTENUM values into ULONGULONG values. + HRESULT SetInterest( + [in] ULONGLONG ullEventInterest, + [in] ULONGLONG ullQueuedInterest); + + HRESULT GetEvents( + [in] ULONG ulCount, + [out, size_is(ulCount)] SPEVENT* pEventArray, + [out] ULONG *pulFetched); + + HRESULT GetInfo([out] SPEVENTSOURCEINFO * pInfo); +}; + +//--- ISpEventSink --------------------------------------------------------- +[ + object, + uuid(BE7A9CC9-5F9E-11D2-960F-00C04F8EE628), + helpstring("ISpEventSink Interface"), + pointer_default(unique), + local, + restricted +] +interface ISpEventSink : IUnknown +{ + HRESULT AddEvents([in] const SPEVENT* pEventArray, [in] ULONG ulCount); + HRESULT GetEventInterest([out] ULONGLONG * pullEventInterest); +}; + + +//--- ISpStreamFormat ------------------------------------------------------- +[ + object, + uuid(BED530BE-2606-4F4D-A1C0-54C5CDA5566F), + helpstring("ISpStreamFormat Interface"), + pointer_default(unique), + restricted +] +interface ISpStreamFormat : IStream +{ + HRESULT GetFormat(GUID * pguidFormatId, WAVEFORMATEX ** ppCoMemWaveFormatEx); +} + +typedef [hidden] enum SPFILEMODE +{ + SPFM_OPEN_READONLY, // Open existing file, read-only + SPFM_OPEN_READWRITE, // (Not supported for wav files) Open existing file, read-write + SPFM_CREATE, // (Not supported for wav files) Open file if exists, else create if does not exist (opens read-write) + SPFM_CREATE_ALWAYS, // Create file even if file exists. Destroys old file. + SPFM_NUM_MODES // Used for limit checking +} SPFILEMODE; + +//--- ISpStream ------------------------------------------------------------- + +[ + object, + uuid(12E3CCA9-7518-44C5-A5E7-BA5A79CB929E), + helpstring("ISpStream Interface"), + pointer_default(unique), + restricted +] +interface ISpStream : ISpStreamFormat +{ + HRESULT SetBaseStream(IStream * pStream, REFGUID rguidFormat, const WAVEFORMATEX * pWaveFormatEx); + HRESULT GetBaseStream(IStream ** ppStream); + HRESULT BindToFile(const WCHAR * pszFileName, SPFILEMODE eMode, + const GUID * pFormatId, const WAVEFORMATEX * pWaveFormatEx, + ULONGLONG ullEventInterest); + HRESULT Close(); +} + +//--- ISpStreamFormatConverter ---------------------------------------------- +[ + object, + uuid(678A932C-EA71-4446-9B41-78FDA6280A29), + helpstring("ISpStreamFormatConverter Interface"), + pointer_default(unique), + restricted +] +interface ISpStreamFormatConverter : ISpStreamFormat +{ + HRESULT SetBaseStream( + [in] ISpStreamFormat * pStream, + [in] BOOL fSetFormatToBaseStreamFormat, // If true, then format of format converter stream + [in] BOOL fWriteToBaseStream ); // will be set to same format as bass stream + // (set up as a pass-through). If pStream == NULL + // and this is set to TRUE, then format of stream is reset + HRESULT GetBaseStream([out] ISpStreamFormat **ppStream); + + HRESULT SetFormat([in] REFGUID rguidFormatIdOfConvertedStream, [in] const WAVEFORMATEX * pWaveFormatExOfConvertedStream); + // Note: GetFormat method of ISpStreamFormat returns the format of the converted stream. + + HRESULT ResetSeekPosition(); + + HRESULT ScaleConvertedToBaseOffset( + [in] ULONGLONG ullOffsetConvertedStream, + [out] ULONGLONG * pullOffsetBaseStream); + + HRESULT ScaleBaseToConvertedOffset( + [in] ULONGLONG ullOffsetBaseStream, + [out] ULONGLONG * pullOffsetConvertedStream); +}; + +//--- ISpAudio -------------------------------------------------------------- + +typedef [hidden] enum _SPAUDIOSTATE +{ + SPAS_CLOSED, + SPAS_STOP, + SPAS_PAUSE, + SPAS_RUN +} SPAUDIOSTATE; + +typedef [restricted, hidden] struct SPAUDIOSTATUS +{ + long cbFreeBuffSpace; + ULONG cbNonBlockingIO; + SPAUDIOSTATE State; + ULONGLONG CurSeekPos; + ULONGLONG CurDevicePos; + DWORD dwReserved1; + DWORD dwReserved2; +} SPAUDIOSTATUS; + +typedef [restricted, hidden] struct SPAUDIOBUFFERINFO +{ + ULONG ulMsMinNotification; + ULONG ulMsBufferSize; + ULONG ulMsEventBias; +} SPAUDIOBUFFERINFO; + +[ + object, + uuid(C05C768F-FAE8-4EC2-8E07-338321C12452), + helpstring("ISpAudio Interface"), + pointer_default(unique), + local, + restricted +] +interface ISpAudio : ISpStreamFormat +{ + HRESULT SetState([in] SPAUDIOSTATE NewState, [in]ULONGLONG ullReserved ); + HRESULT SetFormat([in] REFGUID rguidFmtId, [in] const WAVEFORMATEX * pWaveFormatEx); + HRESULT GetStatus([out] SPAUDIOSTATUS * pStatus); + HRESULT SetBufferInfo([in] const SPAUDIOBUFFERINFO * pBuffInfo); + HRESULT GetBufferInfo([out] SPAUDIOBUFFERINFO * pBuffInfo); + HRESULT GetDefaultFormat([out] GUID * pFormatId, [out] WAVEFORMATEX ** ppCoMemWaveFormatEx); + HANDLE EventHandle(); + HRESULT GetVolumeLevel([out] ULONG *pLevel); + HRESULT SetVolumeLevel([in] ULONG Level); + HRESULT GetBufferNotifySize([out] ULONG *pcbSize); + HRESULT SetBufferNotifySize([in] ULONG cbSize); +}; + +//--- ISpMMSysAudio --------------------------------------------------------- +[ + object, + uuid(15806F6E-1D70-4B48-98E6-3B1A007509AB), + helpstring("ISpMMSysAudio Interface"), + pointer_default(unique), + local, + restricted +] +interface ISpMMSysAudio : ISpAudio +{ + HRESULT GetDeviceId([out] UINT * puDeviceId); + HRESULT SetDeviceId([in] UINT uDeviceId); + HRESULT GetMMHandle(void ** pHandle); + HRESULT GetLineId([out] UINT *puLineId); + HRESULT SetLineId([in] UINT uLineId); +}; + +//--- ISpTranscript --------------------------------------------------------- +[ + object, + uuid(10F63BCE-201A-11D3-AC70-00C04F8EE6C0), + helpstring("ISpTranscript Interface"), + pointer_default(unique), + restricted +] +interface ISpTranscript : IUnknown +{ + HRESULT GetTranscript([out, string] WCHAR ** ppszTranscript); + HRESULT AppendTranscript([in, string] const WCHAR * pszTranscript); +}; + +//--- Structures used by ISpPhrase interface -------------------------------- + +typedef [hidden] enum SPDISPLYATTRIBUTES +{ + SPAF_ONE_TRAILING_SPACE = 0x02, + SPAF_TWO_TRAILING_SPACES = 0x04, + SPAF_CONSUME_LEADING_SPACES = 0x08, + SPAF_ALL = 0x0F +} SPDISPLAYATTRIBUTES; + +typedef unsigned short SPPHONEID; + +typedef [restricted, hidden] struct SPPHRASEELEMENT +{ + ULONG ulAudioTimeOffset; + ULONG ulAudioSizeTime; // In 100ns units + ULONG ulAudioStreamOffset; + ULONG ulAudioSizeBytes; + ULONG ulRetainedStreamOffset; + ULONG ulRetainedSizeBytes; + const WCHAR * pszDisplayText; + const WCHAR * pszLexicalForm; + const SPPHONEID * pszPronunciation; + BYTE bDisplayAttributes; + signed char RequiredConfidence; + signed char ActualConfidence; + BYTE Reserved; + float SREngineConfidence; +} SPPHRASEELEMENT; + +typedef [restricted, hidden] struct SPPHRASERULE SPPHRASERULE; + +[hidden] struct SPPHRASERULE +{ + const WCHAR * pszName; + ULONG ulId; + ULONG ulFirstElement; + ULONG ulCountOfElements; + const SPPHRASERULE * pNextSibling; + const SPPHRASERULE * pFirstChild; + float SREngineConfidence; + signed char Confidence; +}; + + +typedef [restricted, hidden] struct SPPHRASEPROPERTY SPPHRASEPROPERTY; + +[hidden] struct SPPHRASEPROPERTY +{ + const WCHAR * pszName; + ULONG ulId; + const WCHAR * pszValue; + VARIANT vValue; // Will be VT_BOOL, VT_I4, VT_R4, VT_R8, or VT_BYREF (only for dynamic grammars) + ULONG ulFirstElement; + ULONG ulCountOfElements; + const SPPHRASEPROPERTY* pNextSibling; + const SPPHRASEPROPERTY* pFirstChild; + float SREngineConfidence; + signed char Confidence; +}; + +typedef [restricted, hidden] struct SPPHRASEREPLACEMENT +{ + BYTE bDisplayAttributes; + const WCHAR * pszReplacementText; + ULONG ulFirstElement; + ULONG ulCountOfElements; +} SPPHRASEREPLACEMENT; + +typedef [restricted, hidden] struct SPPHRASE +{ + ULONG cbSize; // Size of structure + LANGID LangID; + WORD wReserved; + ULONGLONG ullGrammarID; + ULONGLONG ftStartTime; + ULONGLONG ullAudioStreamPosition; + ULONG ulAudioSizeBytes; + ULONG ulRetainedSizeBytes; + ULONG ulAudioSizeTime; // In 100ns units + SPPHRASERULE Rule; + const SPPHRASEPROPERTY* pProperties; + const SPPHRASEELEMENT * pElements; + ULONG cReplacements; + const SPPHRASEREPLACEMENT * pReplacements; + GUID SREngineID; + ULONG ulSREnginePrivateDataSize; + const BYTE * pSREnginePrivateData; +} SPPHRASE; + + +//--- Serialized phrase + +typedef [restricted, hidden] struct SPSERIALIZEDPHRASE +{ + ULONG ulSerializedSize; // Size of structure in bytes +} SPSERIALIZEDPHRASE; + + + +typedef [hidden] enum SPVALUETYPE +{ + SPDF_PROPERTY = 0x00000001, + SPDF_REPLACEMENT = 0x00000002, + SPDF_RULE = 0x00000004, + SPDF_DISPLAYTEXT = 0x00000008, + SPDF_LEXICALFORM = 0x00000010, + SPDF_PRONUNCIATION = 0x00000020, + SPDF_AUDIO = 0x00000040, + SPDF_ALTERNATES = 0x00000080, + SPDF_ALL = 0x000000FF +} SPVALUETYPE; + + +// Binary grammar public declaration + +typedef [hidden] struct SPBINARYGRAMMAR +{ + ULONG ulTotalSerializedSize; +} SPBINARYGRAMMAR; + +// Possible arguments for methods that take phrase element start and count + +typedef [hidden] enum SPPHRASERNG +{ + SPPR_ALL_ELEMENTS = -1 +} SPPHRASERNG; +cpp_quote("#define SP_GETWHOLEPHRASE SPPR_ALL_ELEMENTS") +cpp_quote("#define SPRR_ALL_ELEMENTS SPPR_ALL_ELEMENTS") + +cpp_quote("#if 0") +typedef void * SPSTATEHANDLE; +cpp_quote("#else") +cpp_quote("DECLARE_HANDLE(SPSTATEHANDLE);") +cpp_quote("#endif") + + + + +typedef [hidden] enum SPRECOEVENTFLAGS +{ + SPREF_AutoPause = (1 << 0), + SPREF_Emulated = (1 << 1) +} SPRECOEVENTFLAGS; + + + +//--- ISpLexicon ------------------------------------------------------------ +typedef [hidden] enum SPPARTOFSPEECH +{ + //--- SAPI5 public POS category values (bits 28-31) + SPPS_NotOverriden = -1, + SPPS_Unknown = 0, + SPPS_Noun = 0x1000, + SPPS_Verb = 0x2000, + SPPS_Modifier = 0x3000, + SPPS_Function = 0x4000, + SPPS_Interjection = 0x5000 +} SPPARTOFSPEECH; + +typedef [hidden] enum SPLEXICONTYPE +{ + eLEXTYPE_USER = (1L << 0), + eLEXTYPE_APP = (1L << 1), + eLEXTYPE_RESERVED1 = (1L << 2), + eLEXTYPE_RESERVED2 = (1L << 3), + eLEXTYPE_RESERVED3 = (1L << 4), + eLEXTYPE_RESERVED4 = (1L << 5), + eLEXTYPE_RESERVED5 = (1L << 6), + eLEXTYPE_RESERVED6 = (1L << 7), + eLEXTYPE_RESERVED7 = (1L << 8), + eLEXTYPE_RESERVED8 = (1L << 9), + eLEXTYPE_RESERVED9 = (1L << 10), + eLEXTYPE_RESERVED10 = (1L << 11), + eLEXTYPE_PRIVATE1 = (1L << 12), + eLEXTYPE_PRIVATE2 = (1L << 13), + eLEXTYPE_PRIVATE3 = (1L << 14), + eLEXTYPE_PRIVATE4 = (1L << 15), + eLEXTYPE_PRIVATE5 = (1L << 16), + eLEXTYPE_PRIVATE6 = (1L << 17), + eLEXTYPE_PRIVATE7 = (1L << 18), + eLEXTYPE_PRIVATE8 = (1L << 19), + eLEXTYPE_PRIVATE9 = (1L << 20), + eLEXTYPE_PRIVATE10 = (1L << 21), + eLEXTYPE_PRIVATE11 = (1L << 22), + eLEXTYPE_PRIVATE12 = (1L << 23), + eLEXTYPE_PRIVATE13 = (1L << 24), + eLEXTYPE_PRIVATE14 = (1L << 25), + eLEXTYPE_PRIVATE15 = (1L << 26), + eLEXTYPE_PRIVATE16 = (1L << 27), + eLEXTYPE_PRIVATE17 = (1L << 28), + eLEXTYPE_PRIVATE18 = (1L << 29), + eLEXTYPE_PRIVATE19 = (1L << 30), + eLEXTYPE_PRIVATE20 = (1L << 31), +} SPLEXICONTYPE; + +typedef [hidden] enum SPWORDTYPE +{ + eWORDTYPE_ADDED = (1L << 0), + eWORDTYPE_DELETED = (1L << 1) +} SPWORDTYPE; + +typedef [restricted, hidden] struct SPWORDPRONUNCIATION +{ + struct SPWORDPRONUNCIATION * pNextWordPronunciation; + SPLEXICONTYPE eLexiconType; + LANGID LangID; + WORD wReserved; + SPPARTOFSPEECH ePartOfSpeech; + SPPHONEID szPronunciation[1]; +} SPWORDPRONUNCIATION; + +typedef [restricted, hidden] struct SPWORDPRONUNCIATIONLIST +{ + ULONG ulSize; + BYTE * pvBuffer; + SPWORDPRONUNCIATION * pFirstWordPronunciation; +} SPWORDPRONUNCIATIONLIST; + +typedef [restricted, hidden] struct SPWORD +{ + struct SPWORD * pNextWord; + LANGID LangID; + WORD wReserved; + SPWORDTYPE eWordType; + WCHAR * pszWord; + SPWORDPRONUNCIATION * pFirstWordPronunciation; +} SPWORD; + +typedef [restricted, hidden] struct SPWORDLIST +{ + ULONG ulSize; + BYTE * pvBuffer; + SPWORD * pFirstWord; +} SPWORDLIST; + +[ + object, + uuid(DA41A7C2-5383-4DB2-916B-6C1719E3DB58), + helpstring("ISpLexicon Interface"), + pointer_default(unique), + restricted +] +interface ISpLexicon : IUnknown +{ + HRESULT GetPronunciations( + [in] const WCHAR * pszWord, + [in] LANGID LangID, + [in] DWORD dwFlags, + [in, out] SPWORDPRONUNCIATIONLIST * pWordPronunciationList + ); + HRESULT AddPronunciation( + [in] const WCHAR * pszWord, + [in] LANGID LangID, + [in] SPPARTOFSPEECH ePartOfSpeech, + [in] const SPPHONEID * pszPronunciation + ); + HRESULT RemovePronunciation( + [in] const WCHAR * pszWord, + [in] LANGID LangID, + [in] SPPARTOFSPEECH ePartOfSpeech, + [in] const SPPHONEID * pszPronunciation + ); + + HRESULT GetGeneration(DWORD *pdwGeneration); + HRESULT GetGenerationChange( + [in] DWORD dwFlags, + [in, out] DWORD *pdwGeneration, + [in, out] SPWORDLIST * pWordList + ); + + HRESULT GetWords( + [in] DWORD dwFlags, + [in, out] DWORD *pdwGeneration, + [in, out] DWORD * pdwCookie, + [in, out] SPWORDLIST *pWordList + ); +}; + +[ + object, + uuid(8565572F-C094-41CC-B56E-10BD9C3FF044), + + helpstring("ISpContainerLexicon Interface"), + pointer_default(unique), + restricted +] +interface ISpContainerLexicon : ISpLexicon +{ + HRESULT AddLexicon([in] ISpLexicon *pAddLexicon, [in] DWORD dwFlags); +}; + +//--- ISpPhoneConverter ----------------------------------------------------- +[ + object, + uuid(8445C581-0CAC-4A38-ABFE-9B2CE2826455), + helpstring("ISpPhoneConverter Interface"), + pointer_default(unique), + restricted +] +interface ISpPhoneConverter : ISpObjectWithToken +{ + HRESULT PhoneToId([in] const WCHAR * pszPhone, [out] SPPHONEID * pId); + HRESULT IdToPhone([in] const SPPHONEID * pId, [out] WCHAR * pszPhone); +}; + +//--- ISpVoice -------------------------------------------------------------- +// These structures maintain the absolute state of the voice relative to +// the voice's baseline XML state. +typedef [restricted, hidden] struct SPVPITCH +{ + long MiddleAdj; + long RangeAdj; +} SPVPITCH; + +typedef [hidden] enum SPVACTIONS +{ + SPVA_Speak = 0, + SPVA_Silence, + SPVA_Pronounce, + SPVA_Bookmark, + SPVA_SpellOut, + SPVA_Section, + SPVA_ParseUnknownTag +} SPVACTIONS; + +typedef [restricted, hidden] struct SPVCONTEXT +{ + LPCWSTR pCategory; + LPCWSTR pBefore; + LPCWSTR pAfter; +} SPVCONTEXT; + +typedef [restricted, hidden] struct SPVSTATE +{ + //--- Action + SPVACTIONS eAction; + + //--- Running state values + LANGID LangID; + WORD wReserved; + long EmphAdj; + long RateAdj; + ULONG Volume; + SPVPITCH PitchAdj; + ULONG SilenceMSecs; + SPPHONEID* pPhoneIds; // NULL terminated array of phone ids + SPPARTOFSPEECH ePartOfSpeech; + SPVCONTEXT Context; +} SPVSTATE; + +typedef [hidden] enum SPRUNSTATE +{ + SPRS_DONE = (1L << 0), // The voice is done rendering all queued phrases + SPRS_IS_SPEAKING = (1L << 1) // The SpVoice currently has the audio queue claimed +} SPRUNSTATE; + +typedef [hidden] enum SPVLIMITS +{ + SPMIN_VOLUME = 0, + SPMAX_VOLUME = 100, + SPMIN_RATE = -10, + SPMAX_RATE = 10 +} SPVLIMITS; + +typedef [hidden] enum SPVPRIORITY +{ + SPVPRI_NORMAL = 0, + SPVPRI_ALERT = (1L << 0), + SPVPRI_OVER = (1L << 1) +} SPVPRIORITY; + +typedef [restricted, hidden] struct SPVOICESTATUS +{ + ULONG ulCurrentStream; // Current stream being rendered + ULONG ulLastStreamQueued; // Number of the last stream queued + HRESULT hrLastResult; // Result of last speak + DWORD dwRunningState; // SPRUNSTATE + ULONG ulInputWordPos; // Input position of current word being rendered + ULONG ulInputWordLen; // Length of current word being rendered + ULONG ulInputSentPos; // Input position of current sentence being rendered + ULONG ulInputSentLen; // Length of current sentence being rendered + LONG lBookmarkId; // Current bookmark converted to a long integer + SPPHONEID PhonemeId; // Current phoneme id + SPVISEMES VisemeId; // Current viseme + DWORD dwReserved1; // Reserved for future expansion + DWORD dwReserved2; // Reserved for future expansion +} SPVOICESTATUS; + +typedef [hidden] enum SPEAKFLAGS +{ + //--- SpVoice flags + SPF_DEFAULT = 0, // Synchronous, no purge, xml auto detect + SPF_ASYNC = (1L << 0), // Asynchronous call + SPF_PURGEBEFORESPEAK = (1L << 1), // Purge current data prior to speaking this + SPF_IS_FILENAME = (1L << 2), // The string passed to Speak() is a file name + SPF_IS_XML = (1L << 3), // The input text will be parsed for XML markup + SPF_IS_NOT_XML = (1L << 4), // The input text will not be parsed for XML markup + SPF_PERSIST_XML = (1L << 5), // Persists XML global state changes + + //--- Normalizer flags + SPF_NLP_SPEAK_PUNC = (1L << 6), // The normalization processor should speak the punctuation + + //--- Masks + SPF_NLP_MASK = (SPF_NLP_SPEAK_PUNC), + SPF_VOICE_MASK = (SPF_ASYNC|SPF_PURGEBEFORESPEAK|SPF_IS_FILENAME|SPF_IS_XML|SPF_IS_NOT_XML|SPF_NLP_MASK|SPF_PERSIST_XML), + SPF_UNUSED_FLAGS = ~(SPF_VOICE_MASK) +} SPEAKFLAGS; + +[ + object, + uuid(6C44DF74-72B9-4992-A1EC-EF996E0422D4), + helpstring("ISpVoice Interface"), + pointer_default(unique), + restricted +] +interface ISpVoice : ISpEventSource +{ + HRESULT SetOutput( [in] IUnknown * pUnkOutput, [in]BOOL fAllowFormatChanges ); + HRESULT GetOutputObjectToken( [out] ISpObjectToken ** ppObjectToken ); + HRESULT GetOutputStream( [out] ISpStreamFormat ** ppStream ); + + HRESULT Pause( void ); + HRESULT Resume( void ); + + HRESULT SetVoice([in] ISpObjectToken *pToken); + HRESULT GetVoice([out] ISpObjectToken **ppToken); + + HRESULT Speak( + [in, string] const WCHAR* pwcs, + [in] DWORD dwFlags, + [out] ULONG * pulStreamNumber); + HRESULT SpeakStream( + [in] IStream* pStream, // If not ISpStreamFormat supported then SPDFID_Text assumed + [in] DWORD dwFlags, + [out] ULONG * pulStreamNumber); + + HRESULT GetStatus( + [out] SPVOICESTATUS *pStatus, + [out, string] WCHAR ** ppszLastBookmark); + + HRESULT Skip( [in,string]WCHAR* pItemType, [in]long lNumItems, [out]ULONG* pulNumSkipped ); + + HRESULT SetPriority([in] SPVPRIORITY ePriority ); + HRESULT GetPriority([out] SPVPRIORITY* pePriority ); + + HRESULT SetAlertBoundary( [in] SPEVENTENUM eBoundary ); + HRESULT GetAlertBoundary( [out] SPEVENTENUM* peBoundary ); + + HRESULT SetRate([in] long RateAdjust ); + HRESULT GetRate([out] long* pRateAdjust); + + HRESULT SetVolume([in] USHORT usVolume); + HRESULT GetVolume([out] USHORT* pusVolume); + + HRESULT WaitUntilDone([in] ULONG msTimeout); + + HRESULT SetSyncSpeakTimeout([in] ULONG msTimeout); + HRESULT GetSyncSpeakTimeout([out] ULONG * pmsTimeout); + + [local] HANDLE SpeakCompleteEvent(); + + [local] HRESULT IsUISupported( + [in] const WCHAR * pszTypeOfUI, + [in] void * pvExtraData, + [in] ULONG cbExtraData, + [out] BOOL *pfSupported); + [local] HRESULT DisplayUI( + [in] HWND hwndParent, + [in] const WCHAR * pszTitle, + [in] const WCHAR * pszTypeOfUI, + [in] void * pvExtraData, + [in] ULONG cbExtraData); + +}; + + +//--- ISpPhrase interface --------------------------------------------------- +[ + object, + uuid(1A5C0354-B621-4b5a-8791-D306ED379E53), + local, + helpstring("ISpPhrase Interface"), + pointer_default(unique), + restricted +] +interface ISpPhrase : IUnknown +{ + HRESULT GetPhrase([out] SPPHRASE ** ppCoMemPhrase); + HRESULT GetSerializedPhrase([out] SPSERIALIZEDPHRASE ** ppCoMemPhrase); + HRESULT GetText([in] ULONG ulStart, [in] ULONG ulCount, [in] BOOL fUseTextReplacements, + [out] WCHAR ** ppszCoMemText, [out] BYTE * pbDisplayAttributes); + HRESULT Discard([in] DWORD dwValueTypes); +}; + +[ + object, + uuid(8FCEBC98-4E49-4067-9C6C-D86A0E092E3D), + local, + helpstring("ISpPhraseAlt Interface"), + pointer_default(unique), + restricted +] +interface ISpPhraseAlt : ISpPhrase +{ + HRESULT GetAltInfo(ISpPhrase **ppParent, ULONG *pulStartElementInParent, ULONG *pcElementsInParent, + ULONG *pcElementsInAlt); + HRESULT Commit(); +}; + + + +//--- ISpRecoResult --------------------------------------------------------- +typedef [restricted, hidden] struct SPRECORESULTTIMES +{ + FILETIME ftStreamTime; // GetSystemTimeAsFileTime() at start of result + // UTC time as number of 100-nanosecond intervals + // since January 1, 1601 + ULONGLONG ullLength; // length in 100ns units + DWORD dwTickCount; // GetTickCount() at start of result + // milliseconds that have elapsed since the + // system was started. + ULONGLONG ullStart; // 100ns units since start of stream +} SPRECORESULTTIMES; + + +typedef [hidden] struct SPSERIALIZEDRESULT +{ + ULONG ulSerializedSize; // Count in bytes (including this ULONG) of the entire phrase +} SPSERIALIZEDRESULT; + + +[ + object, + uuid(20B053BE-E235-43cd-9A2A-8D17A48B7842), + helpstring("ISpRecoResult Interface"), + pointer_default(unique), + local, + restricted +] +interface ISpRecoResult : ISpPhrase +{ + HRESULT GetResultTimes([out] SPRECORESULTTIMES *pTimes); + + HRESULT GetAlternates( + [in] ULONG ulStartElement, + [in] ULONG cElements, + [in] ULONG ulRequestCount, + [out] ISpPhraseAlt **ppPhrases, + [out] ULONG *pcPhrasesReturned); + + HRESULT GetAudio( + [in] ULONG ulStartElement, + [in] ULONG cElements, + [out] ISpStreamFormat **ppStream); + HRESULT SpeakAudio( + [in] ULONG ulStartElement, + [in] ULONG cElements, + [in] DWORD dwFlags, + [out] ULONG * pulStreamNumber); + + HRESULT Serialize([out] SPSERIALIZEDRESULT ** ppCoMemSerializedResult); + + HRESULT ScaleAudio([in] const GUID * pAudioFormatId, [in] const WAVEFORMATEX *pWaveFormatEx); + + HRESULT GetRecoContext([out] ISpRecoContext ** ppRecoContext); +}; + + + +typedef [hidden] struct tagSPTEXTSELECTIONINFO +{ + ULONG ulStartActiveOffset; + ULONG cchActiveChars; + ULONG ulStartSelection; + ULONG cchSelection; +} SPTEXTSELECTIONINFO; + + +typedef [hidden] enum SPWORDPRONOUNCEABLE +{ + SPWP_UNKNOWN_WORD_UNPRONOUNCEABLE = 0, + SPWP_UNKNOWN_WORD_PRONOUNCEABLE = 1, + SPWP_KNOWN_WORD_PRONOUNCEABLE = 2 +} SPWORDPRONOUNCEABLE; + + +typedef [hidden] enum SPGRAMMARSTATE +{ + SPGS_DISABLED = 0, + SPGS_ENABLED = 1, + SPGS_EXCLUSIVE = 3 +} SPGRAMMARSTATE; + + +typedef [hidden] enum SPCONTEXTSTATE +{ + SPCS_DISABLED = 0, + SPCS_ENABLED = 1, +} SPCONTEXTSTATE; + + +typedef [hidden] enum SPRULESTATE +{ + SPRS_INACTIVE = 0, + SPRS_ACTIVE = 1, + SPRS_ACTIVE_WITH_AUTO_PAUSE = 3 +} SPRULESTATE; + +const ULONGLONG SP_STREAMPOS_ASAP = 0; +const ULONGLONG SP_STREAMPOS_REALTIME = -1; + + + +// Special transition types used only by AddRuleTransition + +cpp_quote("#define SPRULETRANS_TEXTBUFFER (SPSTATEHANDLE)(-1)") +cpp_quote("#define SPRULETRANS_WILDCARD (SPSTATEHANDLE)(-2)") +cpp_quote("#define SPRULETRANS_DICTATION (SPSTATEHANDLE)(-3)") + + +typedef [hidden] enum SPGRAMMARWORDTYPE +{ + SPWT_DISPLAY, + SPWT_LEXICAL, + SPWT_PRONUNCIATION +} SPGRAMMARWORDTYPE; + +typedef [hidden] struct tagSPPROPERTYINFO +{ + const WCHAR * pszName; + ULONG ulId; + const WCHAR * pszValue; + VARIANT vValue; // Must be VT_BOOL, VT_I4, VT_R4, VT_R8, or VT_BYREF (only for dynamic grammars) +} SPPROPERTYINFO; + +typedef [hidden] enum SPCFGRULEATTRIBUTES +{ + SPRAF_TopLevel = (1 << 0), + SPRAF_Active = (1 << 1), + SPRAF_Export = (1 << 2), + SPRAF_Import = (1 << 3), + SPRAF_Interpreter = (1 << 4), + SPRAF_Dynamic = (1 << 5), + // The following flag is only valid at run-time as part of a rule state and + // is not valid to pass as part of a rule definition. + SPRAF_AutoPause = (1 << 16) +} SPCFGRULEATTRIBUTES; + + +[ + object, + uuid(8137828F-591A-4A42-BE58-49EA7EBAAC68), + helpstring("ISpGrammarBuilder Interface"), + pointer_default(unique), + restricted, + local +] +interface ISpGrammarBuilder : IUnknown +{ + HRESULT ResetGrammar([in] LANGID NewLanguage); + + HRESULT GetRule([in] const WCHAR * pszRuleName, + [in] DWORD dwRuleId, + [in] DWORD dwAttributes, + [in] BOOL fCreateIfNotExist, + [out] SPSTATEHANDLE * phInitialState); + HRESULT ClearRule(SPSTATEHANDLE hState); + + HRESULT CreateNewState( + SPSTATEHANDLE hState, + SPSTATEHANDLE * phState); + + HRESULT AddWordTransition( + SPSTATEHANDLE hFromState, + SPSTATEHANDLE hToState, + const WCHAR * psz, // If NULL then epsilon + const WCHAR * pszSeparators, // If NULL then psz points to a single word, else specifies valid separator characters + SPGRAMMARWORDTYPE eWordType, + float Weight, + const SPPROPERTYINFO * pPropInfo); + + HRESULT AddRuleTransition( + SPSTATEHANDLE hFromState, + SPSTATEHANDLE hToState, + SPSTATEHANDLE hRule, // Must be the initial state of the rule + float Weight, + const SPPROPERTYINFO * pPropInfo); + + HRESULT AddResource([in] SPSTATEHANDLE hRuleState, // Any state handle in a rule is OK + [in] const WCHAR * pszResourceName, + [in] const WCHAR * pszResourceValue); + + HRESULT Commit(DWORD dwReserved); +}; + + +// --- Options for Load methods on ISpRecoGrammar +typedef [hidden] enum SPLOADOPTIONS +{ + SPLO_STATIC = 0, + SPLO_DYNAMIC = 1 +} SPLOADOPTIONS; + + + +//--- ISpRecoGrammar ------------------------------------------------------- +[ + object, + uuid(2177DB29-7F45-47D0-8554-067E91C80502), + helpstring("ISpRecoGrammar Interface"), + pointer_default(unique), + restricted, + local +] +interface ISpRecoGrammar : ISpGrammarBuilder +{ + HRESULT GetGrammarId([out] ULONGLONG * pullGrammarId); + HRESULT GetRecoContext([out] ISpRecoContext **ppRecoCtxt); + + // Command and control interfaces + HRESULT LoadCmdFromFile([in, string] const WCHAR * pszFileName, [in] SPLOADOPTIONS Options); + HRESULT LoadCmdFromObject([in] REFCLSID rcid, [in, string] const WCHAR * pszGrammarName, [in] SPLOADOPTIONS Options); + HRESULT LoadCmdFromResource([in] HMODULE hModule, + [in, string] const WCHAR * pszResourceName, + [in, string] const WCHAR * pszResourceType, + [in] WORD wLanguage, + [in] SPLOADOPTIONS Options); + HRESULT LoadCmdFromMemory([in] const SPBINARYGRAMMAR * pGrammar, [in] SPLOADOPTIONS Options); + HRESULT LoadCmdFromProprietaryGrammar( + [in] REFGUID rguidParam, + [in, string] const WCHAR * pszStringParam, + [in] const void * pvDataPrarm, + [in] ULONG cbDataSize, + [in] SPLOADOPTIONS Options); + HRESULT SetRuleState([in, string] const WCHAR * pszName, void * pReserved, + [in] SPRULESTATE NewState); + HRESULT SetRuleIdState([in] ULONG ulRuleId, [in] SPRULESTATE NewState); + + + // Dictation / statistical language model + HRESULT LoadDictation([in, string] const WCHAR * pszTopicName, [in] SPLOADOPTIONS Options); + HRESULT UnloadDictation(); + HRESULT SetDictationState([in] SPRULESTATE NewState); + + // Word sequence buffer + HRESULT SetWordSequenceData([in] const WCHAR * pText, [in] ULONG cchText, [in] const SPTEXTSELECTIONINFO * pInfo); + HRESULT SetTextSelection([in] const SPTEXTSELECTIONINFO * pInfo); + + HRESULT IsPronounceable([in, string] const WCHAR * pszWord, [out] SPWORDPRONOUNCEABLE *pWordPronounceable); + + HRESULT SetGrammarState([in] SPGRAMMARSTATE eGrammarState); + + HRESULT SaveCmd([in] IStream * pStream, [out, optional] WCHAR ** ppszCoMemErrorText); + + HRESULT GetGrammarState([out] SPGRAMMARSTATE * peGrammarState); +}; + + + + + +//--- ISpRecoContext -------------------------------------------------------- +typedef [restricted, hidden] struct SPRECOCONTEXTSTATUS +{ + SPINTERFERENCE eInterference; + WCHAR szRequestTypeOfUI[255]; // If first byte null, there is no UI request + DWORD dwReserved1; + DWORD dwReserved2; +} SPRECOCONTEXTSTATUS; + +typedef [hidden] enum SPBOOKMARKOPTIONS +{ + SPBO_NONE = 0, + SPBO_PAUSE = 1 +} SPBOOKMARKOPTIONS; + + +typedef [hidden] enum SPAUDIOOPTIONS +{ + SPAO_NONE = 0, + SPAO_RETAIN_AUDIO = (1 << 0) +} SPAUDIOOPTIONS; + +[ + object, + uuid(F740A62F-7C15-489E-8234-940A33D9272D), + helpstring("ISpRecoContext Interface"), + pointer_default(unique), + local, + restricted +] +interface ISpRecoContext : ISpEventSource +{ + HRESULT GetRecognizer([out] ISpRecognizer ** ppRecognizer); + + HRESULT CreateGrammar([in] ULONGLONG ullGrammarId, [out] ISpRecoGrammar ** ppGrammar); + + HRESULT GetStatus([out] SPRECOCONTEXTSTATUS *pStatus); + + HRESULT GetMaxAlternates([in] ULONG * pcAlternates); + HRESULT SetMaxAlternates([in] ULONG cAlternates); + + HRESULT SetAudioOptions([in] SPAUDIOOPTIONS Options, [in] const GUID *pAudioFormatId, [in] const WAVEFORMATEX *pWaveFormatEx); + HRESULT GetAudioOptions([in] SPAUDIOOPTIONS * pOptions, [out] GUID *pAudioFormatId, [out] WAVEFORMATEX **ppCoMemWFEX); + + HRESULT DeserializeResult( + [in] const SPSERIALIZEDRESULT * pSerializedResult, + [out] ISpRecoResult **ppResult); + + HRESULT Bookmark([in] SPBOOKMARKOPTIONS Options, [in] ULONGLONG ullStreamPosition, [in] LPARAM lparamEvent); + + HRESULT SetAdaptationData([in, string] const WCHAR *pAdaptationData, [in] const ULONG cch); + + HRESULT Pause( DWORD dwReserved ); + HRESULT Resume( DWORD dwReserved ); + + HRESULT SetVoice([in] ISpVoice *pVoice, [in] BOOL fAllowFormatChanges); + HRESULT GetVoice([out] ISpVoice **ppVoice); + HRESULT SetVoicePurgeEvent([in] ULONGLONG ullEventInterest); + HRESULT GetVoicePurgeEvent([out] ULONGLONG *pullEventInterest); + + HRESULT SetContextState([in] SPCONTEXTSTATE eContextState); + HRESULT GetContextState([in] SPCONTEXTSTATE * peContextState); +}; + + +//--- ISpProperties ------------------------------------------------------------ +[ + object, + uuid(5B4FB971-B115-4DE1-AD97-E482E3BF6EE4), + helpstring("ISpProperties Interface"), + pointer_default(unique), + local, + restricted +] +interface ISpProperties : IUnknown +{ + HRESULT SetPropertyNum( [in]const WCHAR* pName, [in]LONG lValue ); + HRESULT GetPropertyNum( [in]const WCHAR* pName, [out]LONG* plValue ); + HRESULT SetPropertyString( [in]const WCHAR* pName, [in]const WCHAR* pValue ); + HRESULT GetPropertyString( [in]const WCHAR* pName, [out]WCHAR** ppCoMemValue ); +}; + +const ULONG SP_MAX_LANGIDS = 20; // Engine can support up to 20 languages at once + +//--- ISpRecognizer --------------------------------------------------------- +typedef [restricted, hidden] struct SPRECOGNIZERSTATUS +{ + SPAUDIOSTATUS AudioStatus; + ULONGLONG ullRecognitionStreamPos; + ULONG ulStreamNumber; + ULONG ulNumActive; + CLSID clsidEngine; + ULONG cLangIDs; + LANGID aLangID[SP_MAX_LANGIDS]; + DWORD dwReserved1; + DWORD dwReserved2; +} SPRECOGNIZERSTATUS; + +typedef [hidden] enum SPWAVEFORMATTYPE +{ + SPWF_INPUT, // WAVEFORMATEX of audio input source + SPWF_SRENGINE // WAVEFORMATEX of the audio received by the SR engine +} SPSTREAMFORMATTYPE; + +typedef [hidden] enum SPRECOSTATE +{ + SPRST_INACTIVE, // Audio deactivated + SPRST_ACTIVE, // Audio running only if one or more rules are active + SPRST_ACTIVE_ALWAYS, // Audio running regardless of rule state + SPRST_INACTIVE_WITH_PURGE, // State will be set to inactive, but all active audio purged + SPRST_NUM_STATES +} SPRECOSTATE; + + + + +[ + object, + uuid(C2B5F241-DAA0-4507-9E16-5A1EAA2B7A5C), + helpstring("ISpRecognizer Interface"), + pointer_default(unique), + restricted +] +interface ISpRecognizer : ISpProperties +{ + HRESULT SetRecognizer([in] ISpObjectToken * pRecognizer); + HRESULT GetRecognizer([out] ISpObjectToken **ppRecognizer); + + HRESULT SetInput([in] IUnknown * pUnkInput, [in] BOOL fAllowFormatChanges); + HRESULT GetInputObjectToken( [out] ISpObjectToken ** ppToken); + + HRESULT GetInputStream( [out] ISpStreamFormat ** ppStream); + HRESULT CreateRecoContext([out] ISpRecoContext ** ppNewCtxt); + + HRESULT GetRecoProfile([out] ISpObjectToken **ppToken); + HRESULT SetRecoProfile([in] ISpObjectToken *pToken); + + HRESULT IsSharedInstance(void); + + HRESULT GetRecoState([out] SPRECOSTATE *pState); + HRESULT SetRecoState([in] SPRECOSTATE NewState); + + HRESULT GetStatus([out] SPRECOGNIZERSTATUS * pStatus); + HRESULT GetFormat([in] SPSTREAMFORMATTYPE WaveFormatType, [out] GUID *pFormatId, [out] WAVEFORMATEX **ppCoMemWFEX); + + [local] HRESULT IsUISupported( + [in] const WCHAR * pszTypeOfUI, + [in] void * pvExtraData, + [in] ULONG cbExtraData, + [out] BOOL *pfSupported); + [local] HRESULT DisplayUI( + [in] HWND hwndParent, + [in] const WCHAR * pszTitle, + [in] const WCHAR * pszTypeOfUI, + [in] void * pvExtraData, + [in] ULONG cbExtraData); + HRESULT EmulateRecognition([in] ISpPhrase *pPhrase); +}; + + + +// +//=== CoClass definitions ===================================================== +// +[ + helpstring("Microsoft Speech Object Library"), + uuid(C866CA3A-32F7-11D2-9602-00C04F8EE628), + version(5.1) +] +library SpeechLib +{ + importlib("stdole32.tlb"); + importlib("stdole2.tlb"); + + #include "sapiaut.idl" + + //--- SpNotifyTranslator ------------------------------------------------ + [ + uuid(E2AE5372-5D40-11D2-960E-00C04F8EE628), + helpstring("SpNotify"), + restricted, + hidden + ] + coclass SpNotifyTranslator + { + interface ISpNotifyTranslator; + } + + //--- SpObjectTokenCategory --------------------------------------------- + [ + uuid(A910187F-0C7A-45AC-92CC-59EDAFB77B53), + helpstring("SpObjectTokenCategory Class"), + ] + coclass SpObjectTokenCategory + { + [default] interface ISpeechObjectTokenCategory; + interface ISpObjectTokenCategory; + } + //--- SpObjectToken --------------------------------------------- + [ + uuid(EF411752-3736-4CB4-9C8C-8EF4CCB58EFE), + helpstring("SpObjectToken Class") + ] + coclass SpObjectToken + { + [default] interface ISpeechObjectToken; + interface ISpObjectToken; + } + + //--- SpResourceManager ------------------------------------------------- + [ + uuid(96749373-3391-11D2-9EE3-00C04F797396), + helpstring("SpResourceManger"), + restricted, + hidden + ] + coclass SpResourceManager + { + [default] interface ISpResourceManager; + }; + + //--- SpStreamFormatConverter ------------------------------------------- + [ + uuid(7013943A-E2EC-11D2-A086-00C04F8EF9B5), + helpstring("FormatConverter Class"), + restricted, + hidden + ] + coclass SpStreamFormatConverter + { + [default] interface ISpStreamFormatConverter; + }; + + //--- SpMMAudioEnum ----------------------------------------------------- + [ + uuid(AB1890A0-E91F-11D2-BB91-00C04F8EE6C0), + helpstring("SpMMAudioEnum Class"), + restricted, + hidden + ] + coclass SpMMAudioEnum + { + interface IEnumSpObjectTokens; + }; + + //--- SpMMAudioIn ------------------------------------------------------- + [ + uuid(CF3D2E50-53F2-11D2-960C-00C04F8EE628), + helpstring("SpMMAudioIn Class") + ] + coclass SpMMAudioIn + { + [default] interface ISpeechMMSysAudio; + interface ISpEventSource; + interface ISpEventSink; + interface ISpObjectWithToken; + interface ISpMMSysAudio; + }; + + //--- SpMMAudioOut ------------------------------------------------------ + [ + uuid(A8C680EB-3D32-11D2-9EE7-00C04F797396), + helpstring("SpMMAudioOut Class") + ] + coclass SpMMAudioOut + { + [default] interface ISpeechMMSysAudio; + interface ISpEventSource; + interface ISpEventSink; + interface ISpObjectWithToken; + interface ISpMMSysAudio; + }; + + //--- SpRecPlayAudio ------------------------------------------------- + [ + uuid(FEE225FC-7AFD-45E9-95D0-5A318079D911), + helpstring("SpRecPlayAudio Class"), + restricted, + hidden + ] + coclass SpRecPlayAudio + { + interface ISpObjectWithToken; + interface ISpAudio; + }; + + //--- SpStream ---------------------------------------------------------- + [ + uuid(715D9C59-4442-11D2-9605-00C04F8EE628), + helpstring("SpStream Class"), + restricted, + hidden + ] + coclass SpStream + { + interface ISpStream; + }; + + //--- SpVoice ----------------------------------------------------------- + [ + uuid(96749377-3391-11D2-9EE3-00C04F797396), + helpstring("SpVoice Class") + ] + coclass SpVoice + { + [default] interface ISpeechVoice; + interface ISpVoice; + + [default, source] dispinterface _ISpeechVoiceEvents; + }; + + //--- SpSharedRecoContext ----------------------------------------------- + [ + uuid(47206204-5ECA-11D2-960F-00C04F8EE628), + helpstring("SpSharedRecoContext Class") + ] + coclass SpSharedRecoContext + { + [default] interface ISpeechRecoContext; + interface ISpRecoContext; + + [default, source] dispinterface _ISpeechRecoContextEvents; + }; + + //--- SpInprocRecognizer ------------------------------------------------ + [ + uuid(41B89B6B-9399-11D2-9623-00C04F8EE628), + helpstring("SpInprocRecognizer Class") + ] + coclass SpInprocRecognizer + { + [default] interface ISpeechRecognizer; + interface ISpRecognizer; + }; + + //--- SpSharedRecognizer ---------------------------------------------- + [ + uuid(3BEE4890-4FE9-4A37-8C1E-5E7E12791C1F), + helpstring("SpSharedRecognizer Class") + ] + coclass SpSharedRecognizer + { + [default] interface ISpeechRecognizer; + interface ISpRecognizer; + }; + + //--- SpLexicon ---------------------------------------------------------- + [ + uuid(0655E396-25D0-11D3-9C26-00C04F8EF87C), + helpstring("SpLexicon Class") + ] + coclass SpLexicon + { + [default] interface ISpeechLexicon; + interface ISpLexicon; + }; + + //--- SpUnCompressedLexicon --------------------------------------------------- + [ + uuid(C9E37C15-DF92-4727-85D6-72E5EEB6995A), + helpstring("SpUnCompressedLexicon Class") + ] + coclass SpUnCompressedLexicon + { + [default] interface ISpeechLexicon; + interface ISpLexicon; + interface ISpObjectWithToken; + }; + + //--- SpCompressedLexicon --------------------------------------------------- + [ + uuid(90903716-2F42-11D3-9C26-00C04F8EF87C), + helpstring("SpCompressedLexicon Class"), + restricted, + hidden + ] + coclass SpCompressedLexicon + { + [default] interface ISpLexicon; + interface ISpObjectWithToken; + }; + + //--- SpPhoneConverter ------------------------------------------------ + [ + uuid(9185F743-1143-4C28-86B5-BFF14F20E5C8), + helpstring("SpPhoneConverter Class") + ] + coclass SpPhoneConverter + { + [default] interface ISpeechPhoneConverter; + interface ISpPhoneConverter; + }; + + //--- SpNullPhoneConverter ------------------------------------------------ + [ + uuid(455F24E9-7396-4A16-9715-7C0FDBE3EFE3), + helpstring("SpNullPhoneConverter Class"), + restricted, + hidden + ] + coclass SpNullPhoneConverter + { + [default] interface ISpPhoneConverter; + }; + +#ifdef SAPI_AUTOMATION + + //--- SpTextSelectionInformation ------------------------------------------------ + [ + uuid(0F92030A-CBFD-4AB8-A164-FF5985547FF6), + helpstring("SpTextSelectionInformation Class"), + ] + coclass SpTextSelectionInformation + { + [default] interface ISpeechTextSelectionInformation; + }; + + //--- SpPhraseInfoBuilder ------------------------------------------------ + [ + uuid(C23FC28D-C55F-4720-8B32-91F73C2BD5D1), + helpstring("SpPhraseInfoBuilder Class"), + ] + coclass SpPhraseInfoBuilder + { + [default] interface ISpeechPhraseInfoBuilder; + }; + + //--- SpAudioFormat ------------------------------------------------ + [ + uuid(9EF96870-E160-4792-820D-48CF0649E4EC), + helpstring("SpAudioFormat Class"), + ] + coclass SpAudioFormat + { + [default] interface ISpeechAudioFormat; + }; + + //--- SpWaveFormatEx ------------------------------------------------ + [ + uuid(C79A574C-63BE-44b9-801F-283F87F898BE), + helpstring("SpWaveFormatEx Class"), + ] + coclass SpWaveFormatEx + { + [default] interface ISpeechWaveFormatEx; + }; + + //--- SpInProcRecoContext ----------------------------------------------- + [ + uuid(73AD6842-ACE0-45E8-A4DD-8795881A2C2A), + helpstring("SpInProcRecoContext Class") + ] + coclass SpInProcRecoContext + { + [default] interface ISpeechRecoContext; + interface ISpRecoContext; + + [default, source] dispinterface _ISpeechRecoContextEvents; + }; + + //--- SpCustomStream ------------------------------------------------ + [ + uuid(8DBEF13F-1948-4aa8-8CF0-048EEBED95D8), + helpstring("SpCustomStream Class"), + ] + coclass SpCustomStream + { + [default] interface ISpeechCustomStream; + interface ISpStream; + }; + + //--- SpFileStream ------------------------------------------------ + [ + uuid(947812B3-2AE1-4644-BA86-9E90DED7EC91), + helpstring("SpFileStream Class"), + ] + coclass SpFileStream + { + [default] interface ISpeechFileStream; + interface ISpStream; + }; + + //--- SpMemoryStream ------------------------------------------------ + [ + uuid(5FB7EF7D-DFF4-468a-B6B7-2FCBD188F994), + helpstring("SpMemoryStream Class"), + ] + coclass SpMemoryStream + { + [default] interface ISpeechMemoryStream; + interface ISpStream; + }; + + +#endif // SAPI_AUTOMATION +} + diff --git a/speech2/third_party/sapi5/idl/sapiaut.idl b/speech2/third_party/sapi5/idl/sapiaut.idl new file mode 100644 index 0000000..5e7cee7 --- /dev/null +++ b/speech2/third_party/sapi5/idl/sapiaut.idl @@ -0,0 +1,4847 @@ +/**************************************************************************** +* sapiaut.idl +* +* This is the interface definition file for the Microsoft Speech API +* Version 5.0. +* +* It contains definitions for the Automation layer. +* +* Copyright (c) Microsoft Corporation. All rights reserved. +*****************************************************************************/ + +// Includes +import "oaidl.idl"; +import "ocidl.idl"; + +// Token object declarations +interface ISpeechDataKey; +interface ISpeechObjectToken; // Token object +interface ISpeechObjectTokens; // Collection of Token Objects +interface ISpeechObjectTokenCategory; + +// Audio object declarations +interface ISpeechAudioBufferInfo; +interface ISpeechAudioStatus; +interface ISpeechAudioFormat; +interface ISpeechWaveFormatEx; +interface ISpeechBaseStream; +interface ISpeechFileStream; +interface ISpeechMemoryStream; +interface ISpeechCustomStream; +interface ISpeechAudio; +interface ISpeechMMSysAudio; + +// Voice object declarations +interface ISpeechVoice; +interface ISpeechVoiceStatus; +dispinterface _ISpeechVoiceEvents; + +// Recognizer object declarations +interface ISpeechRecognizer; +interface ISpeechRecognizerStatus; +interface ISpeechRecoContext; +interface ISpeechRecoGrammar; +dispinterface _ISpeechRecoContextEvents; + +// Grammar object declarations +interface ISpeechGrammarRule; +interface ISpeechGrammarRules; +interface ISpeechGrammarRuleState; +interface ISpeechGrammarRuleStateTransition; +interface ISpeechGrammarRuleStateTransitions; +interface ISpeechTextSelectionInformation; + +// RecoResult and phrase object declarations +interface ISpeechRecoResult; +interface ISpeechRecoResultTimes; +interface ISpeechPhraseAlternate; +interface ISpeechPhraseAlternates; +interface ISpeechPhraseInfo; +interface ISpeechPhraseElement; +interface ISpeechPhraseElements; +interface ISpeechPhraseReplacement; +interface ISpeechPhraseReplacements; +interface ISpeechPhraseProperty; +interface ISpeechPhraseProperties; +interface ISpeechPhraseRule; +interface ISpeechPhraseRules; + +// Lexicon declarations +interface ISpeechLexicon; +interface ISpeechLexiconWords; +interface ISpeechLexiconWord; +interface ISpeechLexiconPronunciations; +interface ISpeechLexiconPronunciation; + +typedef long SpeechLanguageId; + + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// String constants +// +// +// +// +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Line below (#define) is to work around getting these strings just defined in the typelib (Ignore our definition in the .H file) +// Strings will fail to be defined properly in .H unless they have four backslashes ("\\\\") but for being in the typelib +// can't do this and have the strings defined propertly. So for VC just use the existing SAPI defines in SAPI.IDL. +cpp_quote("#define __SpeechStringConstants_MODULE_DEFINED__") + +[ +uuid(E58442E4-0C80-402c-9559-867337A39765) +] +module SpeechStringConstants +{ + //--- Root of registry entries for speech use + const BSTR SpeechRegistryUserRoot = L"HKEY_CURRENT_USER\SOFTWARE\Microsoft\Speech"; + const BSTR SpeechRegistryLocalMachineRoot = L"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Speech"; + + //--- Object Token Categories for speech resource management + const BSTR SpeechCategoryAudioOut = L"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Speech\AudioOutput"; + const BSTR SpeechCategoryAudioIn = L"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Speech\AudioInput"; + const BSTR SpeechCategoryVoices = L"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Speech\Voices"; + const BSTR SpeechCategoryRecognizers = L"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Speech\Recognizers"; + const BSTR SpeechCategoryAppLexicons = L"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Speech\AppLexicons"; + const BSTR SpeechCategoryPhoneConverters = L"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Speech\PhoneConverters"; + const BSTR SpeechCategoryRecoProfiles = L"HKEY_CURRENT_USER\SOFTWARE\Microsoft\Speech\RecoProfiles"; + + //--- User Lexicon Token Id + const BSTR SpeechTokenIdUserLexicon = L"HKEY_CURRENT_USER\SOFTWARE\Microsoft\Speech\CurrentUserLexicon"; + + //--- Standard token values + const BSTR SpeechTokenValueCLSID = L"CLSID"; + const BSTR SpeechTokenKeyFiles = L"Files"; + const BSTR SpeechTokenKeyUI = L"UI"; + const BSTR SpeechTokenKeyAttributes = L"Attributes"; + + //--- Standard voice category values + const BSTR SpeechVoiceCategoryTTSRate = L"DefaultTTSRate"; + + //--- Standard SR Engine properties + const BSTR SpeechPropertyResourceUsage = L"ResourceUsage"; + const BSTR SpeechPropertyHighConfidenceThreshold = L"HighConfidenceThreshold"; + const BSTR SpeechPropertyNormalConfidenceThreshold = L"NormalConfidenceThreshold"; + const BSTR SpeechPropertyLowConfidenceThreshold = L"LowConfidenceThreshold"; + const BSTR SpeechPropertyResponseSpeed = L"ResponseSpeed"; + const BSTR SpeechPropertyComplexResponseSpeed = L"ComplexResponseSpeed"; + const BSTR SpeechPropertyAdaptationOn = L"AdaptationOn"; + + //--- Standard SAPI Recognition Topics + const BSTR SpeechDictationTopicSpelling = L"Spelling"; + + //--- Special Tags used in SR grammars + const BSTR SpeechGrammarTagWildcard = L"..."; + const BSTR SpeechGrammarTagDictation = L"*"; + const BSTR SpeechGrammarTagUnlimitedDictation = L"*+"; + + //--- TokenUI constants + const BSTR SpeechEngineProperties = L"EngineProperties"; + const BSTR SpeechAddRemoveWord = L"AddRemoveWord"; + const BSTR SpeechUserTraining = L"UserTraining"; + const BSTR SpeechMicTraining = L"MicTraining"; + const BSTR SpeechRecoProfileProperties = L"RecoProfileProperties"; + const BSTR SpeechAudioProperties = L"AudioProperties"; + const BSTR SpeechAudioVolume = L"AudioVolume"; + + //--- ISpeechVoice::Skip constant + const BSTR SpeechVoiceSkipTypeSentence = L"Sentence"; + + // The SpeechAudioFormat object includes a guid that can be used to set the format to + // a custom value. + const BSTR SpeechAudioFormatGUIDWave = L"{C31ADBAE-527F-4ff5-A230-F62BB61FF70C}"; + const BSTR SpeechAudioFormatGUIDText = L"{7CEEF9F9-3D13-11d2-9EE7-00C04F797396}"; + +}; + + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// Number Constants +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +[ +uuid(F3E092B2-6BDC-410f-BCB2-4C5ED4424180) +] +module SpeechConstants +{ + const float Speech_Default_Weight = DEFAULT_WEIGHT; + const LONG Speech_Max_Word_Length = SP_MAX_WORD_LENGTH; + const LONG Speech_Max_Pron_Length = SP_MAX_PRON_LENGTH; + const LONG Speech_StreamPos_Asap = SP_STREAMPOS_ASAP; + const LONG Speech_StreamPos_RealTime = SP_STREAMPOS_REALTIME; + const LONG SpeechAllElements = SPPR_ALL_ELEMENTS; +}; + + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechDataKey +// SAPI C++ Only Interface Equivalent: ISpDataKey Interface +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechDataKey +{ + DISPID_SDKSetBinaryValue = 1, + DISPID_SDKGetBinaryValue, + DISPID_SDKSetStringValue, + DISPID_SDKGetStringValue, + DISPID_SDKSetLongValue, + DISPID_SDKGetlongValue, + DISPID_SDKOpenKey, + DISPID_SDKCreateKey, + DISPID_SDKDeleteKey, + DISPID_SDKDeleteValue, + DISPID_SDKEnumKeys, + DISPID_SDKEnumValues +} DISPID_SpeechDataKey; + +[ + object, + uuid(CE17C09B-4EFA-44d5-A4C9-59D9585AB0CD), + dual, + helpstring("ISpeechDataKey Interface"), + pointer_default(unique) +] +interface ISpeechDataKey : IDispatch +{ + // Methods + + // SetBinaryValue + // SAPI C++ Only Interface Equivalent: SetData + // + [helpstring("SetBinaryValue"), id(DISPID_SDKSetBinaryValue)] + HRESULT SetBinaryValue( [in]const BSTR ValueName, + [in]VARIANT Value ); + + // GetBinaryValue + // SAPI C++ Only Interface Equivalent: GetData + // + [helpstring("GetBinaryValue"), id(DISPID_SDKGetBinaryValue)] + HRESULT GetBinaryValue( [in]const BSTR ValueName, + [out,retval]VARIANT* Value ); + + // SetStringValue + // SAPI C++ Only Interface Equivalent: Same + // + [helpstring("SetStringValue"), id(DISPID_SDKSetStringValue)] + HRESULT SetStringValue( [in]const BSTR ValueName, + [in]const BSTR Value ); + + // GetStringValue + // SAPI C++ Only Interface Equivalent: Same + // + [helpstring("GetStringValue"), id(DISPID_SDKGetStringValue)] + HRESULT GetStringValue( [in]const BSTR ValueName, + [out,retval]BSTR* Value ); + + // SetLongValue + // SAPI C++ Only Interface Equivalent: SetDWORD + // + [helpstring("SetLongValue"), id(DISPID_SDKSetLongValue)] + HRESULT SetLongValue( [in]const BSTR ValueName, + [in]long Value ); + + // GetLongValue + // SAPI C++ Only Interface Equivalent: GetDWORD + // + [helpstring("GetlongValue"), id(DISPID_SDKGetlongValue)] + HRESULT GetLongValue( [in]const BSTR ValueName, + [out,retval]long* Value ); + + // OpenKey + // SAPI C++ Only Interface Equivalent: Same + // + [helpstring("OpenKey"), id(DISPID_SDKOpenKey)] + HRESULT OpenKey( [in]const BSTR SubKeyName, [out,retval]ISpeechDataKey** SubKey ); + + // CreateKey + // SAPI C++ Only Interface Equivalent: Same + // + [helpstring("CreateKey"), id(DISPID_SDKCreateKey)] + HRESULT CreateKey( [in]const BSTR SubKeyName, [out,retval]ISpeechDataKey** SubKey ); + + // DeleteKey + // SAPI C++ Only Interface Equivalent: Same + // + [helpstring("DeleteKey"), id(DISPID_SDKDeleteKey)] + HRESULT DeleteKey( [in]const BSTR SubKeyName ); + + // DeleteValue + // SAPI C++ Only Interface Equivalent: Same + // + [helpstring("DeleteValue"), id(DISPID_SDKDeleteValue)] + HRESULT DeleteValue( [in]const BSTR ValueName ); + + // EnumKeys + // SAPI C++ Only Interface Equivalent: Same + // + [helpstring("EnumKeys"), id(DISPID_SDKEnumKeys)] + HRESULT EnumKeys( [in]long Index, [out,retval]BSTR* SubKeyName ); + + // EnumValues + // SAPI C++ Only Interface Equivalent: Same + // + [helpstring("EnumValues"), id(DISPID_SDKEnumValues)] + HRESULT EnumValues( [in]long Index, [out,retval]BSTR* ValueName ); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechObjectToken +// SAPI C++ Only Interface Equivalent: ISpObjectToken +// Default Property: Id +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechObjectToken +{ + DISPID_SOTId = 1, + DISPID_SOTDataKey, + DISPID_SOTCategory, + DISPID_SOTGetDescription, + DISPID_SOTSetId, + DISPID_SOTGetAttribute, + DISPID_SOTCreateInstance, + DISPID_SOTRemove, + DISPID_SOTGetStorageFileName, + DISPID_SOTRemoveStorageFileName, + DISPID_SOTIsUISupported, + DISPID_SOTDisplayUI, + DISPID_SOTMatchesAttributes +} DISPID_SpeechObjectToken; + +////////////////////////////////// +// +// SpeechDataKeyLocation Enum +// SAPI C++ Only Interface Equivalent: SPDATAKEYLOCATION +// +////////////////////////////////// + +typedef enum SpeechDataKeyLocation +{ + SDKLDefaultLocation = SPDKL_DefaultLocation, + SDKLCurrentUser = SPDKL_CurrentUser, + SDKLLocalMachine = SPDKL_LocalMachine, + SDKLCurrentConfig = SPDKL_CurrentConfig +} SpeechDataKeyLocation; + +#define CLSCTXALL (CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER | CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER) + +////////////////////////////////// +// +// SpeechTokenContext Enum +// SAPI C++ Only Interface Equivalent: N/A +// +////////////////////////////////// + +typedef enum SpeechTokenContext +{ + STCInprocServer = CLSCTX_INPROC_SERVER, + STCInprocHandler = CLSCTX_INPROC_HANDLER, + STCLocalServer = CLSCTX_LOCAL_SERVER, + STCRemoteServer = CLSCTX_REMOTE_SERVER, + STCAll = CLSCTXALL +} SpeechTokenContext; + +////////////////////////////////// +// +// SpeechTokenShellFolder Enum +// SAPI C++ Only Interface Equivalent: N/A +// +////////////////////////////////// + +// CSIDL_* symbols are from SHLOBJ.H +typedef enum SpeechTokenShellFolder +{ + STSF_AppData = 0x001a, // CSIDL_APPDATA, + STSF_LocalAppData = 0x001c, // CSIDL_LOCAL_APPDATA + STSF_CommonAppData = 0x0023, // CSIDL_COMMON_APPDATA + STSF_FlagCreate = 0x8000 // CSIDL_FLAG_CREATE +} SpeechTokenShellFolder; + +[ + object, + uuid(C74A3ADC-B727-4500-A84A-B526721C8B8C), + dual, + helpstring("ISpeechObjectToken Interface"), + pointer_default(unique) +] +interface ISpeechObjectToken : IDispatch +{ + // Properties + + // Id + // SAPI C++ Only Interface Equivalent: GetId + // Default: N/A + // + [propget, helpstring("Id"), id(DISPID_SOTId)] + HRESULT Id( [out,retval]BSTR* ObjectId ); + + // DataKey + // SAPI C++ Only Interface Equivalent: Inherited from ISpDataKey + // Default: N/A + // + [propget, helpstring("DataKey"), id(DISPID_SOTDataKey), hidden] + HRESULT DataKey( [out,retval]ISpeechDataKey** DataKey ); + + // Category + // SAPI C++ Only Interface Equivalent: GetCategory + // Default: N/A + // + [propget, helpstring("Category"), id(DISPID_SOTCategory)] + HRESULT Category( [out,retval]ISpeechObjectTokenCategory** Category); + + // Methods + + // GetDescription + // SAPI C++ Only Interface Equivalent: New + // + [helpstring("GetDescription"), id(DISPID_SOTGetDescription)] + HRESULT GetDescription( [in,defaultvalue(0)]long Locale, + [out,retval]BSTR* Description ); + + // SetId + // SAPI C++ Only Interface Equivalent: Same + // + [helpstring("SetId"), hidden, id(DISPID_SOTSetId)] + HRESULT SetId( [in] BSTR Id, + [in, defaultvalue("")] BSTR CategoryID, + [in, defaultvalue(0)]VARIANT_BOOL CreateIfNotExist); + + // GetAttribute + // SAPI C++ Only Interface Equivalent: Same + // + [helpstring("GetAttribute"), id(DISPID_SOTGetAttribute)] + HRESULT GetAttribute( [in] BSTR AttributeName, + [out, retval]BSTR* AttributeValue); + + // CreateInstance + // SAPI C++ Only Interface Equivalent: Same + // + [helpstring("CreateInstance"), id(DISPID_SOTCreateInstance)] + HRESULT CreateInstance( [in, defaultvalue(NULL)] IUnknown *pUnkOuter, + [in,defaultvalue(STCALL)] SpeechTokenContext ClsContext, + [out, retval]IUnknown **Object); + + // Remove + // SAPI C++ Only Interface Equivalent: Same + // + [helpstring("Remove"), hidden, id(DISPID_SOTRemove)] + HRESULT Remove( [in]BSTR ObjectStorageCLSID ); + + // GetStorageFileName + // SAPI C++ Only Interface Equivalent: Same + // + [helpstring("GetStorageFileName"), hidden, id(DISPID_SOTGetStorageFileName)] + HRESULT GetStorageFileName( [in]BSTR ObjectStorageCLSID, + [in]BSTR KeyName, + [in]BSTR FileName, + [in]SpeechTokenShellFolder Folder, + [out,retval]BSTR* FilePath ); + + // Remove + // SAPI C++ Only Interface Equivalent: Same + // + [helpstring("RemoveStorageFileName"), hidden, id(DISPID_SOTRemoveStorageFileName)] + HRESULT RemoveStorageFileName( [in]BSTR ObjectStorageCLSID, + [in]BSTR KeyName, + [in]VARIANT_BOOL DeleteFile); + + // IsUISupported + // SAPI C++ Only Interface Equivalent: Same + // + [helpstring("IsUISupported"), hidden, id(DISPID_SOTIsUISupported)] + HRESULT IsUISupported( [in]const BSTR TypeOfUI, + [in, defaultvalue(NULL)]const VARIANT* ExtraData, + [in, defaultvalue(NULL)]IUnknown* Object, + [out,retval] VARIANT_BOOL *Supported ); + + // DisplayUI + // SAPI C++ Only Interface Equivalent: Same + // + [helpstring("DisplayUI"), hidden, id(DISPID_SOTDisplayUI)] + HRESULT DisplayUI( [in]long hWnd, + [in]BSTR Title, + [in]const BSTR TypeOfUI, + [in, defaultvalue(NULL)]const VARIANT* ExtraData, + [in, defaultvalue(NULL)]IUnknown* Object); + + // MatchesAttributes + // SAPI C++ Only Interface Equivalent: Same + // + [helpstring("MatchesAttributes"), id(DISPID_SOTMatchesAttributes)] + HRESULT MatchesAttributes([in]BSTR Attributes, + [out,retval] VARIANT_BOOL* Matches); +}; + + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechObjectTokens +// SAPI C++ Only Interface Equivalent: IEnumObjectTokens +// Default Property: Item +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechObjectTokens +{ + DISPID_SOTsCount = 1, + DISPID_SOTsItem = DISPID_VALUE, + DISPID_SOTs_NewEnum = DISPID_NEWENUM +} DISPID_SpeechObjectTokens; + +[ + object, + uuid(9285B776-2E7B-4bc0-B53E-580EB6FA967F), + dual, + helpstring("ISpeechObjectTokens Interface"), + pointer_default(unique) +] +interface ISpeechObjectTokens : IDispatch +{ + // Property + + // Count + // SAPI C++ Only Interface Equivalent: GetCount + // + [propget, helpstring("Count"), id(DISPID_SOTsCount)] + HRESULT Count([out, retval] long* Count); + + // Methods + + // Item + // SAPI C++ Only Interface Equivalent: Same + // + [helpstring("Item"), id(DISPID_VALUE)] + HRESULT Item([in] long Index, [out, retval]ISpeechObjectToken** Token ); + + // _NewEnum + // SAPI C++ Only Interface Equivalent: N/A + // + [propget, helpstring("Enumerates the tokens"), restricted, id(DISPID_NEWENUM)] + HRESULT _NewEnum([out, retval] IUnknown** ppEnumVARIANT); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechObjectTokenCategory +// +// SAPI C++ Only Interface Equivalent: ISpObjectTokenCategory +// Default Property: Id +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechObjectTokenCategory +{ + DISPID_SOTCId = 1, + DISPID_SOTCDefault, + DISPID_SOTCSetId, + DISPID_SOTCGetDataKey, + DISPID_SOTCEnumerateTokens, +} DISPID_SpeechObjectTokenCategory; + +[ + object, + uuid(CA7EAC50-2D01-4145-86D4-5AE7D70F4469), + dual, + helpstring("ISpeechObjectTokenCategory Interface"), + pointer_default(unique) +] +interface ISpeechObjectTokenCategory : IDispatch +{ + // Properties + + // Id + // SAPI C++ Only Interface Equivalent: GetId + // + [propget, helpstring("Id"), id(DISPID_SOTCId)] + HRESULT Id([out, retval] BSTR * Id); + + // Default + // SAPI C++ Only Interface Equivalent: Set/GetDefaultTokenId + // + [propput, helpstring("Default"), id(DISPID_SOTCDefault)] + HRESULT Default([in] const BSTR TokenId); + [propget, helpstring("Default"), id(DISPID_SOTCDefault)] + HRESULT Default([out, retval] BSTR * TokenId); + + // Methods + + // SetId + // SAPI C++ Only Interface Equivalent: Same + // + [helpstring("SetId"), id(DISPID_SOTCSetId)] + HRESULT SetId([in] const BSTR Id, [in, defaultvalue(0)]VARIANT_BOOL CreateIfNotExist); + + // GetDataKey + // SAPI C++ Only Interface Equivalent: Same + // + [helpstring("GetDataKey"), hidden, id(DISPID_SOTCGetDataKey)] + HRESULT GetDataKey([in, defaultvalue(SDKLDefaultLocation)]SpeechDataKeyLocation Location, + [out, retval]ISpeechDataKey ** DataKey); + + // EnumerateTokens + // SAPI C++ Only Interface Equivalent: EnumTokens + // + [helpstring("EnumerateTokens"), id(DISPID_SOTCEnumerateTokens)] + HRESULT EnumerateTokens( [in, defaultvalue("")]BSTR RequiredAttributes, + [in, defaultvalue("")]BSTR OptionalAttributes, + [out, retval]ISpeechObjectTokens** Tokens ); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechAudioFormat +// SAPI C++ Only Interface Equivalent: ISpStreamFormat +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +////////////////////////////////// +// +// SpeechAudioFormatType +// SAPI C++ Only Interface Equivalent: SPSTREAMFORMAT +// +////////////////////////////////// + +typedef enum SpeechAudioFormatType { + [hidden] SAFTDefault = -1, + [hidden] SAFTNoAssignedFormat = 0, + [hidden] SAFTText, + [hidden] SAFTNonStandardFormat, // Non-SAPI 5.0 standard format with no WAVEFORMATEX description + [hidden] SAFTExtendedAudioFormat, // Non-SAPI 5.0 standard format but has WAVEFORMATEX description + // Standard PCM wave formats + SAFT8kHz8BitMono, + SAFT8kHz8BitStereo, + SAFT8kHz16BitMono, + SAFT8kHz16BitStereo, + SAFT11kHz8BitMono, + SAFT11kHz8BitStereo, + SAFT11kHz16BitMono, + SAFT11kHz16BitStereo, + SAFT12kHz8BitMono, + SAFT12kHz8BitStereo, + SAFT12kHz16BitMono, + SAFT12kHz16BitStereo, + SAFT16kHz8BitMono, + SAFT16kHz8BitStereo, + SAFT16kHz16BitMono, + SAFT16kHz16BitStereo, + SAFT22kHz8BitMono, + SAFT22kHz8BitStereo, + SAFT22kHz16BitMono, + SAFT22kHz16BitStereo, + SAFT24kHz8BitMono, + SAFT24kHz8BitStereo, + SAFT24kHz16BitMono, + SAFT24kHz16BitStereo, + SAFT32kHz8BitMono, + SAFT32kHz8BitStereo, + SAFT32kHz16BitMono, + SAFT32kHz16BitStereo, + SAFT44kHz8BitMono, + SAFT44kHz8BitStereo, + SAFT44kHz16BitMono, + SAFT44kHz16BitStereo, + SAFT48kHz8BitMono, + SAFT48kHz8BitStereo, + SAFT48kHz16BitMono, + SAFT48kHz16BitStereo, + // TrueSpeech format + SAFTTrueSpeech_8kHz1BitMono, + // A-Law formats + SAFTCCITT_ALaw_8kHzMono, + SAFTCCITT_ALaw_8kHzStereo, + SAFTCCITT_ALaw_11kHzMono, + SAFTCCITT_ALaw_11kHzStereo, + SAFTCCITT_ALaw_22kHzMono, + SAFTCCITT_ALaw_22kHzStereo, + SAFTCCITT_ALaw_44kHzMono, + SAFTCCITT_ALaw_44kHzStereo, + // u-Law formats + SAFTCCITT_uLaw_8kHzMono, + SAFTCCITT_uLaw_8kHzStereo, + SAFTCCITT_uLaw_11kHzMono, + SAFTCCITT_uLaw_11kHzStereo, + SAFTCCITT_uLaw_22kHzMono, + SAFTCCITT_uLaw_22kHzStereo, + SAFTCCITT_uLaw_44kHzMono, + SAFTCCITT_uLaw_44kHzStereo, + // ADPCM formats + SAFTADPCM_8kHzMono, + SAFTADPCM_8kHzStereo, + SAFTADPCM_11kHzMono, + SAFTADPCM_11kHzStereo, + SAFTADPCM_22kHzMono, + SAFTADPCM_22kHzStereo, + SAFTADPCM_44kHzMono, + SAFTADPCM_44kHzStereo, + // GSM 6.10 formats + SAFTGSM610_8kHzMono, + SAFTGSM610_11kHzMono, + SAFTGSM610_22kHzMono, + SAFTGSM610_44kHzMono, +} SpeechAudioFormatType; + +typedef [hidden] enum DISPID_SpeechAudioFormat +{ + DISPID_SAFType = 1, + DISPID_SAFGuid, + DISPID_SAFGetWaveFormatEx, + DISPID_SAFSetWaveFormatEx +} DISPID_SpeechAudioFormat; + +[ + object, + uuid(E6E9C590-3E18-40e3-8299-061F98BDE7C7), + dual, + helpstring("ISpeechAudioFormat Interface"), + pointer_default(unique) +] +interface ISpeechAudioFormat : IDispatch { + // Properties + + // Type + // SAPI C++ Only Interface Equivalent: + // Default: GetFormat + // + [propget, helpstring("Type"), id(DISPID_SAFType)] + HRESULT Type([out,retval]SpeechAudioFormatType* AudioFormat); + [propput, helpstring("Type"), id(DISPID_SAFType)] + HRESULT Type([in]SpeechAudioFormatType AudioFormat); + + // Guid + // SAPI C++ Only Interface Equivalent: + // Default: N/A (used to be parameter of GetFormat) + // + [propget, hidden, helpstring("Guid"), id(DISPID_SAFGuid)] + HRESULT Guid([out,retval]BSTR* Guid); + [propput, hidden, helpstring("Guid"), id(DISPID_SAFGuid)] + HRESULT Guid([in]BSTR Guid); + + // Methods + + // GetWaveFormatEx + // SAPI C++ Only Interface Equivalent: (used to be parameter of GetFormat) + // + [hidden, helpstring("GetWaveFormatEx"), id(DISPID_SAFGetWaveFormatEx)] + HRESULT GetWaveFormatEx([out,retval]ISpeechWaveFormatEx** WaveFormatEx); + + // GetWaveFormatEx + // SAPI C++ Only Interface Equivalent: (used to be parameter of GetFormat) + // + [hidden, helpstring("SetWaveFormatEx"), id(DISPID_SAFSetWaveFormatEx)] + HRESULT SetWaveFormatEx([in]ISpeechWaveFormatEx* WaveFormatEx); +} + + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechBaseStream +// SAPI C++ Only Interface Equivalent: ISpStreamFormat and IStream +// Default Property: Format +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechBaseStream +{ + DISPID_SBSFormat = 1, + DISPID_SBSRead, + DISPID_SBSWrite, + DISPID_SBSSeek +} DISPID_SpeechBaseStream; + +////////////////////////////////// +// +// SpeechStreamSeekPositionType +// SAPI C++ Only Interface Equivalent: N/A +// +////////////////////////////////// + +typedef enum SpeechStreamSeekPositionType +{ + SSSPTRelativeToStart = STREAM_SEEK_SET, + SSSPTRelativeToCurrentPosition = STREAM_SEEK_CUR, + SSSPTRelativeToEnd = STREAM_SEEK_END +} SpeechStreamSeekPositionType; + +[ + object, + uuid(6450336F-7D49-4ced-8097-49D6DEE37294), + dual, + helpstring("ISpeechBaseStream Interface"), + pointer_default(unique) +] +interface ISpeechBaseStream : IDispatch +{ + // Properties + + // Format + // SAPI C++ Only Interface Equivalent: N/A + // Default: N/A + // + [propget, helpstring("Format"), id(DISPID_SBSFormat)] + HRESULT Format([out,retval]ISpeechAudioFormat** AudioFormat); + [propputref, helpstring("Format"), id(DISPID_SBSFormat)] + HRESULT Format([in]ISpeechAudioFormat* AudioFormat); + + // Methods + + + // Read + // SAPI C++ Only Interface Equivalent: N/A + // + [helpstring("Read"), id(DISPID_SBSRead)] + HRESULT Read([out]VARIANT* Buffer, [in]long NumberOfBytes, [out,retval]long* BytesRead); + + // Write + // SAPI C++ Only Interface Equivalent: N/A + // + [helpstring("Write"), id(DISPID_SBSWrite)] + HRESULT Write([in]VARIANT Buffer, [out,retval]long* BytesWritten); + + // Seek + // SAPI C++ Only Interface Equivalent: N/A + // + [helpstring("Seek"), id(DISPID_SBSSeek)] + HRESULT Seek([in]VARIANT Position, [in, defaultvalue(SSSPTRelativeToStart)]SpeechStreamSeekPositionType Origin, [out,retval]VARIANT* NewPosition); +}; + + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechAudio +// SAPI C++ Only Interface Equivalent: ISpAudio +// Default Property: Volume +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechAudio +{ + DISPID_SAStatus = 200, + DISPID_SABufferInfo, + DISPID_SADefaultFormat, + DISPID_SAVolume, + DISPID_SABufferNotifySize, + DISPID_SAEventHandle, + DISPID_SASetState +} DISPID_SpeechAudio; + +////////////////////////////////// +// +// SpeechAudioState +// SAPI C++ Only Interface Equivalent: _SPAUDIOSTATE +// +////////////////////////////////// + +typedef enum SpeechAudioState +{ + SASClosed = SPAS_CLOSED, + SASStop = SPAS_STOP, + SASPause = SPAS_PAUSE, + SASRun = SPAS_RUN +} SpeechAudioState; + +[ + object, + uuid(CFF8E175-019E-11d3-A08E-00C04F8EF9B5), + dual, + helpstring("ISpeechAudio Interface"), + pointer_default(unique) +] +interface ISpeechAudio : ISpeechBaseStream +{ + // Properties + + // Status + // SAPI C++ Only Interface Equivalent: GetStatus + // Default: N/A + // + [propget, helpstring("Status"), id(DISPID_SAStatus)] + HRESULT Status([out,retval]ISpeechAudioStatus** Status); + + // BufferInfo + // SAPI C++ Only Interface Equivalent: GetBufferInfo + // Default: N/A + // + [propget, helpstring("BufferInfo"), id(DISPID_SABufferInfo)] + HRESULT BufferInfo([out,retval]ISpeechAudioBufferInfo** BufferInfo); + + // DefaultFormat + // SAPI C++ Only Interface Equivalent: GetDefaultFormat + // Default: N/A + // + [propget, helpstring("DefaultFormat"), id(DISPID_SADefaultFormat)] + HRESULT DefaultFormat([out,retval]ISpeechAudioFormat** StreamFormat); + + // Volume + // SAPI C++ Only Interface Equivalent: GetVolumeLevel + // Default: N/A + // + [propget, helpstring("Volume"), id(DISPID_SAVolume)] + HRESULT Volume([out,retval]long* Volume); + [propput, helpstring("Volume"), id(DISPID_SAVolume)] + HRESULT Volume([in]long Volume); + + // BufferNotifySize + // SAPI C++ Only Interface Equivalent: GetBufferNotifySize + // Default: N/A + // + [propget, helpstring("BufferNotifySize"), id(DISPID_SABufferNotifySize)] + HRESULT BufferNotifySize([out,retval]long* BufferNotifySize); + [propput, helpstring("BufferNotifySize"), id(DISPID_SABufferNotifySize)] + HRESULT BufferNotifySize([in]long BufferNotifySize); + + // EventHandle + // SAPI C++ Only Interface Equivalent: Same + // Default: N/A + // + [propget, hidden, helpstring("EventHandle"), id(DISPID_SAEventHandle)] + HRESULT EventHandle([out,retval]long* EventHandle); + + // Methods + + // SetState + // SAPI C++ Only Interface Equivalent: Same + // + [helpstring("SetState"), id(DISPID_SASetState), hidden] + HRESULT SetState([in] SpeechAudioState State); + +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechMMSysAudio +// SAPI C++ Only Interface Equivalent: ISpMMSysAudio +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechMMSysAudio +{ + DISPID_SMSADeviceId = 300, + DISPID_SMSALineId, + DISPID_SMSAMMHandle +} DISPID_SpeechMMSysAudio; + +[ + object, + uuid(3C76AF6D-1FD7-4831-81D1-3B71D5A13C44), + dual, + helpstring("ISpeechMMSysAudio Interface"), + pointer_default(unique) +] +interface ISpeechMMSysAudio : ISpeechAudio +{ + // Properties + + // DeviceId + // SAPI C++ Only Interface Equivalent: Get/SetDeviceId + // Default: N/A + // + [propget, helpstring("DeviceId"), id(DISPID_SMSADeviceId)] + HRESULT DeviceId([out, retval] long* DeviceId); + [propput, helpstring("DeviceId"), id(DISPID_SMSADeviceId)] + HRESULT DeviceId([in] long DeviceId); + + // LineId + // SAPI C++ Only Interface Equivalent: Get/SetLineId + // Default: N/A + // + [propget, helpstring("LineId"), id(DISPID_SMSALineId)] + HRESULT LineId([out, retval] long* LineId); + [propput, helpstring("LineId"), id(DISPID_SMSALineId)] + HRESULT LineId([in] long LineId); + + // MMHandle + // SAPI C++ Only Interface Equivalent: GetMMHandle + // Default: N/A + // + [propget, hidden, helpstring("MMHandle"), id(DISPID_SMSAMMHandle)] + HRESULT MMHandle([out, retval] long* Handle); // 64bit issue? Declared as handle. +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechFileStream +// SAPI C++ Only Interface Equivalent: ISpStream +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechFileStream +{ + DISPID_SFSOpen = 100, + DISPID_SFSClose +} DISPID_SpeechFileStream; + +////////////////////////////////// +// +// SpeechStreamFileMode Enum +// SAPI C++ Only Interface Equivalent: +// +////////////////////////////////// + +typedef enum SpeechStreamFileMode +{ + SSFMOpenForRead = SPFM_OPEN_READONLY, // Open existing file, read-only. + [hidden] SSFMOpenReadWrite = SPFM_OPEN_READWRITE, // (Not supported for wav files) Open existing file, read-write. + [hidden] SSFMCreate = SPFM_CREATE, // (Not supported for wav files) Open file if exists, else create if does not exist (opens read-write) + SSFMCreateForWrite = SPFM_CREATE_ALWAYS, // Create file even if file exists. Destroys old file. +} SpeechStreamFileMode; + +[ + object, + uuid(AF67F125-AB39-4e93-B4A2-CC2E66E182A7), + dual, + helpstring("ISpeechFileStream Interface"), + pointer_default(unique) +] +interface ISpeechFileStream : ISpeechBaseStream +{ + // Properties + + // Methods + + // Open + // SAPI C++ Only Interface Equivalent: BindToFile + // Default: N/A + // + [helpstring("Open"), id(DISPID_SFSOpen)] + HRESULT Open([in] BSTR FileName, + [in, defaultvalue(SSFMOpenForRead)] SpeechStreamFileMode FileMode, + [in, defaultvalue(0)]VARIANT_BOOL DoEvents); + + // Close + // SAPI C++ Only Interface Equivalent: Same + // Default: N/A + // + [helpstring("Close"), id(DISPID_SFSClose)] + HRESULT Close(void); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechCustomStream +// SAPI C++ Only Interface Equivalent: ISpStream +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechCustomStream +{ + DISPID_SCSBaseStream = 100 +} DISPID_SpeechCustomStream; + + +[ + object, + uuid(1A9E9F4F-104F-4db8-A115-EFD7FD0C97AE), + dual, + helpstring("ISpeechCustomStream Interface"), + pointer_default(unique) +] +interface ISpeechCustomStream : ISpeechBaseStream +{ + // Properties + + // BaseStream + // SAPI C++ Only Interface Equivalent: ISpStream::Get/SetBaseStream + // Default: N/A + // + [propget, helpstring("BaseStream"), id(DISPID_SCSBaseStream)] + HRESULT BaseStream([out, retval] IUnknown **ppUnkStream); + [propputref, helpstring("BaseStream"), id(DISPID_SCSBaseStream)] + HRESULT BaseStream([in] IUnknown *pUnkStream); + + // Methods +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechMemoryStream +// SAPI C++ Only Interface Equivalent: ISpStream +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechMemoryStream +{ + DISPID_SMSSetData = 100, + DISPID_SMSGetData +} DISPID_SpeechMemoryStream; + +[ + object, + uuid(EEB14B68-808B-4abe-A5EA-B51DA7588008), + dual, + helpstring("ISpeechMemoryStream Interface"), + pointer_default(unique) +] +interface ISpeechMemoryStream : ISpeechBaseStream +{ + // Properties + + // Methods + + // SetData + // SAPI C++ Only Interface Equivalent: N/A + // + [helpstring("SetData"), id(DISPID_SMSSetData)] + HRESULT SetData([in] VARIANT Data); + + // GetData + // SAPI C++ Only Interface Equivalent: N/A + // + [helpstring("GetData"), id(DISPID_SMSGetData)] + HRESULT GetData([out, retval] VARIANT* pData); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechAudioStatus +// SAPI C++ Only Interface Equivalent: SPAUDIOSTATUS Struct +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechAudioStatus +{ + DISPID_SASFreeBufferSpace = 1, + DISPID_SASNonBlockingIO, + DISPID_SASState, + DISPID_SASCurrentSeekPosition, + DISPID_SASCurrentDevicePosition +} DISPID_SpeechAudioStatus; + +[ + object, + uuid(C62D9C91-7458-47f6-862D-1EF86FB0B278), + dual, + helpstring("ISpeechAudioStatus Interface"), + pointer_default(unique) +] +interface ISpeechAudioStatus : IDispatch +{ + // Properties + + // FreeBufferSpace + // SAPI C++ Only Interface Equivalent: Same + // Default: N/A + // + [propget, helpstring("FreeBufferSpace"), id(DISPID_SASFreeBufferSpace)] + HRESULT FreeBufferSpace([out,retval]long* FreeBufferSpace); + + // NonBlockingIO + // SAPI C++ Only Interface Equivalent: Same + // Default: N/A + // + [propget, helpstring("NonBlockingIO"), id(DISPID_SASNonBlockingIO)] + HRESULT NonBlockingIO([out,retval]long* NonBlockingIO); + + // State + // SAPI C++ Only Interface Equivalent: Same + // Default: N/A + // + [propget, helpstring("State"), id(DISPID_SASState)] + HRESULT State([out, retval] SpeechAudioState * State); + + // CurrentSeekPosition + // SAPI C++ Only Interface Equivalent: Same + // Default: N/A + // + [propget, helpstring("CurrentSeekPosition"), id(DISPID_SASCurrentSeekPosition)] + HRESULT CurrentSeekPosition([out,retval]VARIANT* CurrentSeekPosition); + + // CurrentDevicePosition + // SAPI C++ Only Interface Equivalent: Same + // Default: N/A + // + [propget, helpstring("CurrentDevicePosition"), id(DISPID_SASCurrentDevicePosition)] + HRESULT CurrentDevicePosition([out,retval]VARIANT* CurrentDevicePosition); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechAudioBufferInfo +// P3. We're not sure what this is for. Should be hidden? +// SAPI C++ Only Interface Equivalent: SPAUDIOBUFFERINFO Struct +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechAudioBufferInfo +{ + DISPID_SABIMinNotification = 1, + DISPID_SABIBufferSize, + DISPID_SABIEventBias +} DISPID_SpeechAudioBufferInfo; + +[ + object, + uuid(11B103D8-1142-4edf-A093-82FB3915F8CC), + dual, + helpstring("ISpeechAudioBufferInfo Interface"), + pointer_default(unique) +] +interface ISpeechAudioBufferInfo : IDispatch +{ + // Properties + + // MinNotification + // SAPI C++ Only Interface Equivalent: Same + // Default: N/A + // + [propget, helpstring("MinNotification"), id(DISPID_SABIMinNotification)] + HRESULT MinNotification([out,retval]long* MinNotification); + [propput, helpstring("MinNotification"), id(DISPID_SABIMinNotification)] + HRESULT MinNotification([in]long MinNotification); + + // BufferSize + // SAPI C++ Only Interface Equivalent: Same + // Default: N/A + // + [propget, helpstring("BufferSize"), id(DISPID_SABIBufferSize)] + HRESULT BufferSize([out,retval]long* BufferSize); + [propput, helpstring("BufferSize"), id(DISPID_SABIBufferSize)] + HRESULT BufferSize([in]long BufferSize); + + // EventBias + // SAPI C++ Only Interface Equivalent: Same + // Default: N/A + // + [propget, helpstring("EventBias"), id(DISPID_SABIEventBias)] + HRESULT EventBias([out,retval]long* EventBias); + [propput, helpstring("EventBias"), id(DISPID_SABIEventBias)] + HRESULT EventBias([in]long EventBias); +} + + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechWaveFormatEx +// SAPI C++ Only Interface Equivalent: WAVEFORMATEX Struct +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechWaveFormatEx +{ + DISPID_SWFEFormatTag = 1, + DISPID_SWFEChannels, + DISPID_SWFESamplesPerSec, + DISPID_SWFEAvgBytesPerSec, + DISPID_SWFEBlockAlign, + DISPID_SWFEBitsPerSample, + DISPID_SWFEExtraData +} DISPID_SpeechWaveFormatEx; + +[ + object, + uuid(7A1EF0D5-1581-4741-88E4-209A49F11A10), + dual, + helpstring("ISpeechWaveFormatEx Interface"), + pointer_default(unique) +] +interface ISpeechWaveFormatEx : IDispatch +{ + // Properties + + // FormatTag + // SAPI C++ Only Interface Equivalent: Same + // Default: N/A + // + [propget, helpstring("FormatTag"), id(DISPID_SWFEFormatTag)] + HRESULT FormatTag([out,retval]short* FormatTag); + [propput, helpstring("FormatTag"), id(DISPID_SWFEFormatTag)] + HRESULT FormatTag([in]short FormatTag); + + // Channels + // SAPI C++ Only Interface Equivalent: Same + // Default: N/A + // + [propget, helpstring("Channels"), id(DISPID_SWFEChannels)] + HRESULT Channels([out,retval]short* Channels); + [propput, helpstring("Channels"), id(DISPID_SWFEChannels)] + HRESULT Channels([in]short Channels); + + // SamplesPerSec + // SAPI C++ Only Interface Equivalent: Same + // Default: N/A + // + [propget, helpstring("SamplesPerSec"), id(DISPID_SWFESamplesPerSec)] + HRESULT SamplesPerSec([out,retval]long* SamplesPerSec); + [propput, helpstring("SamplesPerSec"), id(DISPID_SWFESamplesPerSec)] + HRESULT SamplesPerSec([in]long SamplesPerSec); + + // AvgBytesPerSec + // SAPI C++ Only Interface Equivalent: Same + // Default: N/A + // + [propget, helpstring("AvgBytesPerSec"), id(DISPID_SWFEAvgBytesPerSec)] + HRESULT AvgBytesPerSec([out,retval]long* AvgBytesPerSec); + [propput, helpstring("AvgBytesPerSec"), id(DISPID_SWFEAvgBytesPerSec)] + HRESULT AvgBytesPerSec([in]long AvgBytesPerSec); + + // BlockAlign + // SAPI C++ Only Interface Equivalent: Same + // Default: N/A + // + [propget, helpstring("BlockAlign"), id(DISPID_SWFEBlockAlign)] + HRESULT BlockAlign([out,retval]short* BlockAlign); + [propput, helpstring("BlockAlign"), id(DISPID_SWFEBlockAlign)] + HRESULT BlockAlign([in]short BlockAlign); + + // BitsPerSample + // SAPI C++ Only Interface Equivalent: Same + // Default: N/A + // + [propget, helpstring("BitsPerSample"), id(DISPID_SWFEBitsPerSample)] + HRESULT BitsPerSample([out,retval]short* BitsPerSample); + [propput, helpstring("BitsPerSample"), id(DISPID_SWFEBitsPerSample)] + HRESULT BitsPerSample([in]short BitsPerSample); + + // ExtraData + // SAPI C++ Only Interface Equivalent: Same + // Default: N/A + // + [propget, helpstring("ExtraData"), id(DISPID_SWFEExtraData)] + HRESULT ExtraData([out,retval]VARIANT* ExtraData); + [propput, helpstring("ExtraData"), id(DISPID_SWFEExtraData)] + HRESULT ExtraData([in]VARIANT ExtraData); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechVoice +// SAPI C++ Only Interface Equivalent: ISpVoice +// Default Property: Speak +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechVoice +{ + DISPID_SVStatus = 1, + DISPID_SVVoice, + DISPID_SVAudioOutput, + DISPID_SVAudioOutputStream, + DISPID_SVRate, + DISPID_SVVolume, + DISPID_SVAllowAudioOuputFormatChangesOnNextSet, + DISPID_SVEventInterests, + DISPID_SVPriority, + DISPID_SVAlertBoundary, + DISPID_SVSyncronousSpeakTimeout, + DISPID_SVSpeak, + DISPID_SVSpeakStream, + DISPID_SVPause, + DISPID_SVResume, + DISPID_SVSkip, + DISPID_SVGetVoices, + DISPID_SVGetAudioOutputs, + DISPID_SVWaitUntilDone, + DISPID_SVSpeakCompleteEvent, + DISPID_SVIsUISupported, + DISPID_SVDisplayUI +} DISPID_SpeechVoice; + +////////////////////////////////// +// +// SpeechVoicePriority Enum +// SAPI C++ Only Interface Equivalent: SPVPRIORITY +// +////////////////////////////////// + +typedef enum SpeechVoicePriority +{ + SVPNormal = SPVPRI_NORMAL, + SVPAlert = SPVPRI_ALERT, + SVPOver = SPVPRI_OVER +} SpeechVoicePriority; + +////////////////////////////////// +// +// SpeechVoiceSpeakFlags Enum +// SAPI C++ Only Interface Equivalent: SPEAKFLAGS +// +////////////////////////////////// + +typedef enum SpeechVoiceSpeakFlags +{ + //--- SpeechVoice flags + SVSFDefault = SPF_DEFAULT, + SVSFlagsAsync = SPF_ASYNC, + SVSFPurgeBeforeSpeak = SPF_PURGEBEFORESPEAK, + SVSFIsFilename = SPF_IS_FILENAME, + SVSFIsXML = SPF_IS_XML, + SVSFIsNotXML = SPF_IS_NOT_XML, + SVSFPersistXML = SPF_PERSIST_XML, + + //--- Normalizer flags + SVSFNLPSpeakPunc = SPF_NLP_SPEAK_PUNC, + + //--- Masks + SVSFNLPMask = SPF_NLP_MASK, + SVSFVoiceMask = SPF_VOICE_MASK, + SVSFUnusedFlags = SPF_UNUSED_FLAGS +} SpeechVoiceSpeakFlags; + +////////////////////////////////// +// +// SpeechVoiceEvents Enum +// SAPI C++ Only Interface Equivalent: N/A +// +////////////////////////////////// + +typedef enum SpeechVoiceEvents +{ + SVEStartInputStream = (1L << 1), + SVEEndInputStream = (1L << 2), + SVEVoiceChange = (1L << 3), + SVEBookmark = (1L << 4), + SVEWordBoundary = (1L << 5), + SVEPhoneme = (1L << 6), + SVESentenceBoundary = (1L << 7), + SVEViseme = (1L << 8), + SVEAudioLevel = (1L << 9), + SVEPrivate = (1L << 15), + SVEAllEvents = 0x083FE // All TTS events on. +} SpeechVoiceEvents; + +[ + object, + uuid(269316D8-57BD-11D2-9EEE-00C04F797396), + dual, + helpstring("ISpeechVoice Interface"), + pointer_default(unique) +] +interface ISpeechVoice : IDispatch +{ + // Status + // SAPI C++ Only Interface Equivalent: GetStatus + // Default: + // + [propget, helpstring("Status"), id(DISPID_SVStatus)] + HRESULT Status([out, retval] ISpeechVoiceStatus** Status); + + // Voice + // SAPI C++ Only Interface Equivalent: Get/SetVoice + // Default: + // + [propget, helpstring("Voice"), id(DISPID_SVVoice)] + HRESULT Voice([out, retval] ISpeechObjectToken** Voice ); + [propputref, helpstring("Voice"), id(DISPID_SVVoice)] + HRESULT Voice([in]ISpeechObjectToken * Voice ); + + // AudioOutput + // SAPI C++ Only Interface Equivalent: GetOutputObjectTokens/SetOutput + // Default: + // + [propget, helpstring("Gets the audio output object"), id(DISPID_SVAudioOutput)] + HRESULT AudioOutput([out, retval]ISpeechObjectToken** AudioOutput); + [propputref, helpstring("Sets the audio output object"), id(DISPID_SVAudioOutput)] + HRESULT AudioOutput([in]ISpeechObjectToken* AudioOutput); + + // AudioOutputStream + // SAPI C++ Only Interface Equivalent: GetOutputStream/SetOutput + // Default: + // + [propget, helpstring("Gets the audio output stream"), id(DISPID_SVAudioOutputStream)] + HRESULT AudioOutputStream([out, retval]ISpeechBaseStream** AudioOutputStream); + [propputref, helpstring("Sets the audio output stream"), id(DISPID_SVAudioOutputStream)] + HRESULT AudioOutputStream([in]ISpeechBaseStream* AudioOutputStream); + + // Rate + // SAPI C++ Only Interface Equivalent: Get/SetRate + // Default: + // + [propget, helpstring("Rate"), id(DISPID_SVRate)] + HRESULT Rate([out, retval] long* Rate); + [propput, helpstring("Rate"), id(DISPID_SVRate)] + HRESULT Rate([in] long Rate); + + // Volume + // SAPI C++ Only Interface Equivalent: Get/SetVolume + // Default: + // + [propget, helpstring("Volume"), id(DISPID_SVVolume)] + HRESULT Volume([out, retval] long* Volume); + [propput, helpstring("Volume"), id(DISPID_SVVolume)] + HRESULT Volume([in] long Volume); + + // AllowAudioOutputFormatChangesOnNextSet + // SAPI C++ Only Interface Equivalent: N/A (used to be parameter of SetOutput) + // Default: + // + [propput, hidden, helpstring("AllowAudioOutputFormatChangesOnNextSet"), id(DISPID_SVAllowAudioOuputFormatChangesOnNextSet)] + HRESULT AllowAudioOutputFormatChangesOnNextSet([in] VARIANT_BOOL Allow ); + [propget, hidden, helpstring("AllowAudioOutputFormatChangesOnNextSet"), id(DISPID_SVAllowAudioOuputFormatChangesOnNextSet)] + HRESULT AllowAudioOutputFormatChangesOnNextSet([out,retval] VARIANT_BOOL* Allow ); + + // EventInterests + // SAPI C++ Only Interface Equivalent: ISpEventSink::GetEventInterests + // Default: + // + [propget, helpstring("EventInterests"), id(DISPID_SVEventInterests)] + HRESULT EventInterests([out,retval] SpeechVoiceEvents* EventInterestFlags); + [propput, helpstring("EventInterests"), id(DISPID_SVEventInterests)] + HRESULT EventInterests([in] SpeechVoiceEvents EventInterestFlags); + + // Priority + // SAPI C++ Only Interface Equivalent: Get/SetPriority + // Default: + // + [propput, helpstring("Priority"), id(DISPID_SVPriority)] + HRESULT Priority([in] SpeechVoicePriority Priority ); + [propget, helpstring("Priority"), id(DISPID_SVPriority)] + HRESULT Priority([out,retval] SpeechVoicePriority* Priority ); + + // AlertBoundary + // SAPI C++ Only Interface Equivalent: Get/SetAlertBoundary + // Default: + // + [propput, helpstring("AlertBoundary"), id(DISPID_SVAlertBoundary)] + HRESULT AlertBoundary( [in] SpeechVoiceEvents Boundary ); + [propget, helpstring("AlertBoundary"), id(DISPID_SVAlertBoundary)] + HRESULT AlertBoundary( [out,retval] SpeechVoiceEvents* Boundary ); + + // SyncSpeakTimeout + // SAPI C++ Only Interface Equivalent: Get/SetSyncSpeakTimeout + // Default: + // + [propput, helpstring("SyncSpeakTimeout"), id(DISPID_SVSyncronousSpeakTimeout)] + HRESULT SynchronousSpeakTimeout([in] long msTimeout ); + [propget, helpstring("SyncSpeakTimeout"), id(DISPID_SVSyncronousSpeakTimeout)] + HRESULT SynchronousSpeakTimeout([out,retval] long* msTimeout ); + + // Methods + + // Speak + // SAPI C++ Only Interface Equivalent: Same + // + [helpstring("Speak"), id(DISPID_SVSpeak)] + HRESULT Speak( [in] BSTR Text, + [in, defaultvalue(SPF_DEFAULT)] SpeechVoiceSpeakFlags Flags, + [out, retval]long* StreamNumber ); + + // SpeakStream + // SAPI C++ Only Interface Equivalent: Same + // + [helpstring("SpeakStream"), id(DISPID_SVSpeakStream)] + HRESULT SpeakStream( [in] ISpeechBaseStream* Stream, + [in, defaultvalue(SPF_DEFAULT)] SpeechVoiceSpeakFlags Flags, + [out, retval]long* StreamNumber ); + + // Pause + // SAPI C++ Only Interface Equivalent: Same + // + [helpstring("Pauses the voices rendering."), id(DISPID_SVPause)] + HRESULT Pause( void ); + + // Resume + // SAPI C++ Only Interface Equivalent: Same + // + [helpstring("Resumes the voices rendering."), id(DISPID_SVResume)] + HRESULT Resume( void ); + + // Skip + // SAPI C++ Only Interface Equivalent: Same + // + [helpstring("Skips rendering the specified number of items."), id(DISPID_SVSkip)] + HRESULT Skip( [in]const BSTR Type, [in]long NumItems, [out,retval]long* NumSkipped ); + + // GetVoices + // SAPI C++ Only Interface Equivalent: IEnumSpObjectTokens + // + [helpstring("GetVoices"), id(DISPID_SVGetVoices)] + HRESULT GetVoices([in, defaultvalue("")]BSTR RequiredAttributes, + [in, defaultvalue("")]BSTR OptionalAttributes, + [out,retval]ISpeechObjectTokens** ObjectTokens ); + + // GetAudioOutputs + // SAPI C++ Only Interface Equivalent: IEnumSpObjectTokens + // + [helpstring("GetAudioOutputs"), id(DISPID_SVGetAudioOutputs)] + HRESULT GetAudioOutputs([in, defaultvalue("")]BSTR RequiredAttributes, + [in, defaultvalue("")]BSTR OptionalAttributes, + [out,retval]ISpeechObjectTokens** ObjectTokens ); + + // WaitUntilDone + // SAPI C++ Only Interface Equivalent: Same + // + [helpstring("WaitUntilDone"), id(DISPID_SVWaitUntilDone)] + HRESULT WaitUntilDone([in]long msTimeout, [out,retval]VARIANT_BOOL * Done); + + // SpeakCompleteEvent + // SAPI C++ Only Interface Equivalent: Same + // + [helpstring("SpeakCompleteEvent"), hidden, id(DISPID_SVSpeakCompleteEvent)] + HRESULT SpeakCompleteEvent([out,retval]long* Handle); + + // IsUISupported + // SAPI C++ Only Interface Equivalent: Same + // + [helpstring("IsUISupported"), id(DISPID_SVIsUISupported)] + HRESULT IsUISupported( [in]const BSTR TypeOfUI, + [in, defaultvalue(NULL)]const VARIANT* ExtraData, + [out,retval] VARIANT_BOOL* Supported ); + + // DisplayUI + // SAPI C++ Only Interface Equivalent: Same + // + [helpstring("DisplayUI"), id(DISPID_SVDisplayUI)] + HRESULT DisplayUI( [in]long hWndParent, + [in]BSTR Title, + [in]const BSTR TypeOfUI, + [in, defaultvalue(NULL)]const VARIANT* ExtraData); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechVoiceStatus +// SAPI C++ Only Interface Equivalent: SPVOICESTATUS Struct +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechVoiceStatus +{ + DISPID_SVSCurrentStreamNumber = 1, + DISPID_SVSLastStreamNumberQueued, + DISPID_SVSLastResult, + DISPID_SVSRunningState, + DISPID_SVSInputWordPosition, + DISPID_SVSInputWordLength, + DISPID_SVSInputSentencePosition, + DISPID_SVSInputSentenceLength, + DISPID_SVSLastBookmark, + DISPID_SVSLastBookmarkId, + DISPID_SVSPhonemeId, + DISPID_SVSVisemeId +} DISPID_SpeechVoiceStatus; + +////////////////////////////////// +// +// SpeechRunState Enum +// SAPI C++ Only Interface Equivalent: SPRUNSTATE +// +////////////////////////////////// + +typedef enum SpeechRunState +{ + SRSEDone = SPRS_DONE, // The voice is done rendering all queued phrases + SRSEIsSpeaking = SPRS_IS_SPEAKING // The SpVoice currently has the audio queue claimed +} SpeechRunState; + +[ + object, + uuid(8BE47B07-57F6-11d2-9EEE-00C04F797396), + dual, + helpstring("ISpeechVoiceStatus Interface"), + pointer_default(unique) +] +interface ISpeechVoiceStatus : IDispatch +{ + // CurrentStream + // SAPI C++ Only Interface Equivalent: Same + // Default: + // + [propget, helpstring("CurrentStreamNumber"), id(DISPID_SVSCurrentStreamNumber)] + HRESULT CurrentStreamNumber([out, retval] long* StreamNumber); + + // LastStreamNumberQueued + // SAPI C++ Only Interface Equivalent: Same + // Default: + // + [propget, helpstring("LastStreamNumberQueued"), id(DISPID_SVSLastStreamNumberQueued)] + HRESULT LastStreamNumberQueued([out, retval] long* StreamNumber); + + // LastHResult + // SAPI C++ Only Interface Equivalent: Same + // Default: + // + [propget, helpstring("LastHResult"), id(DISPID_SVSLastResult)] + HRESULT LastHResult([out, retval]long* HResult); + + // RunningState + // SAPI C++ Only Interface Equivalent: Same + // Default: + // + [propget, helpstring("RunningState"), id(DISPID_SVSRunningState)] + HRESULT RunningState([out, retval] SpeechRunState* State); + + // InputWordPosition + // SAPI C++ Only Interface Equivalent: Same + // Default: + // + [propget, helpstring("InputWordPosition"), id(DISPID_SVSInputWordPosition)] + HRESULT InputWordPosition([out, retval] long* Position); + + // InputWordLength + // SAPI C++ Only Interface Equivalent: Same + // Default: + // + [propget, helpstring("InputWordLength"), id(DISPID_SVSInputWordLength)] + HRESULT InputWordLength([out, retval] long* Length); + + // InputSentencePosition + // SAPI C++ Only Interface Equivalent: Same + // Default: + // + [propget, helpstring("InputSentencePosition"), id(DISPID_SVSInputSentencePosition)] + HRESULT InputSentencePosition([out, retval] long* Position); + + // InputSentenceLength + // SAPI C++ Only Interface Equivalent: Same + // Default: + // + [propget, helpstring("InputSentenceLength"), id(DISPID_SVSInputSentenceLength)] + HRESULT InputSentenceLength([out, retval] long* Length); + + // LastBookmark + // SAPI C++ Only Interface Equivalent: Same + // Default: + // + [propget, helpstring("LastBookmark"), id(DISPID_SVSLastBookmark)] + HRESULT LastBookmark([out, retval] BSTR* Bookmark); + + // LastBookmarkId + // SAPI C++ Only Interface Equivalent: Same + // Default: + // + [propget, helpstring("LastBookmarkId"), id(DISPID_SVSLastBookmarkId), hidden] + HRESULT LastBookmarkId([out, retval] long* BookmarkId); + + // PhonemeId + // SAPI C++ Only Interface Equivalent: Same + // Default: + // + [propget, helpstring("PhonemeId"), id(DISPID_SVSPhonemeId)] + HRESULT PhonemeId([out, retval] short* PhoneId); + + // VisemeId + // SAPI C++ Only Interface Equivalent: Same + // Default: + // + [propget, helpstring("VisemeId"), id(DISPID_SVSVisemeId)] + HRESULT VisemeId([out, retval] short* VisemeId); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// _ISpeechVoiceEvents +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +////////////////////////////////// +// +// SpeechVisemeType Enum +// SAPI C++ Only Interface Equivalent: SPVISEMES +// +////////////////////////////////// + +typedef enum SpeechVisemeType +{ + // English example + SVP_0 = 0, // silence + SVP_1, // ae, ax, ah + SVP_2, // aa + SVP_3, // ao + SVP_4, // ey, eh, uh + SVP_5, // er + SVP_6, // y, iy, ih, ix + SVP_7, // w, uw + SVP_8, // ow + SVP_9, // aw + SVP_10, // oy + SVP_11, // ay + SVP_12, // h + SVP_13, // r + SVP_14, // l + SVP_15, // s, z + SVP_16, // sh, ch, jh, zh + SVP_17, // th, dh + SVP_18, // f, v + SVP_19, // d, t, n + SVP_20, // k, g, ng + SVP_21, // p, b, m +} SpeechVisemeType ; + +////////////////////////////////// +// +// SpeechVisemeFeature Enum +// SAPI C++ Only Interface Equivalent: +// +////////////////////////////////// + +typedef enum SpeechVisemeFeature +{ + SVF_None = 0, + SVF_Stressed = SPVFEATURE_STRESSED, + SVF_Emphasis = SPVFEATURE_EMPHASIS +} SpeechVisemeFeature; + +typedef [hidden] enum DISPID_SpeechVoiceEvent +{ + DISPID_SVEStreamStart = 1, + DISPID_SVEStreamEnd, + DISPID_SVEVoiceChange, + DISPID_SVEBookmark, + DISPID_SVEWord, + DISPID_SVEPhoneme, + DISPID_SVESentenceBoundary, + DISPID_SVEViseme, + DISPID_SVEAudioLevel, + DISPID_SVEEnginePrivate +} DISPID_SpeechVoiceEvent; + +[ + uuid(A372ACD1-3BEF-4bbd-8FFB-CB3E2B416AF8) +] +dispinterface _ISpeechVoiceEvents +{ + properties: + methods: + + // StartStream + // SAPI C++ Only Interface Equivalent: + // + [helpstring("StartStream"), id(DISPID_SVEStreamStart)] + void StartStream([in]long StreamNumber, [in]VARIANT StreamPosition); + + // EndStream + // SAPI C++ Only Interface Equivalent: + // + [helpstring("EndStream"), id(DISPID_SVEStreamEnd)] + void EndStream([in]long StreamNumber, [in]VARIANT StreamPosition); + + // VoiceChange + // SAPI C++ Only Interface Equivalent: + // + [helpstring("VoiceChange"), id(DISPID_SVEVoiceChange)] + void VoiceChange([in]long StreamNumber, + [in]VARIANT StreamPosition, + [in]ISpeechObjectToken* VoiceObjectToken); + + // Bookmark + // SAPI C++ Only Interface Equivalent: + // + [helpstring("Bookmark"), id(DISPID_SVEBookmark)] + void Bookmark([in]long StreamNumber, + [in]VARIANT StreamPosition, + [in]BSTR Bookmark, + [in]long BookmarkId); + + // Word + // SAPI C++ Only Interface Equivalent: + // + [helpstring("Word"), id(DISPID_SVEWord)] + void Word([in]long StreamNumber, + [in]VARIANT StreamPosition, + [in]long CharacterPosition, + [in]long Length); + + // Sentence + // SAPI C++ Only Interface Equivalent: + // + [helpstring("Sentence"), id(DISPID_SVESentenceBoundary)] + void Sentence([in]long StreamNumber, + [in]VARIANT StreamPosition, + [in]long CharacterPosition, + [in]long Length); + + // Phoneme + // SAPI C++ Only Interface Equivalent: + // + [helpstring("Phoneme"), id(DISPID_SVEPhoneme)] + void Phoneme([in]long StreamNumber, + [in]VARIANT StreamPosition, + [in]long Duration, // In milliseconds + [in]short NextPhoneId, + [in]SpeechVisemeFeature Feature, + [in]short CurrentPhoneId); + + // Viseme + // SAPI C++ Only Interface Equivalent: + // + [helpstring("Viseme"), id(DISPID_SVEViseme)] + void Viseme([in]long StreamNumber, + [in]VARIANT StreamPosition, + [in]long Duration, // In milliseconds + [in]SpeechVisemeType NextVisemeId, + [in]SpeechVisemeFeature Feature, + [in]SpeechVisemeType CurrentVisemeId); + + // AudioLevel + // SAPI C++ Only Interface Equivalent: + // + [helpstring("AudioLevel"), id(DISPID_SVEAudioLevel)] + void AudioLevel([in]long StreamNumber, + [in]VARIANT StreamPosition, + [in]long AudioLevel); + + // EnginePrivate + // SAPI C++ Only Interface Equivalent: + // + [helpstring("EnginePrivate"), id(DISPID_SVEEnginePrivate)] + void EnginePrivate( [in]long StreamNumber, + [in]long StreamPosition, + [in]VARIANT EngineData); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechRecognizer +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechRecognizer +{ + DISPID_SRRecognizer = 1, + DISPID_SRAllowAudioInputFormatChangesOnNextSet, + DISPID_SRAudioInput, + DISPID_SRAudioInputStream, + DISPID_SRIsShared, + DISPID_SRState, + DISPID_SRStatus, + DISPID_SRProfile, + DISPID_SREmulateRecognition, + DISPID_SRCreateRecoContext, + DISPID_SRGetFormat, + DISPID_SRSetPropertyNumber, + DISPID_SRGetPropertyNumber, + DISPID_SRSetPropertyString, + DISPID_SRGetPropertyString, + DISPID_SRIsUISupported, + DISPID_SRDisplayUI, + DISPID_SRGetRecognizers, + DISPID_SVGetAudioInputs, + DISPID_SVGetProfiles +} DISPID_SpeechRecognizer; + +///////////////////////////////////////////////// +// +// SpeechLexiconType Enum +// SAPI C++ Only Interface Equivalent: +// +///////////////////////////////////////////////// + +typedef enum SpeechRecognizerState +{ + SRSInactive = SPRST_INACTIVE, + SRSActive = SPRST_ACTIVE, + SRSActiveAlways = SPRST_ACTIVE_ALWAYS, + SRSInactiveWithPurge = SPRST_INACTIVE_WITH_PURGE, +} SpeechRecognizerState; + +///////////////////////////////////////////////// +// +// SpeechDisplayAttributes Enum +// SAPI C++ Only Interface Equivalent: +// +///////////////////////////////////////////////// + +typedef enum SpeechDisplayAttributes +{ + SDA_No_Trailing_Space = 0, + SDA_One_Trailing_Space = SPAF_ONE_TRAILING_SPACE, + SDA_Two_Trailing_Spaces = SPAF_TWO_TRAILING_SPACES, + SDA_Consume_Leading_Spaces = SPAF_CONSUME_LEADING_SPACES +} SpeechDisplayAttributes; + +///////////////////////////////////////////////// +// +// SpeechFormatType Enum +// SAPI C++ Only Interface Equivalent: +// +///////////////////////////////////////////////// +typedef enum SpeechFormatType +{ + SFTInput = SPWF_INPUT, + SFTSREngine = SPWF_SRENGINE +} SpeechFormatType; + +[ + object, + uuid(2D5F1C0C-BD75-4b08-9478-3B11FEA2586C), + dual, + helpstring("ISpeechRecognizer Interface"), + pointer_default(unique) +] +interface ISpeechRecognizer : IDispatch +{ + // Properties + + // Recognizer + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propputref, helpstring("Recognizer"), id(DISPID_SRRecognizer)] + HRESULT Recognizer( [in]ISpeechObjectToken* Recognizer ); + [propget, helpstring("Recognizer"), id(DISPID_SRRecognizer)] + HRESULT Recognizer( [out,retval]ISpeechObjectToken** Recognizer ); + + // AllowAudioInputFormatChangesOnNextSet + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propput, hidden, helpstring("AllowAudioInputFormatChangesOnNextSet"), id(DISPID_SRAllowAudioInputFormatChangesOnNextSet)] + HRESULT AllowAudioInputFormatChangesOnNextSet([in] VARIANT_BOOL Allow ); + [propget, hidden, helpstring("AllowAudioInputFormatChangesOnNextSet"), id(DISPID_SRAllowAudioInputFormatChangesOnNextSet)] + HRESULT AllowAudioInputFormatChangesOnNextSet([out,retval] VARIANT_BOOL* Allow ); + + // AudioInput + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propputref, helpstring("AudioInput"), id(DISPID_SRAudioInput)] + HRESULT AudioInput( [in,defaultvalue(0)]ISpeechObjectToken* AudioInput ); + [propget, helpstring("AudioInput"), id(DISPID_SRAudioInput)] + HRESULT AudioInput( [out,retval]ISpeechObjectToken** AudioInput ); + + // AudioInputStream + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propputref, helpstring("AudioInputStream"), id(DISPID_SRAudioInputStream)] + HRESULT AudioInputStream( [in,defaultvalue(0)]ISpeechBaseStream* AudioInputStream ); + [propget, helpstring("AudioInputStream"), id(DISPID_SRAudioInputStream)] + HRESULT AudioInputStream( [out,retval]ISpeechBaseStream** AudioInputStream ); + + // IsShared + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("IsShared"), id(DISPID_SRIsShared)] + HRESULT IsShared( [out,retval]VARIANT_BOOL* Shared ); + + // State + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propput, helpstring("State"), id(DISPID_SRState)] + HRESULT State([in] SpeechRecognizerState State ); + [propget, helpstring("State"), id(DISPID_SRState)] + HRESULT State([out,retval] SpeechRecognizerState* State ); + + // Status + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Status"), id(DISPID_SRStatus)] + HRESULT Status([out,retval]ISpeechRecognizerStatus** Status ); + + // Profile + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propputref, helpstring("Profile"), id(DISPID_SRProfile)] + HRESULT Profile( [in,defaultvalue(0)]ISpeechObjectToken* Profile ); + [propget, helpstring("Profile"), id(DISPID_SRProfile)] + HRESULT Profile( [out,retval]ISpeechObjectToken** Profile ); + + // Methods + + // EmulateRecognition + // SAPI C++ Only Interface Equivalent: + // + // Notes: + // TextElements param: + // * This parameter specifies the elements of the phrase to EmulateRecognition with. + // * If it is a BSTR string then its assumed that the elements in TextElements are assumed to be + // space delimited and you cannot use the DisplayAttributes parameter (it is ignored). + // * If it is an array of BSTR words then you are specifying each element in the phrase and + // you can optionally specify the ElementDisplayAttributes as appropriate. + // * You can specify additional information for each element by using the following syntax on + // each TextElement: "/display_text/lexical_form/pronounciation;". This syntax can be used in both the + // BSTR and the array of BSTRs case. + // ElementDisplayAttributes param: + // * This parameter specifies the SpeechDisplayAttribute to use for each Word element. + // * If it is a NULL pointer, VT_NULL, or VT_EMPTY then SDA_No_Trailing_Space is assumed (default). + // * If it is a BSTR then it can be "" (empty string), " " (space), or " " (double space) + // and we'll pick the appropriate SpeechDispalyAttribute that matches and use this for all text elements. + // * If it is a integer value (VT_I1 to VT_I4) then this value is a SpeechDisplayAttribute value and + // it is used for each element in the Words array for the DisplayAttribute setting. + // and we'll pick the appropriate SpeechDispalyAttribute that matches and use this for all text elements. + // * If it is an array of integer values (VT_I1 to VT_I4) we'll use those values for the SpeechDisplayAttribute + // of each corresponding element in the TextElements array. + // * This parameter is only valid if you are using an array of BSTRs for the TextElements parameter (ignored + // if you pass in BSTR for Words). + // + [helpstring("EmulateRecognition"), id(DISPID_SREmulateRecognition)] + HRESULT EmulateRecognition( [in]VARIANT TextElements, [in, defaultvalue(NULL)]VARIANT* ElementDisplayAttributes, [in, defaultvalue(0)]long LanguageId); + + // CreateRecoContext + // SAPI C++ Only Interface Equivalent: + // + [helpstring("CreateRecoContext"), id(DISPID_SRCreateRecoContext)] + HRESULT CreateRecoContext([out,retval]ISpeechRecoContext** NewContext ); + + // GetFormat + // SAPI C++ Only Interface Equivalent: + // + [helpstring("GetFormat"), id(DISPID_SRGetFormat)] + HRESULT GetFormat([in] SpeechFormatType Type, [out,retval]ISpeechAudioFormat** Format ); + + // SetPropertyNumber + // SAPI C++ Only Interface Equivalent: + // + [helpstring("SetPropertyNumber"), hidden, id(DISPID_SRSetPropertyNumber)] + HRESULT SetPropertyNumber( [in]const BSTR Name, [in]long Value, [out,retval]VARIANT_BOOL * Supported ); + + // GetPropertyNumber + // SAPI C++ Only Interface Equivalent: + // + [helpstring("GetPropertyNumber"), hidden, id(DISPID_SRGetPropertyNumber)] + HRESULT GetPropertyNumber( [in]const BSTR Name, [in,out]long* Value, [out,retval]VARIANT_BOOL * Supported ); + + // SetPropertyString + // SAPI C++ Only Interface Equivalent: + // + [helpstring("SetPropertyString"), hidden, id(DISPID_SRSetPropertyString)] + HRESULT SetPropertyString( [in]const BSTR Name, [in]const BSTR Value, [out,retval]VARIANT_BOOL * Supported ); + + // GetPropertyString + // SAPI C++ Only Interface Equivalent: + // + [helpstring("GetPropertyString"), hidden, id(DISPID_SRGetPropertyString)] + HRESULT GetPropertyString( [in]const BSTR Name, [in,out]BSTR* Value, [out,retval]VARIANT_BOOL * Supported ); + + // IsUISupported + // SAPI C++ Only Interface Equivalent: + // + [helpstring("IsUISupported"), id(DISPID_SRIsUISupported)] + HRESULT IsUISupported( [in]const BSTR TypeOfUI, + [in, defaultvalue(NULL)]const VARIANT* ExtraData, + [out,retval] VARIANT_BOOL* Supported ); + + // DisplayUI + // SAPI C++ Only Interface Equivalent: + // + [helpstring("DisplayUI"), id(DISPID_SRDisplayUI)] + HRESULT DisplayUI( [in]long hWndParent, + [in]BSTR Title, + [in]const BSTR TypeOfUI, + [in, defaultvalue(NULL)]const VARIANT* ExtraData); + + // GetRecognizers + // SAPI C++ Only Interface Equivalent: + // + [helpstring("GetRecognizers"), id(DISPID_SRGetRecognizers)] + HRESULT GetRecognizers([in, defaultvalue("")]BSTR RequiredAttributes, + [in, defaultvalue("")]BSTR OptionalAttributes, + [out,retval]ISpeechObjectTokens** ObjectTokens ); + + // GetAudioOutputs + // SAPI C++ Only Interface Equivalent: IEnumSpObjectTokens + // + [helpstring("GetAudioInputs"), id(DISPID_SVGetAudioInputs)] + HRESULT GetAudioInputs([in, defaultvalue("")]BSTR RequiredAttributes, + [in, defaultvalue("")]BSTR OptionalAttributes, + [out,retval]ISpeechObjectTokens** ObjectTokens ); + + // GetProfiles + // SAPI C++ Only Interface Equivalent: IEnumSpObjectTokens + // + [helpstring("GetProfiles"), id(DISPID_SVGetProfiles)] + HRESULT GetProfiles([in, defaultvalue("")]BSTR RequiredAttributes, + [in, defaultvalue("")]BSTR OptionalAttributes, + [out,retval]ISpeechObjectTokens** ObjectTokens ); + +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechRecognizerStatus +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechRecognizerStatus +{ + DISPID_SRSAudioStatus = 1, + DISPID_SRSCurrentStreamPosition, + DISPID_SRSCurrentStreamNumber, + DISPID_SRSNumberOfActiveRules, + DISPID_SRSClsidEngine, + DISPID_SRSSupportedLanguages +} DISPID_SpeechRecognizerStatus; + +[ + object, + uuid(BFF9E781-53EC-484e-BB8A-0E1B5551E35C), + dual, + helpstring("ISpeechRecognizerStatus Interface"), + pointer_default(unique) +] +interface ISpeechRecognizerStatus : IDispatch +{ + // Properties + + // AudioStatus + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("AudioStatus"),id(DISPID_SRSAudioStatus)] + HRESULT AudioStatus([out,retval]ISpeechAudioStatus** AudioStatus ); + + // CurrentStreamPosition + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("CurrentStreamPosition"), id(DISPID_SRSCurrentStreamPosition)] + HRESULT CurrentStreamPosition([out,retval]VARIANT* pCurrentStreamPos ); + + // CurrentStreamNumber + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("CurrentStreamNumber"), id(DISPID_SRSCurrentStreamNumber)] + HRESULT CurrentStreamNumber([out,retval]long* StreamNumber ); + + // NumberOfActiveRules + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("NumberOfActiveRules"), id(DISPID_SRSNumberOfActiveRules)] + HRESULT NumberOfActiveRules([out,retval]long* NumberOfActiveRules ); + + // ClsidEngine + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("ClsidEngine"), id(DISPID_SRSClsidEngine)] + HRESULT ClsidEngine([out,retval]BSTR* ClsidEngine ); + + // SupportedLanguages + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("SupportedLanguages"), id(DISPID_SRSSupportedLanguages)] + HRESULT SupportedLanguages([out,retval]VARIANT* SupportedLanguages ); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechRecoContext +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechRecoContext +{ + DISPID_SRCRecognizer = 1, + DISPID_SRCAudioInInterferenceStatus, + DISPID_SRCRequestedUIType, + DISPID_SRCVoice, + DISPID_SRAllowVoiceFormatMatchingOnNextSet, + DISPID_SRCVoicePurgeEvent, + DISPID_SRCEventInterests, + DISPID_SRCCmdMaxAlternates, + DISPID_SRCState, + DISPID_SRCRetainedAudio, + DISPID_SRCRetainedAudioFormat, + DISPID_SRCPause, + DISPID_SRCResume, + DISPID_SRCCreateGrammar, + DISPID_SRCCreateResultFromMemory, + DISPID_SRCBookmark, + DISPID_SRCSetAdaptationData +} DISPID_SpeechRecoContext; + +///////////////////////////////////////////////// +// +// SpeechRetainedAudioOptions Enum +// SAPI C++ Only Interface Equivalent: +// +///////////////////////////////////////////////// + +typedef enum SpeechRetainedAudioOptions +{ + SRAONone = SPAO_NONE, + SRAORetainAudio = SPAO_RETAIN_AUDIO +} SpeechRetainedAudioOptions; + +///////////////////////////////////////////////// +// +// SpeechBookmarkOptions Enum +// SAPI C++ Only Interface Equivalent: +// +///////////////////////////////////////////////// + +typedef enum SpeechBookmarkOptions +{ + SBONone = SPBO_NONE, + SBOPause = SPBO_PAUSE +} SpeechBookmarkOptions; + +///////////////////////////////////////////////// +// +// SpeechInterference Enum +// SAPI C++ Only Interface Equivalent: +// +///////////////////////////////////////////////// + +typedef enum SpeechInterference +{ + SINone = SPINTERFERENCE_NONE, + SINoise = SPINTERFERENCE_NOISE, + SINoSignal = SPINTERFERENCE_NOSIGNAL, + SITooLoud = SPINTERFERENCE_TOOLOUD, + SITooQuiet = SPINTERFERENCE_TOOQUIET, + SITooFast = SPINTERFERENCE_TOOFAST, + SITooSlow = SPINTERFERENCE_TOOSLOW +} SpeechInterference; + +///////////////////////////////////////////////// +// +// SpeechRecoEvents Enum +// SAPI C++ Only Interface Equivalent: +// +///////////////////////////////////////////////// + +typedef enum SpeechRecoEvents +{ + SREStreamEnd = (1L << 0), // SR engine has reached the end of an input stream + SRESoundStart = (1L << 1), // SR engine has detected the start of non-trivial audio data + SRESoundEnd = (1L << 2), // SR engine has detected the end of non-trivial audio data + SREPhraseStart = (1L << 3), // SR engine has detected the start of a recognizable phrase + SRERecognition = (1L << 4), // SR engine's best hypothesis for the audio data + SREHypothesis = (1L << 5), // SR engine's interim hypothesis for the result of the audio data + SREBookmark = (1L << 6), // SR engine has reached the specified point in the audio stream + SREPropertyNumChange = (1L << 7), // LPARAM points to a string, WPARAM is the attrib value + SREPropertyStringChange = (1L << 8), // LPARAM pointer to buffer. Two concatinated null terminated strings. + SREFalseRecognition = (1L << 9), // apparent speech with no valid recognition + SREInterference = (1L << 10), // LPARAM is any combination of SPINTERFERENCE flags + SRERequestUI = (1L << 11), // LPARAM is string. + SREStateChange = (1L << 12), // wParam contains new reco state + SREAdaptation = (1L << 13), // the adaptation buffer is now ready to be accepted + SREStreamStart = (1L << 14), // SR engine has reached the start of an input stream + SRERecoOtherContext = (1L << 15), // Phrase finished and recognized, but for other context + SREAudioLevel = (1L << 16), // input audio volume level + SREPrivate = (1L << 18), // private engine specific event + SREAllEvents = 0x5FFFF // All Reco events on. +} SpeechRecoEvents; + +///////////////////////////////////////////////// +// +// SpeechRecoContextState Enum +// SAPI C++ Only Interface Equivalent: +// +///////////////////////////////////////////////// + +typedef enum SpeechRecoContextState +{ + SRCS_Disabled = SPCS_DISABLED, + SRCS_Enabled = SPCS_ENABLED +} SpeechRecoContextState; + +[ + object, + uuid(580AA49D-7E1E-4809-B8E2-57DA806104B8), + dual, + helpstring("ISpeechRecoContext Interface"), + pointer_default(unique) +] +interface ISpeechRecoContext : IDispatch +{ + // Properties + + // Recognizer + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Recognizer"), id(DISPID_SRCRecognizer)] + HRESULT Recognizer( [out,retval]ISpeechRecognizer** Recognizer ); + + // AudioInInterferenceStatus + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("AudioInInterferenceStatus"), id(DISPID_SRCAudioInInterferenceStatus)] + HRESULT AudioInputInterferenceStatus( [out,retval]SpeechInterference* Interference ); + + // RequestedUIType + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("RequestedUIType"), id(DISPID_SRCRequestedUIType)] + HRESULT RequestedUIType( [out,retval]BSTR* UIType ); + + // Voice + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propputref, helpstring("Voice"), id(DISPID_SRCVoice)] + HRESULT Voice([in]ISpeechVoice *Voice ); + [propget, helpstring("Voice"), id(DISPID_SRCVoice)] + HRESULT Voice([out,retval]ISpeechVoice **Voice ); + + // AllowVoiceFormatMatchingOnNextSet + // + [propput, hidden, helpstring("AllowVoiceFormatMatchingOnNextSet"), id(DISPID_SRAllowVoiceFormatMatchingOnNextSet)] + HRESULT AllowVoiceFormatMatchingOnNextSet([in] VARIANT_BOOL Allow ); + [propget, hidden, helpstring("AllowAudioInputFormatChangesOnNextSet"), id(DISPID_SRAllowVoiceFormatMatchingOnNextSet)] + HRESULT AllowVoiceFormatMatchingOnNextSet([out,retval] VARIANT_BOOL* pAllow ); + + // VoicePurgeEvent + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propput, helpstring("VoicePurgeEvent"), id(DISPID_SRCVoicePurgeEvent)] + HRESULT VoicePurgeEvent( [in]SpeechRecoEvents EventInterest ); + [propget, helpstring("VoicePurgeEvent"), id(DISPID_SRCVoicePurgeEvent)] + HRESULT VoicePurgeEvent( [out,retval]SpeechRecoEvents* EventInterest ); + + // EventInterests + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propput, helpstring("EventInterests"), id(DISPID_SRCEventInterests)] + HRESULT EventInterests( [in]SpeechRecoEvents EventInterest ); + [propget, helpstring("EventInterests"), id(DISPID_SRCEventInterests)] + HRESULT EventInterests( [out,retval]SpeechRecoEvents* EventInterest ); + + // CmdMaxAlternates + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propput, helpstring("CmdMaxAlternates"), id(DISPID_SRCCmdMaxAlternates)] + HRESULT CmdMaxAlternates([in] long MaxAlternates ); + [propget, helpstring("CmdMaxAlternates"), id(DISPID_SRCCmdMaxAlternates)] + HRESULT CmdMaxAlternates([out,retval] long* MaxAlternates ); + + // State + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propput, helpstring("State"), id(DISPID_SRCState)] + HRESULT State([in] SpeechRecoContextState State ); + [propget, helpstring("State"), id(DISPID_SRCState)] + HRESULT State([out,retval] SpeechRecoContextState* State ); + + // RetainedAudio + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propput, helpstring("RetainedAudio"), id(DISPID_SRCRetainedAudio)] + HRESULT RetainedAudio([in]SpeechRetainedAudioOptions Option); + [propget, helpstring("RetainedAudio"), id(DISPID_SRCRetainedAudio)] + HRESULT RetainedAudio([out,retval]SpeechRetainedAudioOptions* Option); + + // RetainedAudioFormat + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propputref, helpstring("RetainedAudioFormat"), id(DISPID_SRCRetainedAudioFormat)] + HRESULT RetainedAudioFormat([in] ISpeechAudioFormat* Format ); + [propget, helpstring("RetainedAudioFormat"), id(DISPID_SRCRetainedAudioFormat)] + HRESULT RetainedAudioFormat([out,retval] ISpeechAudioFormat** Format ); + + // Methods + + // Pause + // SAPI C++ Only Interface Equivalent: + // + [helpstring("Pause"), id(DISPID_SRCPause)] + HRESULT Pause(void); + + // Resume + // SAPI C++ Only Interface Equivalent: + // + [helpstring("Resume"), id(DISPID_SRCResume)] + HRESULT Resume(void); + + // CreateGrammar + // SAPI C++ Only Interface Equivalent: + // + [helpstring("CreateGrammar"), id(DISPID_SRCCreateGrammar)] + HRESULT CreateGrammar( [in, defaultvalue(0)]VARIANT GrammarId, [out,retval]ISpeechRecoGrammar** Grammar ); + + // CreateResultFromMemory + // SAPI C++ Only Interface Equivalent: + // + [helpstring("CreateResultFromMemory"), id(DISPID_SRCCreateResultFromMemory)] + HRESULT CreateResultFromMemory( [in]VARIANT* ResultBlock, [out,retval]ISpeechRecoResult **Result ); + + // Bookmark + // SAPI C++ Only Interface Equivalent: + // + [helpstring("Bookmark"), id(DISPID_SRCBookmark)] + HRESULT Bookmark( [in]SpeechBookmarkOptions Options, [in]VARIANT StreamPos, [in]VARIANT BookmarkId ); + + // SetAdaptationData + // SAPI C++ Only Interface Equivalent: + // + [helpstring("SetAdaptationData"), id(DISPID_SRCSetAdaptationData)] + HRESULT SetAdaptationData( [in]BSTR AdaptationString ); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechRecoGrammar +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPIDSPRG +{ + DISPID_SRGId = 1, + DISPID_SRGRecoContext, + DISPID_SRGState, + DISPID_SRGRules, + DISPID_SRGReset, + DISPID_SRGCommit, + DISPID_SRGCmdLoadFromFile, + DISPID_SRGCmdLoadFromObject, + DISPID_SRGCmdLoadFromResource, + DISPID_SRGCmdLoadFromMemory, + DISPID_SRGCmdLoadFromProprietaryGrammar, + DISPID_SRGCmdSetRuleState, + DISPID_SRGCmdSetRuleIdState, + DISPID_SRGDictationLoad, + DISPID_SRGDictationUnload, + DISPID_SRGDictationSetState, + DISPID_SRGSetWordSequenceData, + DISPID_SRGSetTextSelection, + DISPID_SRGIsPronounceable +} DISPIDSPRG; + +///////////////////////////////////////////////// +// +// SpeechLoadOption Enum +// SAPI C++ Only Interface Equivalent: +// +///////////////////////////////////////////////// + +typedef enum SpeechLoadOption +{ + SLOStatic = SPLO_STATIC, + SLODynamic = SPLO_DYNAMIC +} SpeechLoadOption; + +///////////////////////////////////////////////// +// +// SpeechWordPronounceable Enum +// SAPI C++ Only Interface Equivalent: +// +///////////////////////////////////////////////// + +typedef enum SpeechWordPronounceable +{ + SWPUnknownWordUnpronounceable = SPWP_UNKNOWN_WORD_UNPRONOUNCEABLE, + SWPUnknownWordPronounceable = SPWP_UNKNOWN_WORD_PRONOUNCEABLE, + SWPKnownWordPronounceable = SPWP_KNOWN_WORD_PRONOUNCEABLE +} SpeechWordPronounceable; + +///////////////////////////////////////////////// +// +// SpeechGrammarState Enum +// SAPI C++ Only Interface Equivalent: +// +///////////////////////////////////////////////// + +typedef enum SpeechGrammarState +{ + SGSEnabled = SPGS_ENABLED, + SGSDisabled = SPGS_DISABLED, + SGSExclusive = SPGS_EXCLUSIVE, +} SpeechGrammarState; + +///////////////////////////////////////////////// +// +// SpeechRuleState Enum +// SAPI C++ Only Interface Equivalent: +// +///////////////////////////////////////////////// + +typedef enum SpeechRuleState +{ + SGDSInactive = SPRS_INACTIVE, + SGDSActive = SPRS_ACTIVE, + SGDSActiveWithAutoPause = SPRS_ACTIVE_WITH_AUTO_PAUSE +} SpeechRuleState; + +///////////////////////////////////////////////// +// +// SpeechRuleAttributes Enum +// SAPI C++ Only Interface Equivalent: +// +///////////////////////////////////////////////// + +typedef enum SpeechRuleAttributes +{ + SRATopLevel = SPRAF_TopLevel, + SRADefaultToActive = SPRAF_Active, + SRAExport = SPRAF_Export, + SRAImport = SPRAF_Import, + SRAInterpreter = SPRAF_Interpreter, + SRADynamic = SPRAF_Dynamic +} SpeechRuleAttributes; + +///////////////////////////////////////////////// +// +// SpeechGrammarWordType Enum +// SAPI C++ Only Interface Equivalent: +// +///////////////////////////////////////////////// + +typedef enum SpeechGrammarWordType +{ + SGDisplay = SPWT_DISPLAY, // Not implemented + SGLexical = SPWT_LEXICAL, + SGPronounciation = SPWT_PRONUNCIATION // Not implemented +} SpeechGrammarWordType; + +[ + object, + uuid(B6D6F79F-2158-4e50-B5BC-9A9CCD852A09), + dual, + helpstring("ISpeechRecoGrammar Interface"), + pointer_default(unique) +] +interface ISpeechRecoGrammar : IDispatch +{ + // Properties + + // Id + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Id"), id(DISPID_SRGId)] + HRESULT Id( [out,retval]VARIANT* Id ); + + // RecoContext + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("RecoContext"), id(DISPID_SRGRecoContext)] + HRESULT RecoContext( [out,retval] ISpeechRecoContext** RecoContext ); + + // State + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propput, helpstring("State"), id(DISPID_SRGState)] + HRESULT State( [in]SpeechGrammarState State ); + [propget, helpstring("State"), id(DISPID_SRGState)] + HRESULT State( [out,retval]SpeechGrammarState* State); + + // Rules + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Rules"), id(DISPID_SRGRules)] + HRESULT Rules( [out,retval]ISpeechGrammarRules** Rules); + + // Methods + + // Reset + // SAPI C++ Only Interface Equivalent: + // + [helpstring("Reset"), id(DISPID_SRGReset)] + HRESULT Reset([in, defaultvalue(0)]SpeechLanguageId NewLanguage); + + // CmdLoadFromFile + // SAPI C++ Only Interface Equivalent: + // + [helpstring("CmdLoadFromFile"), id(DISPID_SRGCmdLoadFromFile)] + HRESULT CmdLoadFromFile( [in]const BSTR FileName, [in, defaultvalue(SLOStatic)]SpeechLoadOption LoadOption ); + + // CmdLoadFromObject + // SAPI C++ Only Interface Equivalent: + // + [helpstring("CmdLoadFromObject"), id(DISPID_SRGCmdLoadFromObject)] + HRESULT CmdLoadFromObject( [in]const BSTR ClassId, + [in]const BSTR GrammarName, + [in, defaultvalue(SLOStatic)]SpeechLoadOption LoadOption ); + + // CmdLoadFromResource + // SAPI C++ Only Interface Equivalent: + // + [helpstring("CmdLoadFromResource"), id(DISPID_SRGCmdLoadFromResource)] + HRESULT CmdLoadFromResource( [in]long hModule, + [in]VARIANT ResourceName, + [in]VARIANT ResourceType, + [in]SpeechLanguageId LanguageId, + [in, defaultvalue(SLOStatic)]SpeechLoadOption LoadOption ); + + // CmdLoadFromMemory + // SAPI C++ Only Interface Equivalent: + // + [helpstring("CmdLoadFromMemory"), id(DISPID_SRGCmdLoadFromMemory)] + HRESULT CmdLoadFromMemory( [in] VARIANT GrammarData, [in, defaultvalue(SLOStatic)]SpeechLoadOption LoadOption ); + + // CmdLoadFromProprietaryGrammar + // SAPI C++ Only Interface Equivalent: + // + [helpstring("CmdLoadFromProprietaryGrammar"), id(DISPID_SRGCmdLoadFromProprietaryGrammar)] + HRESULT CmdLoadFromProprietaryGrammar( [in]const BSTR ProprietaryGuid, + [in]const BSTR ProprietaryString, + [in]VARIANT ProprietaryData, + [in, defaultvalue(SLOStatic)]SpeechLoadOption LoadOption ); + + // CmdSetRuleState + // SAPI C++ Only Interface Equivalent: + // + [helpstring("CmdSetRuleState"), id(DISPID_SRGCmdSetRuleState)] + HRESULT CmdSetRuleState( [in/*, defaultvalue("")*/]const BSTR Name, [in]SpeechRuleState State); + + // CmdSetRuleIdState + // SAPI C++ Only Interface Equivalent: + // + [helpstring("CmdSetRuleIdState"), id(DISPID_SRGCmdSetRuleIdState)] + HRESULT CmdSetRuleIdState( [in/*, defaultvalue(0)*/]long RuleId, [in]SpeechRuleState State ); + + // DictationLoad + // SAPI C++ Only Interface Equivalent: + // + [helpstring("DictationLoad"), id(DISPID_SRGDictationLoad)] + HRESULT DictationLoad( [in, defaultvalue("")] const BSTR TopicName, [in, defaultvalue(SLOStatic)]SpeechLoadOption LoadOption ); + + // DictationUnload + // SAPI C++ Only Interface Equivalent: + // + [helpstring("DictationUnload"), id(DISPID_SRGDictationUnload)] + HRESULT DictationUnload( void ); + + // DictationSetState + // SAPI C++ Only Interface Equivalent: + // + [helpstring("DictationSetState"), id(DISPID_SRGDictationSetState)] + HRESULT DictationSetState( [in]SpeechRuleState State ); + + // SetWordSequenceData + // SAPI C++ Only Interface Equivalent: + // + [helpstring("SetWordSequenceData"), id(DISPID_SRGSetWordSequenceData)] + HRESULT SetWordSequenceData( [in]const BSTR Text, [in]long TextLength, [in]ISpeechTextSelectionInformation* Info ); + + // SetTextSelection + // SAPI C++ Only Interface Equivalent: + // + [helpstring("SetTextSelection"), id(DISPID_SRGSetTextSelection)] + HRESULT SetTextSelection( [in]ISpeechTextSelectionInformation* Info ); + + // IsPronounceable + // SAPI C++ Only Interface Equivalent: + // + [helpstring("IsPronounceable"), id(DISPID_SRGIsPronounceable)] + HRESULT IsPronounceable( [in]const BSTR Word, [out,retval]SpeechWordPronounceable* WordPronounceable ); +}; + + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// _ISpeechRecoContextEvents +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechRecoContextEvents +{ + DISPID_SRCEStartStream = 1, + DISPID_SRCEEndStream, + DISPID_SRCEBookmark, + DISPID_SRCESoundStart, + DISPID_SRCESoundEnd, + DISPID_SRCEPhraseStart, + DISPID_SRCERecognition, + DISPID_SRCEHypothesis, + DISPID_SRCEPropertyNumberChange, + DISPID_SRCEPropertyStringChange, + DISPID_SRCEFalseRecognition, + DISPID_SRCEInterference, + DISPID_SRCERequestUI, + DISPID_SRCERecognizerStateChange, + DISPID_SRCEAdaptation, + DISPID_SRCERecognitionForOtherContext, + DISPID_SRCEAudioLevel, + DISPID_SRCEEnginePrivate +} DISPID_SpeechRecoContextEvents; + +///////////////////////////////////////////////// +// +// SpeechRecognitionType Enum +// SAPI C++ Only Interface Equivalent: +// +///////////////////////////////////////////////// + +typedef enum SpeechRecognitionType +{ + SRTStandard = 0, + SRTAutopause = SPREF_AutoPause, + SRTEmulated = SPREF_Emulated +} SpeechRecognitionType; + +[ + uuid(7B8FCB42-0E9D-4f00-A048-7B04D6179D3D) +] +dispinterface _ISpeechRecoContextEvents +{ + properties: + methods: + + // Methods + + // StartStream + // SAPI C++ Only Interface Equivalent: + // + [helpstring("StartStream"), id(DISPID_SRCEStartStream)] + void StartStream([in]long StreamNumber, [in]VARIANT StreamPosition); + + // EndStream + // SAPI C++ Only Interface Equivalent: + // + [helpstring("EndStream"), id(DISPID_SRCEEndStream)] + void EndStream([in]long StreamNumber, [in]VARIANT StreamPosition, [in]VARIANT_BOOL StreamReleased); + + // Bookmark + // SAPI C++ Only Interface Equivalent: + // + [helpstring("Bookmark"), id(DISPID_SRCEBookmark)] + void Bookmark([in]long StreamNumber, [in]VARIANT StreamPosition, [in]VARIANT BookmarkId, [in]SpeechBookmarkOptions Options); + + // SoundStart + // SAPI C++ Only Interface Equivalent: + // + [helpstring("SoundStart"), id(DISPID_SRCESoundStart)] + void SoundStart([in]long StreamNumber, [in]VARIANT StreamPosition); + + // SoundEnd + // SAPI C++ Only Interface Equivalent: + // + [helpstring("SoundEnd"), id(DISPID_SRCESoundEnd)] + void SoundEnd([in]long StreamNumber, [in]VARIANT StreamPosition); + + // PhraseStart + // SAPI C++ Only Interface Equivalent: + // + [helpstring("PhraseStart"), id(DISPID_SRCEPhraseStart)] + void PhraseStart([in]long StreamNumber, [in]VARIANT StreamPosition); + + // Recognition + // SAPI C++ Only Interface Equivalent: + // + [helpstring("Recognition"), id(DISPID_SRCERecognition)] + void Recognition([in]long StreamNumber, [in]VARIANT StreamPosition, [in]SpeechRecognitionType RecognitionType, [in]ISpeechRecoResult * Result); + + // Hypothesis + // SAPI C++ Only Interface Equivalent: + // + [helpstring("Hypothesis"), id(DISPID_SRCEHypothesis)] + void Hypothesis([in]long StreamNumber, [in]VARIANT StreamPosition, [in]ISpeechRecoResult* Result); + + // PropertyNumberChange + // SAPI C++ Only Interface Equivalent: + // + [helpstring("PropertyNumberChange"), id(DISPID_SRCEPropertyNumberChange)] + void PropertyNumberChange([in]long StreamNumber, [in]VARIANT StreamPosition, [in]BSTR PropertyName, [in]long NewNumberValue); + + // PropertyStringChange + // SAPI C++ Only Interface Equivalent: + // + [helpstring("PropertyStringChange"), id(DISPID_SRCEPropertyStringChange)] + void PropertyStringChange([in]long StreamNumber, [in]VARIANT StreamPosition, [in]BSTR PropertyName, [in]BSTR NewStringValue); + + // FalseRecognition + // SAPI C++ Only Interface Equivalent: + // + [helpstring("FalseRecognition"), id(DISPID_SRCEFalseRecognition)] + void FalseRecognition([in]long StreamNumber, [in]VARIANT StreamPosition, [in]ISpeechRecoResult* Result); + + // Interference + // SAPI C++ Only Interface Equivalent: + // + [helpstring("Interference"), id(DISPID_SRCEInterference)] + void Interference([in]long StreamNumber, [in]VARIANT StreamPosition, [in]SpeechInterference Interference); + + // RequestUI + // SAPI C++ Only Interface Equivalent: + // + [helpstring("RequestUI"), id(DISPID_SRCERequestUI)] + void RequestUI([in]long StreamNumber, [in]VARIANT StreamPosition, [in]BSTR UIType); + + // RecognizerStateChange + // SAPI C++ Only Interface Equivalent: + // + [helpstring("RecognizerStateChange"), id(DISPID_SRCERecognizerStateChange)] + void RecognizerStateChange([in]long StreamNumber, [in]VARIANT StreamPosition, [in]SpeechRecognizerState NewState); + + // Adaption + // SAPI C++ Only Interface Equivalent: + // + [helpstring("Adaptation"), id(DISPID_SRCEAdaptation)] + void Adaptation([in]long StreamNumber, [in]VARIANT StreamPosition); + + // RecognitionForOtherContext + // SAPI C++ Only Interface Equivalent: + // + [helpstring("RecognitionForOtherContext"), id(DISPID_SRCERecognitionForOtherContext)] + void RecognitionForOtherContext([in]long StreamNumber, [in]VARIANT StreamPosition); + + // AudioLevel + // SAPI C++ Only Interface Equivalent: + // + [helpstring("AudioLevel"), id(DISPID_SRCEAudioLevel)] + void AudioLevel([in]long StreamNumber, [in]VARIANT StreamPosition, [in]long AudioLevel); + + // EnginePrivate + // SAPI C++ Only Interface Equivalent: + // + [helpstring("EnginePrivate"), id(DISPID_SRCEEnginePrivate)] + void EnginePrivate([in]long StreamNumber, [in]VARIANT StreamPosition, [in]VARIANT EngineData); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechGrammarRule +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechGrammarRule +{ + DISPID_SGRAttributes = 1, + DISPID_SGRInitialState, + DISPID_SGRName, + DISPID_SGRId, + DISPID_SGRClear, + DISPID_SGRAddResource, + DISPID_SGRAddState +} DISPID_SpeechGrammarRule; + +[ + object, + uuid(AFE719CF-5DD1-44f2-999C-7A399F1CFCCC), + dual, + helpstring("ISpeechGrammarRule Interface"), + pointer_default(unique) +] +interface ISpeechGrammarRule : IDispatch +{ + // Properties + + // RuleAttributes + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("RuleAttributes"), id(DISPID_SGRAttributes)] + HRESULT Attributes([out, retval] SpeechRuleAttributes* Attributes ); + + // InitialState + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("InitialState"), id(DISPID_SGRInitialState)] + HRESULT InitialState([out, retval] ISpeechGrammarRuleState** State); + + // Name + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Name"), id(DISPID_SGRName)] + HRESULT Name([out, retval] BSTR* Name); + + // Id + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Id"), id(DISPID_SGRId)] + HRESULT Id([out, retval] long* Id); + + // Methods + + // Clear + // SAPI C++ Only Interface Equivalent: + // + [helpstring("Clear"),id(DISPID_SGRClear)] + HRESULT Clear(); + + // AddResource + // SAPI C++ Only Interface Equivalent: + // + [helpstring("AddResource"), id(DISPID_SGRAddResource)] + HRESULT AddResource([in]const BSTR ResourceName, [in]const BSTR ResourceValue); + + // AddState + // SAPI C++ Only Interface Equivalent: + // + [helpstring("AddState"), id(DISPID_SGRAddState)] + HRESULT AddState([out, retval] ISpeechGrammarRuleState** State); +}; + + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechGrammarRules +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechGrammarRules +{ + DISPID_SGRsCount = 1, + DISPID_SGRsDynamic, + DISPID_SGRsAdd, + DISPID_SGRsCommit, + DISPID_SGRsCommitAndSave, + DISPID_SGRsFindRule, + DISPID_SGRsItem = DISPID_VALUE, + DISPID_SGRs_NewEnum = DISPID_NEWENUM +} DISPID_SpeechGrammarRules; + +[ + object, + uuid(6FFA3B44-FC2D-40d1-8AFC-32911C7F1AD1), + dual, + helpstring("ISpeechGrammarRules Interface"), + pointer_default(unique) +] +interface ISpeechGrammarRules : IDispatch +{ + // Properties + + // RuleAttributes + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Count"), id(DISPID_SGRsCount)] + HRESULT Count([out, retval] long* Count); + + // FindRule + // SAPI C++ Only Interface Equivalent: + // NOTE: This returns S_OK with NULL Rule if rule is not found. + [helpstring("FindRule"), id(DISPID_SGRsFindRule)] + HRESULT FindRule([in]VARIANT RuleNameOrId, [out, retval]ISpeechGrammarRule** Rule); + + // Item + // SAPI C++ Only Interface Equivalent: + // Default: + // + [id(DISPID_SGRsItem), helpstring("Item")] + HRESULT Item([in] long Index, [out, retval]ISpeechGrammarRule** Rule ); + + // _NewEnum + // SAPI C++ Only Interface Equivalent: + // Default: + // + [id(DISPID_SGRs_NewEnum), propget, helpstring("Enumerates the alternates"), restricted] + HRESULT _NewEnum([out, retval] IUnknown** EnumVARIANT); + + // Dynamic + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Dynamic"), id(DISPID_SGRsDynamic)] + HRESULT Dynamic([out, retval] VARIANT_BOOL *Dynamic); + + // Methods + + // Add + // SAPI C++ Only Interface Equivalent: + // + [helpstring("Add"), id(DISPID_SGRsAdd)] + HRESULT Add([in] BSTR RuleName, + [in] SpeechRuleAttributes Attributes, + [in, defaultvalue(0)] long RuleId, + [out, retval] ISpeechGrammarRule** Rule); + + // Commit + // SAPI C++ Only Interface Equivalent: + // + [helpstring("Commit"), id(DISPID_SGRsCommit)] + HRESULT Commit(void); + + // CommitAndSave + // SAPI C++ Only Interface Equivalent: + // + [helpstring("CommitAndSave"), id(DISPID_SGRsCommitAndSave)] + HRESULT CommitAndSave([out] BSTR* ErrorText, [out, retval] VARIANT* SaveStream); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechGrammarRuleState +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechGrammarRuleState +{ + DISPID_SGRSRule = 1, + DISPID_SGRSTransitions, + DISPID_SGRSAddWordTransition, + DISPID_SGRSAddRuleTransition, + DISPID_SGRSAddSpecialTransition +} DISPID_SpeechGrammarRuleState; + +typedef enum SpeechSpecialTransitionType +{ + SSTTWildcard = 1, + SSTTDictation, + SSTTTextBuffer +} SpeechSpecialTransitionType; + +[ + object, + uuid(D4286F2C-EE67-45ae-B928-28D695362EDA), + dual, + helpstring("ISpeechGrammarRuleState Interface"), + pointer_default(unique) +] +interface ISpeechGrammarRuleState : IDispatch +{ + // Properties + + // Rule + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Rule"), id(DISPID_SGRSRule)] + HRESULT Rule([out, retval] ISpeechGrammarRule** Rule); + + // Transitions + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Transitions"), id(DISPID_SGRSTransitions)] + HRESULT Transitions([out, retval] ISpeechGrammarRuleStateTransitions** Transitions); + + // Methods + + // AddWordTransition + // SAPI C++ Only Interface Equivalent: + // + [helpstring("AddWordTransition"), id(DISPID_SGRSAddWordTransition)] + HRESULT AddWordTransition([in]ISpeechGrammarRuleState* DestState, + [in]const BSTR Words, + [in, defaultvalue(" ")]const BSTR Separators, + [in, defaultvalue(SGLexical)]SpeechGrammarWordType Type, + [in, defaultvalue("")]const BSTR PropertyName, + [in, defaultvalue(0)]long PropertyId, + [in, defaultvalue(0)]VARIANT* PropertyValue, + [in, defaultvalue(1.0)]float Weight); + + // AddRuleTransition + // SAPI C++ Only Interface Equivalent: + // + [helpstring("AddRuleTransition"), id(DISPID_SGRSAddRuleTransition)] + HRESULT AddRuleTransition([in]ISpeechGrammarRuleState* DestinationState, + [in]ISpeechGrammarRule* Rule, + [in, defaultvalue("")]const BSTR PropertyName, + [in, defaultvalue(0)]long PropertyId, + [in, defaultvalue(0)]VARIANT* PropertyValue, + [in, defaultvalue(1.0)]float Weight); + + // AddSpecialTransition + // SAPI C++ Only Interface Equivalent: + // + [helpstring("AddSpecialTransition"), id(DISPID_SGRSAddSpecialTransition)] + HRESULT AddSpecialTransition([in]ISpeechGrammarRuleState* DestinationState, + [in]SpeechSpecialTransitionType Type, + [in, defaultvalue("")]const BSTR PropertyName, + [in, defaultvalue(0)]long PropertyId, + [in, defaultvalue(0)]VARIANT* PropertyValue, + [in, defaultvalue(1.0)]float Weight); + +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechGrammarStateTransitions +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechGrammarRuleStateTransitions +{ + DISPID_SGRSTsCount = 1, + DISPID_SGRSTsItem = DISPID_VALUE, + DISPID_SGRSTs_NewEnum = DISPID_NEWENUM +} DISPID_SpeechGrammarRuleStateTransitions; + +[ + object, + uuid(EABCE657-75BC-44a2-AA7F-C56476742963), + dual, + helpstring("ISpeechGrammarRuleStateTransitions Interface"), + pointer_default(unique) +] +interface ISpeechGrammarRuleStateTransitions : IDispatch +{ + // Properties + + // Count + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Count"), id(DISPID_SGRSTsCount)] + HRESULT Count([out, retval] long* Count); + + // Methods + + // Item + // SAPI C++ Only Interface Equivalent: + // + [helpstring("Item"), id(DISPID_SGRSTsItem)] + HRESULT Item([in] long Index, [out, retval]ISpeechGrammarRuleStateTransition** Transition ); + + // _NewEnum + // SAPI C++ Only Interface Equivalent: + // + [propget, helpstring("Enumerates the transitions"), restricted, id(DISPID_SGRSTs_NewEnum)] + HRESULT _NewEnum([out, retval] IUnknown** EnumVARIANT); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechGrammarStateTransition +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechGrammarRuleStateTransition +{ + DISPID_SGRSTType = 1, + DISPID_SGRSTText, + DISPID_SGRSTRule, + DISPID_SGRSTWeight, + DISPID_SGRSTPropertyName, + DISPID_SGRSTPropertyId, + DISPID_SGRSTPropertyValue, + DISPID_SGRSTNextState +} DISPID_SpeechGrammarRuleStateTransition; + +////////////////////////////////// +// +// SpeechGrammarRuleStateTransitionType Enum +// SAPI C++ Only Interface Equivalent: +// +////////////////////////////////// + +typedef enum SpeechGrammarRuleStateTransitionType +{ + SGRSTTEpsilon = 0, + SGRSTTWord, + SGRSTTRule, + SGRSTTDictation, + SGRSTTWildcard, + SGRSTTTextBuffer +} SpeechGrammarRuleStateTransitionType; + +[ + object, + uuid(CAFD1DB1-41D1-4a06-9863-E2E81DA17A9A), + dual, + helpstring("ISpeechGrammarRuleStateTransition Interface"), + pointer_default(unique) +] +interface ISpeechGrammarRuleStateTransition : IDispatch +{ + // Properties + + // Type + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Type"), id(DISPID_SGRSTType)] + HRESULT Type([out, retval] SpeechGrammarRuleStateTransitionType* Type); + + // Text + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Text"), id(DISPID_SGRSTText)] + HRESULT Text([out, retval] BSTR* Text); + + // Rule + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Rule"), id(DISPID_SGRSTRule)] + HRESULT Rule([out, retval] ISpeechGrammarRule ** Rule); + + // Weight + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Weight"), id(DISPID_SGRSTWeight)] + HRESULT Weight([out, retval] VARIANT * Weight); + + // PropertyName + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("PropertyName"), id(DISPID_SGRSTPropertyName)] + HRESULT PropertyName([out, retval] BSTR * PropertyName); + + // PropertyId + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("PropertyId"), id(DISPID_SGRSTPropertyId)] + HRESULT PropertyId([out, retval] long * PropertyId); + + // PropertyValue + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("PropertyValue"), id(DISPID_SGRSTPropertyValue)] + HRESULT PropertyValue([out, retval] VARIANT * PropertyValue); + + // NextState + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("NextState"), id(DISPID_SGRSTNextState)] + HRESULT NextState([out, retval] ISpeechGrammarRuleState ** NextState); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechTextSelectionInformation +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPIDSPTSI +{ + DISPIDSPTSI_ActiveOffset = 1, + DISPIDSPTSI_ActiveLength, + DISPIDSPTSI_SelectionOffset, + DISPIDSPTSI_SelectionLength +} DISPIDSPTSI; + +[ + object, + uuid(3B9C7E7A-6EEE-4DED-9092-11657279ADBE), + dual, + helpstring("ISpeechTextSelectionInformation Interface"), + pointer_default(unique) +] +interface ISpeechTextSelectionInformation : IDispatch +{ + // Properties + + // ActiveOffset + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propput, helpstring("ActiveOffset"), id(DISPIDSPTSI_ActiveOffset)] + HRESULT ActiveOffset( [in]long ActiveOffset ); + [propget, helpstring("ActiveOffset"), id(DISPIDSPTSI_ActiveOffset)] + HRESULT ActiveOffset( [out, retval]long* ActiveOffset ); + + // ActiveLength + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propput, helpstring("ActiveLength"), id(DISPIDSPTSI_ActiveLength)] + HRESULT ActiveLength( [in]long ActiveLength ); + [propget, helpstring("ActiveLength"), id(DISPIDSPTSI_ActiveLength)] + HRESULT ActiveLength( [out, retval]long* ActiveLength ); + + // SelectionOffset + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propput, helpstring("SelectionOffset"), id(DISPIDSPTSI_SelectionOffset)] + HRESULT SelectionOffset( [in]long SelectionOffset ); + [propget, helpstring("SelectionOffset"), id(DISPIDSPTSI_SelectionOffset)] + HRESULT SelectionOffset( [out, retval]long* SelectionOffset ); + + // SelectionLength + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propput, helpstring("SelectionLength"), id(DISPIDSPTSI_SelectionLength)] + HRESULT SelectionLength( [in]long SelectionLength ); + [propget, helpstring("SelectionLength"), id(DISPIDSPTSI_SelectionLength)] + HRESULT SelectionLength( [out, retval]long* SelectionLength ); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechRecoResult +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechRecoResult +{ + DISPID_SRRRecoContext = 1, + DISPID_SRRTimes, + DISPID_SRRAudioFormat, + DISPID_SRRPhraseInfo, + DISPID_SRRAlternates, + DISPID_SRRAudio, + DISPID_SRRSpeakAudio, + DISPID_SRRSaveToMemory, + DISPID_SRRDiscardResultInfo +} DISPID_SpeechRecoResult; + +///////////////////////////////////////////////// +// +// SpeechDiscardType Enum +// SAPI C++ Only Interface Equivalent: +// +///////////////////////////////////////////////// + +typedef enum SpeechDiscardType +{ + SDTProperty = SPDF_PROPERTY, + SDTReplacement = SPDF_REPLACEMENT, + SDTRule = SPDF_RULE, + SDTDisplayText = SPDF_DISPLAYTEXT, + SDTLexicalForm = SPDF_LEXICALFORM, + SDTPronunciation = SPDF_PRONUNCIATION, + SDTAudio = SPDF_AUDIO, + SDTAlternates = SPDF_ALTERNATES, + SDTAll = SPDF_ALL +} SpeechDiscardType; + +[ + object, + uuid(ED2879CF-CED9-4ee6-A534-DE0191D5468D), + dual, + helpstring("ISpeechRecoResult Interface"), + pointer_default(unique) +] +interface ISpeechRecoResult : IDispatch +{ + // Properties + + // RecoContext + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("RecoContext"), id(DISPID_SRRRecoContext)] + HRESULT RecoContext( [out,retval]ISpeechRecoContext** RecoContext ); + + // Times + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Times"), id(DISPID_SRRTimes)] + HRESULT Times( [out,retval]ISpeechRecoResultTimes** Times ); + + // AudioFormat + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propputref, helpstring("AudioFormat"), id(DISPID_SRRAudioFormat)] + HRESULT AudioFormat( [in]ISpeechAudioFormat* Format ); + [propget, helpstring("AudioFormat"), id(DISPID_SRRAudioFormat)] + HRESULT AudioFormat( [out,retval]ISpeechAudioFormat** Format ); + + // PhraseInfo + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("PhraseInfo"), id(DISPID_SRRPhraseInfo)] + HRESULT PhraseInfo( [out,retval]ISpeechPhraseInfo** PhraseInfo ); + + + // Methods + + // Alternates + // SAPI C++ Only Interface Equivalent: + // + [helpstring("Alternates"), id(DISPID_SRRAlternates)] + HRESULT Alternates( [in] long RequestCount, + [in, defaultvalue(0)] long StartElement, + [in, defaultvalue(SPPR_ALL_ELEMENTS)] long Elements, + [out,retval] ISpeechPhraseAlternates** Alternates ); + + // Audio + // SAPI C++ Only Interface Equivalent: + // + [helpstring("Audio"), id(DISPID_SRRAudio)] + HRESULT Audio( [in, defaultvalue(0)] long StartElement, + [in, defaultvalue(SPPR_ALL_ELEMENTS)] long Elements, + [out,retval] ISpeechMemoryStream **Stream ); + + // SpeakAudio + // SAPI C++ Only Interface Equivalent: + // + [helpstring("SpeakAudio"), id(DISPID_SRRSpeakAudio)] + HRESULT SpeakAudio( [in, defaultvalue(0)] long StartElement, + [in, defaultvalue(SPPR_ALL_ELEMENTS)] long Elements, + [in, defaultvalue(SPF_DEFAULT)] SpeechVoiceSpeakFlags Flags, + [out,retval]long* StreamNumber ); + + // SaveToMemory + // SAPI C++ Only Interface Equivalent: + // + [helpstring("SaveToMemory"), id(DISPID_SRRSaveToMemory)] + HRESULT SaveToMemory( [out,retval] VARIANT* ResultBlock ); + + // DiscardResultInfo + // SAPI C++ Only Interface Equivalent: + // + [helpstring("DiscardResultInfo"), id(DISPID_SRRDiscardResultInfo)] + HRESULT DiscardResultInfo( [in]SpeechDiscardType ValueTypes ); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechPhraseInfoBuilder +// SAPI C++ Only Interface Equivalent: +// This interface corresponds to the ISpPhraseBuilder +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechPhraseBuilder +{ + DISPID_SPPBRestorePhraseFromMemory = 1 +} DISPID_SpeechPhraseBuilder ; + +[ + object, + uuid(3B151836-DF3A-4E0A-846C-D2ADC9334333), + dual, + helpstring("ISpeechPhraseInfoBuilder Interface"), + pointer_default(unique) +] +interface ISpeechPhraseInfoBuilder : IDispatch +{ + // Methods + + // RestorePhraseFromMemory + // SAPI C++ Only Interface Equivalent: + // + [helpstring("RestorePhraseFromMemory"), id(DISPID_SPPBRestorePhraseFromMemory)] + HRESULT RestorePhraseFromMemory([in] VARIANT* PhraseInMemory, + [out,retval] ISpeechPhraseInfo **PhraseInfo); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechRecoResultTimes +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechRecoResultTimes +{ + DISPID_SRRTStreamTime = 1, + DISPID_SRRTLength, + DISPID_SRRTTickCount, + DISPID_SRRTOffsetFromStart +} DISPID_SpeechRecoResultTimes; + +[ + object, + uuid(62B3B8FB-F6E7-41be-BDCB-056B1C29EFC0), + dual, + helpstring("ISpeechRecoResultTimes Interface"), + pointer_default(unique) +] +interface ISpeechRecoResultTimes : IDispatch +{ + // Properties + + // StreamTime + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("StreamTime"), id(DISPID_SRRTStreamTime)] + HRESULT StreamTime([out,retval]VARIANT* Time ); + + // Length + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Length"), id(DISPID_SRRTLength)] + HRESULT Length([out,retval]VARIANT* Length ); + + // TickCount + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("TickCount"), id(DISPID_SRRTTickCount)] + HRESULT TickCount([out,retval]long* TickCount ); + + // Start + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Start"), id(DISPID_SRRTOffsetFromStart)] + HRESULT OffsetFromStart([out,retval]VARIANT* OffsetFromStart ); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechPhraseAlternate +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechPhraseAlternate +{ + DISPID_SPARecoResult = 1, + DISPID_SPAStartElementInResult, + DISPID_SPANumberOfElementsInResult, + DISPID_SPAPhraseInfo, + DISPID_SPACommit +} DISPID_SpeechPhraseAlternate; + +[ + object, + uuid(27864A2A-2B9F-4cb8-92D3-0D2722FD1E73), + dual, + helpstring("ISpeechPhraseAlternate Interface"), + pointer_default(unique) +] +interface ISpeechPhraseAlternate : IDispatch +{ + // Properties + + // RecoResult + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("RecoResult"), id(DISPID_SPARecoResult)] + HRESULT RecoResult( [out,retval]ISpeechRecoResult** RecoResult ); // Was ISpPhrase, is this right? + + // StartElementInResult + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("StartElementInResult"), id(DISPID_SPAStartElementInResult)] + HRESULT StartElementInResult( [out,retval]long* StartElement ); + + // NumberOfElementsInResult + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("NumberOfElementsInResult"), id(DISPID_SPANumberOfElementsInResult)] + HRESULT NumberOfElementsInResult( [out,retval]long* NumberOfElements ); + + // PhraseInfo + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Phrase"), id(DISPID_SPAPhraseInfo)] + HRESULT PhraseInfo( [out,retval]ISpeechPhraseInfo** PhraseInfo ); + + // Methods + + // Commit + // SAPI C++ Only Interface Equivalent: + // + [helpstring("Commit"), id(DISPID_SPACommit)] + HRESULT Commit( void ); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechPhraseAlternates +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechPhraseAlternates +{ + DISPID_SPAsCount = 1, + DISPID_SPAsItem = DISPID_VALUE, + DISPID_SPAs_NewEnum = DISPID_NEWENUM +} DISPID_SpeechPhraseAlternates; + +[ + object, + uuid(B238B6D5-F276-4c3d-A6C1-2974801C3CC2), + dual, + helpstring("ISpeechPhraseAlternates Interface"), + pointer_default(unique) +] +interface ISpeechPhraseAlternates : IDispatch +{ + // Properties + + // Count + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Count"), id(DISPID_SPAsCount)] + HRESULT Count([out, retval] long* Count); + + // Methods + + // Item + // SAPI C++ Only Interface Equivalent: + // + [helpstring("Item"), id(DISPID_SPAsItem)] + HRESULT Item([in] long Index, [out, retval]ISpeechPhraseAlternate** PhraseAlternate ); + + // _NewEnum + // SAPI C++ Only Interface Equivalent: + // + [propget, helpstring("Enumerates the alternates"), restricted, id(DISPID_SPAs_NewEnum)] + HRESULT _NewEnum([out, retval] IUnknown** EnumVARIANT); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechPhraseInfo +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechPhraseInfo +{ + DISPID_SPILanguageId = 1, + DISPID_SPIGrammarId, + DISPID_SPIStartTime, + DISPID_SPIAudioStreamPosition, + DISPID_SPIAudioSizeBytes, + DISPID_SPIRetainedSizeBytes, + DISPID_SPIAudioSizeTime, + DISPID_SPIRule, + DISPID_SPIProperties, + DISPID_SPIElements, + DISPID_SPIReplacements, + DISPID_SPIEngineId, + DISPID_SPIEnginePrivateData, + DISPID_SPISaveToMemory, + DISPID_SPIGetText, + DISPID_SPIGetDisplayAttributes +} DISPID_SpeechPhraseInfo; + +[ + object, + uuid(961559CF-4E67-4662-8BF0-D93F1FCD61B3), + dual, + helpstring("ISpeechPhraseInfo Interface"), + pointer_default(unique) +] +interface ISpeechPhraseInfo : IDispatch +{ + // Properties + + // LanguageId + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("LanguageId"), id(DISPID_SPILanguageId)] + HRESULT LanguageId( [out, retval]long* LanguageId ); + + // GrammarId + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("GrammarId"), id(DISPID_SPIGrammarId)] + HRESULT GrammarId( [out, retval]VARIANT* GrammarId ); + + // StartTime + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("StartTime"), id(DISPID_SPIStartTime)] + HRESULT StartTime( [out, retval]VARIANT* StartTime ); + + // AudioStreamPosition + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("AudioStreamPosition"), id(DISPID_SPIAudioStreamPosition)] + HRESULT AudioStreamPosition( [out, retval]VARIANT* AudioStreamPosition ); + + // AudioSizeBytes + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("AudioSizeBytes"), id(DISPID_SPIAudioSizeBytes)] + HRESULT AudioSizeBytes( [out, retval]long* pAudioSizeBytes ); + + // RetainedSizeBytes + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("RetainedSizeBytes"), id(DISPID_SPIRetainedSizeBytes)] + HRESULT RetainedSizeBytes( [out, retval]long* RetainedSizeBytes ); + + // AudioSizeTime + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("AudioSizeTime"), id(DISPID_SPIAudioSizeTime)] + HRESULT AudioSizeTime( [out, retval]long* AudioSizeTime ); + + // Rule + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Rule"), id(DISPID_SPIRule)] + HRESULT Rule( [out, retval]ISpeechPhraseRule** Rule ); + + // Properties + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Properties"), id(DISPID_SPIProperties)] + HRESULT Properties( [out, retval]ISpeechPhraseProperties** Properties ); + + // Elements + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Elements"), id(DISPID_SPIElements)] + HRESULT Elements( [out, retval]ISpeechPhraseElements** Elements ); + + // Replacements + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Replacements"), id(DISPID_SPIReplacements)] + HRESULT Replacements( [out, retval]ISpeechPhraseReplacements** Replacements ); + + // EngineId + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("EngineId"), id(DISPID_SPIEngineId)] + HRESULT EngineId( [out, retval]BSTR* EngineIdGuid ); + + // EnginePrivateData + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("EnginePrivateData"), id(DISPID_SPIEnginePrivateData)] + HRESULT EnginePrivateData( [out, retval]VARIANT *PrivateData ); + + // Methods + + // SaveToMemory + // SAPI C++ Only Interface Equivalent: + // + [helpstring("SaveToMemory"), id(DISPID_SPISaveToMemory)] + HRESULT SaveToMemory( [out,retval]VARIANT* PhraseBlock ); + + // GetText + // SAPI C++ Only Interface Equivalent: + // + [helpstring("GetText"), id(DISPID_SPIGetText)] + HRESULT GetText( [in, defaultvalue(0)] long StartElement, + [in, defaultvalue(SPPR_ALL_ELEMENTS)] long Elements, + [in, defaultvalue(-1)] VARIANT_BOOL UseReplacements, + [out,retval]BSTR* Text ); + + // DisplayAttributes + // SAPI C++ Only Interface Equivalent: + // + [helpstring("DisplayAttributes"), id(DISPID_SPIGetDisplayAttributes)] + HRESULT GetDisplayAttributes( [in, defaultvalue(0)] long StartElement, + [in, defaultvalue(SPPR_ALL_ELEMENTS)] long Elements, + [in, defaultvalue(-1)] VARIANT_BOOL UseReplacements, + [out,retval]SpeechDisplayAttributes* DisplayAttributes ); + +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechPhraseElement +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechPhraseElement +{ + DISPID_SPEAudioTimeOffset = 1, + DISPID_SPEAudioSizeTime, + DISPID_SPEAudioStreamOffset, + DISPID_SPEAudioSizeBytes, + DISPID_SPERetainedStreamOffset, + DISPID_SPERetainedSizeBytes, + DISPID_SPEDisplayText, + DISPID_SPELexicalForm, + DISPID_SPEPronunciation, + DISPID_SPEDisplayAttributes, + DISPID_SPERequiredConfidence, + DISPID_SPEActualConfidence, + DISPID_SPEEngineConfidence +} DISPID_SpeechPhraseElement; + +///////////////////////////////////////////////// +// +// SpeechEngineConfidence Enum +// SAPI C++ Only Interface Equivalent: +// +///////////////////////////////////////////////// + +typedef enum SpeechEngineConfidence +{ + SECLowConfidence = -1, + SECNormalConfidence = 0, + SECHighConfidence = 1 +} SpeechEngineConfidence; + +[ + object, + uuid(E6176F96-E373-4801-B223-3B62C068C0B4), + dual, + helpstring("ISpeechPhraseElement Interface"), + pointer_default(unique) +] +interface ISpeechPhraseElement : IDispatch +{ + // Properties + + // AudioTimeOffset + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("AudioTimeOffset"), id(DISPID_SPEAudioTimeOffset)] + HRESULT AudioTimeOffset( [out, retval]long* AudioTimeOffset ); + + // AudioSizeTime + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("AudioSizeTime"), id(DISPID_SPEAudioSizeTime)] + HRESULT AudioSizeTime( [out, retval]long* AudioSizeTime ); + + // AudioStreamOffset + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("AudioStreamOffset"), id(DISPID_SPEAudioStreamOffset)] + HRESULT AudioStreamOffset( [out, retval]long* AudioStreamOffset ); + + // AudioSizeBytes + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("AudioSizeBytes"), id(DISPID_SPEAudioSizeBytes)] + HRESULT AudioSizeBytes( [out, retval]long* AudioSizeBytes ); + + // RetainedStreamOffset + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("RetainedStreamOffset"), id(DISPID_SPERetainedStreamOffset)] + HRESULT RetainedStreamOffset( [out, retval]long* RetainedStreamOffset ); + + // RetainedSizeBytes + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("RetainedSizeBytes"), id(DISPID_SPERetainedSizeBytes)] + HRESULT RetainedSizeBytes( [out, retval]long* RetainedSizeBytes ); + + // DisplayText + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("DisplayText"), id(DISPID_SPEDisplayText)] + HRESULT DisplayText( [out, retval]BSTR* DisplayText ); + + // LexicalForm + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("LexicalForm"), id(DISPID_SPELexicalForm)] + HRESULT LexicalForm( [out, retval]BSTR* LexicalForm ); + + // Pronunciation + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Pronunciation"), id(DISPID_SPEPronunciation)] + HRESULT Pronunciation( [out, retval]VARIANT* Pronunciation ); + + // DisplayAttributes + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("DisplayAttributes"), id(DISPID_SPEDisplayAttributes)] + HRESULT DisplayAttributes( [out, retval]SpeechDisplayAttributes* DisplayAttributes ); + + // RequiredConfidence + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("RequiredConfidence"), id(DISPID_SPERequiredConfidence)] + HRESULT RequiredConfidence( [out, retval]SpeechEngineConfidence* RequiredConfidence ); + + // ActualConfidence + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("ActualConfidence"), id(DISPID_SPEActualConfidence)] + HRESULT ActualConfidence( [out, retval]SpeechEngineConfidence* ActualConfidence ); + + // EngineConfidence + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("EngineConfidence"), id(DISPID_SPEEngineConfidence)] + HRESULT EngineConfidence( [out, retval]float* EngineConfidence ); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechPhraseElements +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechPhraseElements +{ + DISPID_SPEsCount = 1, + DISPID_SPEsItem = DISPID_VALUE, + DISPID_SPEs_NewEnum = DISPID_NEWENUM +} DISPID_SpeechPhraseElements; + +[ + object, + uuid(0626B328-3478-467d-A0B3-D0853B93DDA3), + dual, + helpstring("ISpeechPhraseElements Interface"), + pointer_default(unique) +] +interface ISpeechPhraseElements : IDispatch +{ + // Properties + + // Count + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Count"), id(DISPID_SPEsCount)] + HRESULT Count([out, retval] long* Count); + + // Methods + + // Item + // SAPI C++ Only Interface Equivalent: + // + [helpstring("Item"), id(DISPID_SPEsItem)] + HRESULT Item([in] long Index, [out, retval]ISpeechPhraseElement** Element ); + + // _NewEnum + // SAPI C++ Only Interface Equivalent: + // + [propget, helpstring("Enumerates the tokens"), restricted, id(DISPID_SPEs_NewEnum)] + HRESULT _NewEnum([out, retval] IUnknown** EnumVARIANT); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechPhraseReplacement +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechPhraseReplacement +{ + DISPID_SPRDisplayAttributes = 1, + DISPID_SPRText, + DISPID_SPRFirstElement, + DISPID_SPRNumberOfElements +} DISPID_SpeechPhraseReplacement; + +[ + object, + uuid(2890A410-53A7-4fb5-94EC-06D4998E3D02), + dual, + helpstring("ISpeechPhraseReplacement Interface"), + pointer_default(unique) +] +interface ISpeechPhraseReplacement : IDispatch +{ + // Proerties + + // DisplayAttributes + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("DisplayAttributes"), id(DISPID_SPRDisplayAttributes)] + HRESULT DisplayAttributes( [out,retval]SpeechDisplayAttributes* DisplayAttributes ); + + // Text + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Text"), id(DISPID_SPRText)] + HRESULT Text( [out, retval]BSTR* Text ); + + // FirstElement + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("FirstElement"), id(DISPID_SPRFirstElement)] + HRESULT FirstElement( [out, retval]long* FirstElement ); + + // NumberOfElements + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("NumElements"), id(DISPID_SPRNumberOfElements)] + HRESULT NumberOfElements( [out, retval]long* NumberOfElements ); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechPhraseReplacements +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechPhraseReplacements +{ + DISPID_SPRsCount = 1, + DISPID_SPRsItem = DISPID_VALUE, + DISPID_SPRs_NewEnum = DISPID_NEWENUM +} DISPID_SpeechPhraseReplacements; + +[ + object, + uuid(38BC662F-2257-4525-959E-2069D2596C05), + dual, + helpstring("ISpeechPhraseReplacements Interface"), + pointer_default(unique) +] +interface ISpeechPhraseReplacements : IDispatch +{ + // Properties + + // Count + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Count"), id(DISPID_SPRsCount)] + HRESULT Count([out, retval] long* Count); + + // Methods + + // Item + // SAPI C++ Only Interface Equivalent: + // + [helpstring("Item"), id(DISPID_SPRsItem)] + HRESULT Item([in] long Index, [out, retval]ISpeechPhraseReplacement** Reps ); + + // _NewEnum + // SAPI C++ Only Interface Equivalent: + // + [propget, helpstring("Enumerates the tokens"), restricted, id(DISPID_SPRs_NewEnum)] + HRESULT _NewEnum([out, retval] IUnknown** EnumVARIANT); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechPhraseProperty +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechPhraseProperty +{ + DISPID_SPPName = 1, + DISPID_SPPId, + DISPID_SPPValue, + DISPID_SPPFirstElement, + DISPID_SPPNumberOfElements, + DISPID_SPPEngineConfidence, + DISPID_SPPConfidence, + DISPID_SPPParent, + DISPID_SPPChildren +} DISPID_SpeechPhraseProperty; + +[ + object, + uuid(CE563D48-961E-4732-A2E1-378A42B430BE), + dual, + helpstring("ISpeechPhraseProperty Interface"), + pointer_default(unique) +] +interface ISpeechPhraseProperty : IDispatch +{ + // Properties + + // Name + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Name"), id(DISPID_SPPName)] + HRESULT Name( [out, retval]BSTR* Name ); + + // Id + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Id"), id(DISPID_SPPId)] + HRESULT Id( [out, retval]long* Id ); + + // Value + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Value"), id(DISPID_SPPValue)] + HRESULT Value( [out, retval]VARIANT* Value ); + + // FirstElement + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("FirstElement"), id(DISPID_SPPFirstElement)] + HRESULT FirstElement( [out, retval]long* FirstElement ); + + // NumberOfElements + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("NumberOfElements"), id(DISPID_SPPNumberOfElements)] + HRESULT NumberOfElements( [out, retval]long* NumberOfElements ); + + // EngineConfidence + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("EngineConfidence"), id(DISPID_SPPEngineConfidence)] + HRESULT EngineConfidence( [out, retval]float* Confidence ); + + // Confidence + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Confidence"), id(DISPID_SPPConfidence)] + HRESULT Confidence( [out, retval]SpeechEngineConfidence* Confidence ); + + // Parent + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Parent"), id(DISPID_SPPParent)] + HRESULT Parent( [out, retval]ISpeechPhraseProperty** ParentProperty ); + + // Children + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Children"), id(DISPID_SPPChildren)] + HRESULT Children( [out, retval]ISpeechPhraseProperties** Children ); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechPhraseProperties +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechPhraseProperties +{ + DISPID_SPPsCount = 1, + DISPID_SPPsItem = DISPID_VALUE, + DISPID_SPPs_NewEnum = DISPID_NEWENUM +} DISPID_SpeechPhraseProperties; + +[ + object, + uuid(08166B47-102E-4b23-A599-BDB98DBFD1F4), + dual, + helpstring("ISpeechPhraseProperties Interface"), + pointer_default(unique) +] +interface ISpeechPhraseProperties : IDispatch +{ + // Properties + + // Count + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Count"), id(DISPID_SPPsCount)] + HRESULT Count([out, retval] long* Count); + + // Methods + + // Item + // SAPI C++ Only Interface Equivalent: + // + [helpstring("Item"), id(DISPID_SPPsItem)] + HRESULT Item([in] long Index, [out, retval]ISpeechPhraseProperty** Property ); + + // _NewEnum + // SAPI C++ Only Interface Equivalent: + // + [propget, helpstring("Enumerates the alternates"), restricted, id(DISPID_SPPs_NewEnum)] + HRESULT _NewEnum([out, retval] IUnknown** EnumVARIANT); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechPhraseRule +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechPhraseRule +{ + DISPID_SPRuleName = 1, + DISPID_SPRuleId, + DISPID_SPRuleFirstElement, + DISPID_SPRuleNumberOfElements, + DISPID_SPRuleParent, + DISPID_SPRuleChildren, + DISPID_SPRuleConfidence, + DISPID_SPRuleEngineConfidence +} DISPID_SpeechPhraseRule; + +[ + object, + uuid(A7BFE112-A4A0-48d9-B602-C313843F6964), + dual, + helpstring("ISpeechPhraseRule Interface"), + pointer_default(unique) +] +interface ISpeechPhraseRule : IDispatch +{ + // Properties + + // Name + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Name"), id(DISPID_SPRuleName)] + HRESULT Name( [out, retval]BSTR* Name ); + + // Id + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Id"), id(DISPID_SPRuleId)] + HRESULT Id( [out, retval]long* Id ); + + // FirstElement + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("FirstElement"), id(DISPID_SPRuleFirstElement)] + HRESULT FirstElement( [out, retval]long* FirstElement ); + + // NumElements + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("NumElements"), id(DISPID_SPRuleNumberOfElements)] + HRESULT NumberOfElements( [out, retval]long* NumberOfElements ); + + // Parent + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Parent"), id(DISPID_SPRuleParent)] + HRESULT Parent( [out, retval]ISpeechPhraseRule** Parent ); + + // Children + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Children"), id(DISPID_SPRuleChildren)] + HRESULT Children( [out, retval]ISpeechPhraseRules** Children ); + + // Confidence + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Confidence"), id(DISPID_SPRuleConfidence)] + HRESULT Confidence( [out, retval]SpeechEngineConfidence* ActualConfidence ); + + // EngineConfidence + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("EngineConfidence"), id(DISPID_SPRuleEngineConfidence)] + HRESULT EngineConfidence( [out, retval]float* EngineConfidence ); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechPhraseRules +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechPhraseRules +{ + DISPID_SPRulesCount = 1, + DISPID_SPRulesItem = DISPID_VALUE, + DISPID_SPRules_NewEnum = DISPID_NEWENUM +} DISPID_SpeechPhraseRules; + +[ + object, + uuid(9047D593-01DD-4b72-81A3-E4A0CA69F407), + dual, + helpstring("ISpeechPhraseRules Interface"), + pointer_default(unique) +] +interface ISpeechPhraseRules : IDispatch +{ + // Properties + + // Count + // SAPI C++ Only Interface Equivalent: + // Default: + // + [propget, helpstring("Count"), id(DISPID_SPRulesCount)] + HRESULT Count([out, retval] long* Count); + + // Methods + + // Item + // SAPI C++ Only Interface Equivalent: + // + [helpstring("Item"), id(DISPID_SPRulesItem)] + HRESULT Item([in] long Index, [out, retval]ISpeechPhraseRule** Rule ); + + // _NewEnum + // SAPI C++ Only Interface Equivalent: + // + [propget, helpstring("Enumerates the Rules"), restricted, id(DISPID_SPRules_NewEnum)] + HRESULT _NewEnum([out, retval] IUnknown** EnumVARIANT); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechLexicon +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechLexicon +{ + DISPID_SLGenerationId = 1, + DISPID_SLGetWords, + DISPID_SLAddPronunciation, + DISPID_SLAddPronunciationByPhoneIds, + DISPID_SLRemovePronunciation, + DISPID_SLRemovePronunciationByPhoneIds, + DISPID_SLGetPronunciations, + DISPID_SLGetGenerationChange +} DISPID_SpeechLexicon; + +///////////////////////////////////////////////// +// +// SpeechLexiconType Enum +// SAPI C++ Only Interface Equivalent: +// +///////////////////////////////////////////////// + +typedef enum SpeechLexiconType { + SLTUser = eLEXTYPE_USER, + SLTApp = eLEXTYPE_APP +} SpeechLexiconType; + +///////////////////////////////////////////////// +// +// SpeechPartOfSpeech Enum +// SAPI C++ Only Interface Equivalent: +// +///////////////////////////////////////////////// + +typedef enum SpeechPartOfSpeech { +// ?? NotOverriden - what does this do + SPSNotOverriden = SPPS_NotOverriden, + SPSUnknown = SPPS_Unknown, + SPSNoun = SPPS_Noun, + SPSVerb = SPPS_Verb, + SPSModifier = SPPS_Modifier, + SPSFunction = SPPS_Function, + SPSInterjection = SPPS_Interjection +} SpeechPartOfSpeech; + +[ + object, + uuid(3DA7627A-C7AE-4b23-8708-638C50362C25), + dual, + helpstring("ISpeechLexicon Interface"), + pointer_default(unique) +] +interface ISpeechLexicon : IDispatch +{ + // Properties + + // GenerationId + // SAPI C++ Only Interface Equivalent: + // + // + [propget, helpstring("GenerationId"), id(DISPID_SLGenerationId), hidden] + HRESULT GenerationId([out,retval]long* GenerationId ); + + // Methods + + // GetWords + // SAPI C++ Only Interface Equivalent: + // + [helpstring("GetWords"), id(DISPID_SLGetWords)] + HRESULT GetWords([in, defaultvalue(eLEXTYPE_USER | eLEXTYPE_APP)]SpeechLexiconType Flags, + [out, defaultvalue(NULL)]long* GenerationID, + [out,retval]ISpeechLexiconWords** Words ); + + + // AddPronunciation + // SAPI C++ Only Interface Equivalent: + // + [helpstring("AddPronunciation"), id(DISPID_SLAddPronunciation)] + HRESULT AddPronunciation([in]BSTR bstrWord, + [in]SpeechLanguageId LangId, + [in, defaultvalue(SPSUnknown)]SpeechPartOfSpeech PartOfSpeech, + [in, defaultvalue("")]BSTR bstrPronunciation); + + + // AddPronunciationByPhoneIds + // SAPI C++ Only Interface Equivalent: + // + [helpstring("AddPronunciationByPhoneIds"), hidden, id(DISPID_SLAddPronunciationByPhoneIds)] + HRESULT AddPronunciationByPhoneIds([in]BSTR bstrWord, + [in]SpeechLanguageId LangId, + [in, defaultvalue(SPSUnknown)]SpeechPartOfSpeech PartOfSpeech, + [in, defaultvalue(NULL)]VARIANT* PhoneIds); + + + // RemovePronunciation + // SAPI C++ Only Interface Equivalent: + // + [helpstring("RemovePronunciation"), id(DISPID_SLRemovePronunciation)] + HRESULT RemovePronunciation([in]BSTR bstrWord, + [in]SpeechLanguageId LangId, + [in, defaultvalue(SPSUnknown)]SpeechPartOfSpeech PartOfSpeech, + [in, defaultvalue("")]BSTR bstrPronunciation); + + // RemovePronunciationByPhoneIds + // SAPI C++ Only Interface Equivalent: + // + [helpstring("RemovePronunciationByPhoneIds"), hidden, id(DISPID_SLRemovePronunciationByPhoneIds)] + HRESULT RemovePronunciationByPhoneIds([in]BSTR bstrWord, + [in]SpeechLanguageId LangId, + [in, defaultvalue(SPSUnknown)]SpeechPartOfSpeech PartOfSpeech, + [in, defaultvalue(NULL)]VARIANT* PhoneIds); + + // GetPronunciations + // SAPI C++ Only Interface Equivalent: + // + [helpstring("GetPronunciations"), id(DISPID_SLGetPronunciations)] + HRESULT GetPronunciations([in]BSTR bstrWord, + [in, defaultvalue(0)]SpeechLanguageId LangId, + [in, defaultvalue(eLEXTYPE_USER | eLEXTYPE_APP)]SpeechLexiconType TypeFlags, + [out,retval]ISpeechLexiconPronunciations** ppPronunciations ); + + // GetGenerationChange + // SAPI C++ Only Interface Equivalent: + // + [helpstring("GetGenerationChange"), id(DISPID_SLGetGenerationChange), hidden] + HRESULT GetGenerationChange([in,out]long* GenerationID, + [out,retval]ISpeechLexiconWords** ppWords); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechLexiconWords +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechLexiconWords +{ + DISPID_SLWsCount = 1, + DISPID_SLWsItem = DISPID_VALUE, + DISPID_SLWs_NewEnum = DISPID_NEWENUM +} DISPID_SpeechLexiconWords; + +[ + object, + uuid(8D199862-415E-47d5-AC4F-FAA608B424E6), + dual, + helpstring("ISpeechLexiconWords Interface"), + pointer_default(unique) +] +interface ISpeechLexiconWords : IDispatch +{ + // Properties + + // Count + // SAPI C++ Only Interface Equivalent: + // Default: N/A + // + [id(DISPID_SLWsCount), propget, helpstring("Count")] + HRESULT Count([out, retval] long* Count); + + // Methods + + // Item + // SAPI C++ Only Interface Equivalent: + // + [id(DISPID_VALUE), helpstring("Item")] + HRESULT Item([in] long Index, [out, retval]ISpeechLexiconWord** Word ); + + // _NewEnum + // SAPI C++ Only Interface Equivalent: + // + [id(DISPID_NEWENUM), propget, helpstring("Enumerates the tokens"), restricted] + HRESULT _NewEnum([out, retval] IUnknown** EnumVARIANT); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechLexiconWord +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +///////////////////////////////////////////////// +// +// SpeechWordType Enum +// SAPI C++ Only Interface Equivalent: +// +///////////////////////////////////////////////// + +typedef enum SpeechWordType +{ + SWTAdded = eWORDTYPE_ADDED, + SWTDeleted = eWORDTYPE_DELETED +} SpeechWordType; + + +typedef [hidden] enum DISPID_SpeechLexiconWord +{ + DISPID_SLWLangId = 1, + DISPID_SLWType, + DISPID_SLWWord, + DISPID_SLWPronunciations +} DISPID_SpeechLexiconWord; + +[ + object, + uuid(4E5B933C-C9BE-48ed-8842-1EE51BB1D4FF), + dual, + helpstring("ISpeechLexiconWord Interface"), + pointer_default(unique) +] +interface ISpeechLexiconWord : IDispatch +{ + // Properties + + // LangID + // SAPI C++ Only Interface Equivalent: + // + // + [id(DISPID_SLWLangId), propget] + HRESULT LangId([out,retval]SpeechLanguageId* LangId); + + // Type + // SAPI C++ Only Interface Equivalent: + // + // + [id(DISPID_SLWType), propget] + HRESULT Type([out,retval]SpeechWordType* WordType); + + // Word + // SAPI C++ Only Interface Equivalent: + // + // + [id(DISPID_SLWWord), propget] + HRESULT Word([out,retval]BSTR* Word); + + // Pronounciations + // SAPI C++ Only Interface Equivalent: + // + // + [id(DISPID_SLWPronunciations), propget] + HRESULT Pronunciations([out,retval]ISpeechLexiconPronunciations** Pronunciations); +}; + + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechLexiconPronunciations +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechLexiconProns +{ + DISPID_SLPsCount = 1, + DISPID_SLPsItem = DISPID_VALUE, + DISPID_SLPs_NewEnum = DISPID_NEWENUM +} DISPID_SpeechLexiconProns; + +[ + object, + uuid(72829128-5682-4704-A0D4-3E2BB6F2EAD3), + dual, + helpstring("ISpeechLexiconPronunciations Interface"), + pointer_default(unique) +] +interface ISpeechLexiconPronunciations : IDispatch +{ + // Count + // SAPI C++ Only Interface Equivalent: + // + // + [id(DISPID_SLPsCount), propget, helpstring("Count")] + HRESULT Count([out, retval] long* Count); + + // Item + // SAPI C++ Only Interface Equivalent: + // + [id(DISPID_VALUE), helpstring("Item")] + HRESULT Item([in] long Index, [out, retval]ISpeechLexiconPronunciation** Pronunciation ); + + // _NewEnum + // + // + [id(DISPID_NEWENUM), propget, helpstring("Enumerates the tokens"), restricted] + HRESULT _NewEnum([out, retval] IUnknown** EnumVARIANT); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechLexiconPronunciation +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechLexiconPronunciation +{ + DISPID_SLPType = 1, + DISPID_SLPLangId, + DISPID_SLPPartOfSpeech, + DISPID_SLPPhoneIds, + DISPID_SLPSymbolic, +} DISPID_SpeechLexiconPronunciation; + +[ + object, + uuid(95252C5D-9E43-4f4a-9899-48EE73352F9F), + dual, + helpstring("ISpeechLexiconPronunciation Interface"), + pointer_default(unique) +] +interface ISpeechLexiconPronunciation : IDispatch +{ + // Type + // SAPI C++ Only Interface Equivalent: + // + // + [id(DISPID_SLPType), propget, helpstring("Type")] + HRESULT Type([out, retval]SpeechLexiconType* LexiconType); + + // LangID + // SAPI C++ Only Interface Equivalent: + // + // + [id(DISPID_SLPLangId), propget, helpstring("LangId")] + HRESULT LangId([out, retval]SpeechLanguageId* LangId); + + // PartOfSpeech + // SAPI C++ Only Interface Equivalent: + // + // + [id(DISPID_SLPPartOfSpeech), propget, helpstring("PartOfSpeech")] + HRESULT PartOfSpeech([out, retval]SpeechPartOfSpeech* PartOfSpeech); + + // PhoneIds + // SAPI C++ Only Interface Equivalent: + // Zero terminated string of phoneids + // + [id(DISPID_SLPPhoneIds), propget, helpstring("PhoneIds")] + HRESULT PhoneIds([out, retval]VARIANT* PhoneIds); + + // Symbolic + // SAPI C++ Only Interface Equivalent: + // Zero terminated string of phones + // + [id(DISPID_SLPSymbolic), propget, helpstring("Symbolic")] + HRESULT Symbolic([out, retval]BSTR* Symbolic); +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// ISpeechPhoneConverter +// SAPI C++ Only Interface Equivalent: +// Default Property: N/A +// +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef [hidden] enum DISPID_SpeechPhoneConverter +{ + DISPID_SPCLangId = 1, + DISPID_SPCPhoneToId, + DISPID_SPCIdToPhone +} DISPID_SpeechPhoneConverter; + +[ + object, + uuid(C3E4F353-433F-43d6-89A1-6A62A7054C3D), + dual, + helpstring("ISpeechPhoneConverter Interface"), + pointer_default(unique) +] +interface ISpeechPhoneConverter : IDispatch +{ + // Methods + + // LanguageId + // SAPI C++ Only Interface Equivalent: + // This can only be set once, if tried it fails + // + [propget, helpstring("LanguageId"), id(DISPID_SPCLangId)] + HRESULT LanguageId([out,retval]SpeechLanguageId* LanguageId); + [propput, helpstring("LanguageId"), id(DISPID_SPCLangId)] + HRESULT LanguageId([in]SpeechLanguageId LanguageId); + + // PhoneToId + // SAPI C++ Only Interface Equivalent: + // + [id(DISPID_SPCPhoneToId), helpstring("PhoneToId")] + HRESULT PhoneToId([in]const BSTR Phonemes, + [out,retval]VARIANT* IdArray); + + // IdToPhone + // SAPI C++ Only Interface Equivalent: + // + [id(DISPID_SPCIdToPhone), helpstring("IdToPhone")] + HRESULT IdToPhone([in]const VARIANT IdArray, + [out,retval]BSTR* Phonemes); +} diff --git a/speech2/third_party/sapi5/idl/sapiddk.idl b/speech2/third_party/sapi5/idl/sapiddk.idl new file mode 100644 index 0000000..280b010 --- /dev/null +++ b/speech2/third_party/sapi5/idl/sapiddk.idl @@ -0,0 +1,818 @@ +/**************************************************************************** +* sapiddk.idl +* +* This is the interface definition file for the Microsoft Speech API DLL's +* Version 5.0. +* +* It contains definitions for the DDI layer between SAPI.DLL and both +* TTS and SR engines. +* +* Copyright (c) Microsoft Corporation. All rights reserved. +*****************************************************************************/ + +//--- Includes -------------------------------------------------------------- +import "oaidl.idl"; +import "ocidl.idl"; +import "sapi.idl"; + +//--- Locally scoped define for LANGID +#ifndef LANGID +#define LANGID WORD +#endif + + +//--- ITN Processor +interface ISpITNProcessor; + +//--- Grammar compiler and dynamic manipulation +interface ISpErrorLog; +interface ISpGrammarCompiler; +interface ISpGramCompBackend; + +//--- Phrase builder +interface ISpPhraseBuilder; + +//--- Token String Key Names +cpp_quote("#define SPRECOEXTENSION L\"RecoExtension\"") +cpp_quote("#define SPALTERNATESCLSID L\"AlternatesCLSID\"") + +//--- ISpTokenUI ----------------------------------------------------------- +[ + object, + uuid(F8E690F0-39CB-4843-B8D7-C84696E1119D), + helpstring("ISpTokenUI Interface"), + pointer_default(unique), + restricted +] +interface ISpTokenUI : IUnknown +{ + [local] HRESULT IsUISupported( + [in] const WCHAR * pszTypeOfUI, + [in] void * pvExtraData, + [in] ULONG cbExtraData, + [in] IUnknown * punkObject, + [out] BOOL *pfSupported); + [local] HRESULT DisplayUI( + [in] HWND hwndParent, + [in] const WCHAR * pszTitle, + [in] const WCHAR * pszTypeOfUI, + [in] void * pvExtraData, + [in] ULONG cbExtraData, + [in] ISpObjectToken * pToken, + [in] IUnknown * punkObject); +}; + +//--- ISpObjectTokenEnumBuilder --------------------------------------------- +[ + object, + uuid(06B64F9F-7FDA-11d2-B4F2-00C04F797396), + helpstring("ISpObjectTokensEnumBuilder Interface"), + pointer_default(unique), + restricted +] +interface ISpObjectTokenEnumBuilder : IEnumSpObjectTokens +{ + HRESULT SetAttribs(const WCHAR * pszReqAttribs, const WCHAR * pszOptAttribs); + + HRESULT AddTokens(ULONG cTokens, ISpObjectToken ** pToken); + HRESULT AddTokensFromDataKey(ISpDataKey * pDataKey, const WCHAR * pszSubKey, const WCHAR * pszCategoryId); + HRESULT AddTokensFromTokenEnum(IEnumSpObjectTokens * pTokenEnum); + + HRESULT Sort(const WCHAR * pszTokenIdToListFirst); +}; + +//--- Handles for SR grammars and results +cpp_quote("#if 0") +typedef void * SPWORDHANDLE; +typedef void * SPRULEHANDLE; +typedef void * SPGRAMMARHANDLE; +typedef void * SPRECOCONTEXTHANDLE; +typedef void * SPPHRASERULEHANDLE; +typedef void * SPPHRASEPROPERTYHANDLE; +typedef void * SPTRANSITIONID; +cpp_quote("#else") +cpp_quote("DECLARE_HANDLE(SPWORDHANDLE);") +cpp_quote("DECLARE_HANDLE(SPRULEHANDLE);") +cpp_quote("DECLARE_HANDLE(SPGRAMMARHANDLE);") +cpp_quote("DECLARE_HANDLE(SPRECOCONTEXTHANDLE);") +cpp_quote("DECLARE_HANDLE(SPPHRASERULEHANDLE);") +cpp_quote("DECLARE_HANDLE(SPPHRASEPROPERTYHANDLE);") +cpp_quote("DECLARE_HANDLE(SPTRANSITIONID);") +cpp_quote("#endif") + + +//--- ISpErrorLog ----------------------------------------------------------- +// This interface is used to log error information. + +[ + object, + uuid(F4711347-E608-11d2-A086-00C04F8EF9B5), + helpstring("ISpErrorLog Interface"), + pointer_default(unique), + restricted +] +interface ISpErrorLog : IUnknown +{ + HRESULT AddError( + const long lLineNumber, + HRESULT hr, + const WCHAR * pszDescription, + const WCHAR * pszHelpFile, + DWORD dwHelpContext); +}; + +//--- ISpGrammarCompiler ---------------------------------------------------- + +[ + object, + uuid(B1E29D58-A675-11D2-8302-00C04F8EE6C0), + helpstring("ISpGrammarCompiler Interface"), + pointer_default(unique), + restricted +] +interface ISpGrammarCompiler : IUnknown +{ + HRESULT CompileStream( + IStream * pSource, + IStream * pDest, + IStream * pHeader, + IUnknown * pReserved, + ISpErrorLog * pErrorLog, + [in] DWORD dwFlags); +}; + +[ + object, + uuid(3DDCA27C-665C-4786-9F97-8C90C3488B61), + helpstring("ISpGramCompBackend Interface"), + pointer_default(unique), + restricted +] +interface ISpGramCompBackend : ISpGrammarBuilder +{ + HRESULT SetSaveObjects(IStream * pStream, ISpErrorLog * pErrorLog); + + HRESULT InitFromBinaryGrammar(const SPBINARYGRAMMAR * pBinaryData); +}; + + +//--- ISpITNProcessor ---------------------------------------------------------- +[ + object, + uuid(12D7360F-A1C9-11d3-BC90-00C04F72DF9F), + helpstring("ISpITNProcessor Interface"), + pointer_default(unique), + local, + restricted +] +interface ISpITNProcessor : IUnknown +{ + HRESULT LoadITNGrammar(WCHAR *pszCLSID); + HRESULT ITNPhrase(ISpPhraseBuilder *pPhrase); +}; + + +[ + object, + uuid(88A3342A-0BED-4834-922B-88D43173162F), + local, + helpstring("ISpPhraseBuilder Interface"), + pointer_default(unique), + restricted +] +interface ISpPhraseBuilder : ISpPhrase +{ + HRESULT InitFromPhrase(const SPPHRASE * pPhrase); + HRESULT InitFromSerializedPhrase(const SPSERIALIZEDPHRASE * pPhrase); + HRESULT AddElements(ULONG cElements, const SPPHRASEELEMENT *pElement); + HRESULT AddRules(const SPPHRASERULEHANDLE hParent, const SPPHRASERULE * pRule, SPPHRASERULEHANDLE * phNewRule); + HRESULT AddProperties(const SPPHRASEPROPERTYHANDLE hParent, const SPPHRASEPROPERTY * pProperty, SPPHRASEPROPERTYHANDLE * phNewProperty); + HRESULT AddReplacements(ULONG cReplacements, const SPPHRASEREPLACEMENT * pReplacements); +}; + + + +//--- ISpTask --------------------------------------------------------------- + +cpp_quote("#if defined(__cplusplus)") +cpp_quote("interface ISpTask") +cpp_quote("{") +cpp_quote("virtual HRESULT STDMETHODCALLTYPE Execute(") +cpp_quote(" void *pvTaskData,") +cpp_quote(" volatile const BOOL* pfContinueProcessing) = 0;") +cpp_quote("};") +cpp_quote("#else") +typedef void * ISpTask; +cpp_quote("#endif") + +//--- ISpThreadTask --------------------------------------------------------- + +cpp_quote("#if defined(__cplusplus)") +cpp_quote("interface ISpThreadTask") +cpp_quote("{") +cpp_quote("virtual HRESULT STDMETHODCALLTYPE InitThread(") +cpp_quote(" void * pvTaskData,") +cpp_quote(" HWND hwnd) = 0;") +cpp_quote("virtual HRESULT STDMETHODCALLTYPE ThreadProc(") +cpp_quote(" void *pvTaskData,") +cpp_quote(" HANDLE hExitThreadEvent,") +cpp_quote(" HANDLE hNotifyEvent,") +cpp_quote(" HWND hwndWorker,") +cpp_quote(" volatile const BOOL * pfContinueProcessing) = 0;") +cpp_quote("virtual LRESULT STDMETHODCALLTYPE WindowMessage(") +cpp_quote(" void *pvTaskData,") +cpp_quote(" HWND hWnd,") +cpp_quote(" UINT Msg,") +cpp_quote(" WPARAM wParam,") +cpp_quote(" LPARAM lParam) = 0;") +cpp_quote("};") +cpp_quote("#else") +typedef void * ISpThreadTask; +cpp_quote("#endif") + +//--- ISpThreadControl ------------------------------------------------------ +[ + object, + uuid(A6BE4D73-4403-4358-B22D-0346E23B1764), + helpstring("ISpThreadControl Interface"), + pointer_default(unique), + local, + restricted +] +interface ISpThreadControl : ISpNotifySink +{ + HRESULT StartThread(DWORD dwFlags, HWND * phwnd); + HRESULT WaitForThreadDone( + BOOL fForceStop, + HRESULT * phrThreadResult, + ULONG msTimeOut); + HRESULT TerminateThread(void); + HANDLE ThreadHandle(void); + DWORD ThreadId(void); + HANDLE NotifyEvent(void); + HWND WindowHandle(void); + HANDLE ThreadCompleteEvent(void); + HANDLE ExitThreadEvent(void); +}; + +//--- ISpTaskManager -------------------------------------------------------- +// This interface is used to implement a task managment service provider +// to optimize thread usage. + +typedef [restricted] struct SPTMTHREADINFO +{ + long lPoolSize; // Number of threads in pool (-1 default) + long lPriority; // Priority of threads in pool + ULONG ulConcurrencyLimit; // Number of threads allowed to concurrently execute (0 default) + ULONG ulMaxQuickAllocThreads; // Maximum number of dedicated threads retained +} SPTMTHREADINFO; + +[ + local, + uuid(2BAEEF81-2CA3-4331-98F3-26EC5ABEFB03), + helpstring("ISpTaskManager Interface"), + pointer_default(unique), + restricted +] +interface ISpTaskManager : IUnknown +{ + HRESULT SetThreadPoolInfo([in] const SPTMTHREADINFO* pPoolInfo); + HRESULT GetThreadPoolInfo([out] SPTMTHREADINFO* pPoolInfo); + + HRESULT QueueTask( + [in] ISpTask* pTask, + [in] void* pvTaskData, + [in] HANDLE hCompEvent, + [in, out] DWORD* pdwGroupId, + [out] DWORD* pTaskID); + HRESULT CreateReoccurringTask( + [in] ISpTask* pTask, + [in] void* pvTaskData, + [in] HANDLE hCompEvent, + [out] ISpNotifySink** ppTaskCtrl); + HRESULT CreateThreadControl( + [in] ISpThreadTask* pTask, + [in] void* pvTaskData, + [in] long nPriority, + [out] ISpThreadControl** ppTaskCtrl); + + HRESULT TerminateTask([in] DWORD dwTaskId, [in] ULONG ulWaitPeriod); + HRESULT TerminateTaskGroup([in] DWORD dwGroupId, [in] ULONG ulWaitPeriod); +}; + + +//--- ISpTTSEngineSite ------------------------------------------------------ + +typedef enum SPVSKIPTYPE +{ + SPVST_SENTENCE = (1L << 0) // Skip sentences +} SPVSKIPTYPE; + +typedef enum SPVESACTIONS +{ + SPVES_CONTINUE = 0, + SPVES_ABORT = ( 1L << 0 ), + SPVES_SKIP = ( 1L << 1 ), + SPVES_RATE = ( 1L << 2 ), + SPVES_VOLUME = ( 1L << 3 ) +} SPVESACTIONS; + +[ + object, + local, + uuid(9880499B-CCE9-11d2-B503-00C04F797396), + helpstring("ISpTTSEngineSite Interface"), + pointer_default(unique) +] +interface ISpTTSEngineSite : ISpEventSink +{ + DWORD GetActions( void ); + HRESULT Write( [in]const void* pBuff, [in]ULONG cb, [out]ULONG *pcbWritten ); + HRESULT GetRate( [out]long* pRateAdjust ); + HRESULT GetVolume( [out]USHORT* pusVolume ); + HRESULT GetSkipInfo( [out]SPVSKIPTYPE* peType, [out]long* plNumItems ); + HRESULT CompleteSkip( [in]long ulNumSkipped ); +}; + +//--- ISpTTSEngine ---------------------------------------------------------- + +typedef struct SPVTEXTFRAG +{ + struct SPVTEXTFRAG* pNext; // Next text fragment in list, NULL == end of list + SPVSTATE State; // Current XML attribute state + LPCWSTR pTextStart; + ULONG ulTextLen; + ULONG ulTextSrcOffset; // Original source position of the fragment text +} SPVTEXTFRAG; + +[ + object, + local, + uuid(A74D7C8E-4CC5-4f2f-A6EB-804DEE18500E), + helpstring("ISpTTSEngine Interface"), + pointer_default(unique) +] +interface ISpTTSEngine : IUnknown +{ + HRESULT Speak( [in]DWORD dwSpeakFlags, + [in]REFGUID rguidFormatId, [in]const WAVEFORMATEX * pWaveFormatEx, + [in]const SPVTEXTFRAG* pTextFragList, [in]ISpTTSEngineSite* pOutputSite ); + HRESULT GetOutputFormat( [in] const GUID * pTargetFmtId, [in] const WAVEFORMATEX * pTargetWaveFormatEx, + [out] GUID * pOutputFormatId, [out] WAVEFORMATEX ** ppCoMemOutputWaveFormatEx); +}; + + + +//--- SR Engine data structures ---------------------------------------- + + +typedef [restricted] struct SPWORDENTRY +{ + SPWORDHANDLE hWord; + LANGID LangID; + WCHAR * pszDisplayText; + WCHAR * pszLexicalForm; + SPPHONEID * aPhoneId; + void * pvClientContext; +} SPWORDENTRY; + +typedef [restricted] struct SPRULEENTRY +{ + SPRULEHANDLE hRule; + SPSTATEHANDLE hInitialState; + DWORD Attributes; // SPCFGRULEATTRIBUTES + void * pvClientRuleContext; + void * pvClientGrammarContext; +} SPRULEENTRY; + +typedef enum SPTRANSITIONTYPE +{ + SPTRANSEPSILON, + SPTRANSWORD, + SPTRANSRULE, + SPTRANSTEXTBUF, + SPTRANSWILDCARD, + SPTRANSDICTATION +} SPTRANSITIONTYPE; + +typedef [restricted] struct SPTRANSITIONENTRY +{ + SPTRANSITIONID ID; + SPSTATEHANDLE hNextState; + BYTE Type; // SPTRANSITIONTYPE + char RequiredConfidence; + struct + { + DWORD fHasProperty; // Boolean type + }; + float Weight; + union + { + struct + { + SPSTATEHANDLE hRuleInitialState; // Only if Type == SPTRANSRULE + SPRULEHANDLE hRule; + void * pvClientRuleContext; + }; + struct + { + SPWORDHANDLE hWord; // Only if Type == SPTRANSWORD + void * pvClientWordContext; + }; + struct + { + void * pvGrammarCookie; // Only if Type == SPTRANSTEXTBUF or SPTRANSWILDCARD or SPTRANSDICTATION + }; + }; +} SPTRANSITIONENTRY; + +typedef [restricted] struct SPTRANSITIONPROPERTY +{ + const WCHAR * pszName; + ULONG ulId; + const WCHAR * pszValue; + VARIANT vValue; // Will be VT_BOOL, VT_I4, VT_R4, VT_R8, or VT_BYREF (only for dynamic grammars) +} SPTRANSITIONPROPERTY; + +typedef [restricted] struct SPSTATEINFO +{ + ULONG cAllocatedEntries; + SPTRANSITIONENTRY * pTransitions; + ULONG cEpsilons; + ULONG cRules; + ULONG cWords; + ULONG cSpecialTransitions; +} SPSTATEINFO; + +typedef [restricted] struct SPPATHENTRY +{ + SPTRANSITIONID hTransition; + SPPHRASEELEMENT elem; +} SPPATHENTRY; + + + + + +//--- ISpCFGInterpreterSite ------------------------------------------------- +[ + object, + uuid(6A6FFAD8-78B6-473d-B844-98152E4FB16B), + helpstring("ISpCFGInterpreterSite Interface"), + pointer_default(unique), + local, + restricted +] +interface ISpCFGInterpreterSite : IUnknown +{ + HRESULT AddTextReplacement([in] SPPHRASEREPLACEMENT * pReplace); + HRESULT AddProperty([in] const SPPHRASEPROPERTY *pProperty); + HRESULT GetResourceValue( + [in] const WCHAR *pszResourceName, + [out] WCHAR ** ppCoMemResource); +}; + + +//--- ISpCFGInterpreter ----------------------------------------------------- + +[ + object, + uuid(F3D3F926-11FC-11d3-BB97-00C04F8EE6C0), + helpstring("ISpCFGInterpreter Interface"), + pointer_default(unique), + local, + restricted +] +interface ISpCFGInterpreter : IUnknown +{ + HRESULT InitGrammar( + [in] const WCHAR * pszGrammarName, + [in] const void ** pvGrammarData); + HRESULT Interpret( + [in] ISpPhraseBuilder * pPhrase, + [in] const ULONG ulFirstElement, + [in] const ULONG ulCountOfElements, + [in] ISpCFGInterpreterSite * pSite); +}; + + +typedef enum SPCFGNOTIFY +{ + SPCFGN_ADD, + SPCFGN_REMOVE, + SPCFGN_INVALIDATE, + SPCFGN_ACTIVATE, + SPCFGN_DEACTIVATE +} SPCFGNOTIFY; + +//--- ISpSREngineSite ------------------------------------------------------- + +typedef enum SPRESULTTYPE +{ + SPRT_CFG = 0, + SPRT_SLM = 1, + SPRT_PROPRIETARY = 2, + SPRT_FALSE_RECOGNITION = ( 1L << 2 ) // Flag used to indicate a false recognition +} SPRESULTTYPE; + +typedef struct tagSPPHRASEALT +{ + ISpPhraseBuilder * pPhrase; + ULONG ulStartElementInParent; + ULONG cElementsInParent; + ULONG cElementsInAlternate; + void * pvAltExtra; + ULONG cbAltExtra; +} SPPHRASEALT; + +// Result structure passed from engine to SAPI +typedef struct SPRECORESULTINFO +{ + ULONG cbSize; // Total size of this structure + SPRESULTTYPE eResultType; // Type of result object (CFG, SLM, or Proprietary) + BOOL fHypothesis; // If true then this recognition is a hypothesis + BOOL fProprietaryAutoPause;// This field is only used for SPERT_PROPRIETARY grammars. If true, recognition will pause. + ULONGLONG ullStreamPosStart; // Start and end stream positions of recognition + ULONGLONG ullStreamPosEnd; + SPGRAMMARHANDLE hGrammar; // Required for SPERT_SLM and SPERT_PROPRIETARY else NULL + ULONG ulSizeEngineData; // Size of pvEngineData + void * pvEngineData; // Extra engine specific data + ISpPhraseBuilder* pPhrase; // Pointer to phrase object + SPPHRASEALT* aPhraseAlts; // Alternates array + ULONG ulNumAlts; // Number of alternates in the array +} SPRECORESULTINFO; + +typedef enum SPWORDINFOOPT +{ + SPWIO_NONE = 0, + SPWIO_WANT_TEXT = 1 +} SPWORDINFOOPT; + + +typedef enum SPRULEINFOOPT +{ + SPRIO_NONE = 0, +} SPRULEINFOOPT; + +typedef struct SPPARSEINFO +{ + ULONG cbSize; + SPRULEHANDLE hRule; + ULONGLONG ullAudioStreamPosition; + ULONG ulAudioSize; + ULONG cTransitions; + SPPATHENTRY * pPath; + GUID SREngineID; + ULONG ulSREnginePrivateDataSize; + const BYTE * pSREnginePrivateData; + BOOL fHypothesis; +} SPPARSEINFO; + +[ + object, + uuid(3B414AEC-720C-4883-B9EF-178CD394FB3A), + helpstring("ISpSREngineSite Interface"), + pointer_default(unique), + local +] +interface ISpSREngineSite : IUnknown +{ + HRESULT Read([in] void * pv, [in] ULONG cb, [out] ULONG * pcbRead); + HRESULT DataAvailable(ULONG * pcb); + HRESULT SetBufferNotifySize([in] ULONG cbSize); + HRESULT ParseFromTransitions([in] const SPPARSEINFO * pParseInfo, + [out] ISpPhraseBuilder ** ppNewPhrase); + HRESULT Recognition([in] const SPRECORESULTINFO * pResultInfo); + HRESULT AddEvent([in] const SPEVENT* pEvent, [in] SPRECOCONTEXTHANDLE hSAPIRecoContext); + HRESULT Synchronize([in] ULONGLONG ullProcessedThruPos); + HRESULT GetWordInfo([in, out] SPWORDENTRY * pWordEntry, [in] SPWORDINFOOPT Options); // Caller must fill in hWord. if fWantWordText then caller must CoTaskMemFree the pszWord. + HRESULT SetWordClientContext(SPWORDHANDLE hWord, void * pvClientContext); + HRESULT GetRuleInfo([in, out] SPRULEENTRY * pRuleEntry, [in] SPRULEINFOOPT Options); // Caller must fill in hRule.SPRULEHANDLE hRule, BOOL * pfActive, BOOL *pfAutoPause, SPSTATEHANDLE * phInitialState, void ** ppvClientContext); + HRESULT SetRuleClientContext(SPRULEHANDLE hRule, void * pvClientContext); + HRESULT GetStateInfo(SPSTATEHANDLE hState, SPSTATEINFO * pStateInfo); + HRESULT GetResource( [in] SPRULEHANDLE hRule, [in] const WCHAR *pszResourceName, [out] WCHAR ** ppCoMemResource ); + HRESULT GetTransitionProperty([in] SPTRANSITIONID ID, [out] SPTRANSITIONPROPERTY **ppCoMemProperty); + HRESULT IsAlternate( [in]SPRULEHANDLE hRule, [in]SPRULEHANDLE hAltRule ); + HRESULT GetMaxAlternates( [in]SPRULEHANDLE hRule, [out]ULONG* pulNumAlts ); + HRESULT GetContextMaxAlternates( [in] SPRECOCONTEXTHANDLE hContext, [out] ULONG * pulNumAlts); + HRESULT UpdateRecoPos([in] ULONGLONG ullCurrentRecoPos); +}; + +//--- ISpSREngine ----------------------------------------------------------- +typedef enum SPPROPSRC +{ + SPPROPSRC_RECO_INST, + SPPROPSRC_RECO_CTX, + SPPROPSRC_RECO_GRAMMAR +} SPPROPSRC; + +[ + object, + uuid(2F472991-854B-4465-B613-FBAFB3AD8ED8), + helpstring("ISpSREngine Interface"), + pointer_default(unique), + local +] +interface ISpSREngine : IUnknown +{ + HRESULT SetSite([in] ISpSREngineSite *pSite); + + HRESULT GetInputAudioFormat( + [in] const GUID * pguidSourceFormatId, + [in] const WAVEFORMATEX * pSourceWaveFormatEx, + [out] GUID * pguidDesiredFormatId, + [out] WAVEFORMATEX ** ppCoMemDesiredWaveFormatEx); + + HRESULT RecognizeStream([in] REFGUID rguidFmtId, [in] const WAVEFORMATEX * pWaveFormatEx, + [in] HANDLE hRequestSync, [in] HANDLE hDataAvailable, + [in] HANDLE hExit, [in] BOOL fNewAudioStream, [in] BOOL fRealTimeAudio, + [in] ISpObjectToken * pAudioObjectToken); + + HRESULT SetRecoProfile(ISpObjectToken * pProfile); + + HRESULT OnCreateGrammar([in] void * pvEngineRecoContext, + [in] SPGRAMMARHANDLE hSAPIGrammar, + [out] void ** ppvEngineGrammarContext); + + HRESULT OnDeleteGrammar([in] void * pvEngineGrammar); + + HRESULT LoadProprietaryGrammar( + [in] void * pvEngineGrammar, + [in] REFGUID rguidParam, + [in, string] const WCHAR * pszStringParam, + [in] const void * pvDataParam, + [in] ULONG ulDataSize, + [in] SPLOADOPTIONS Options); // Note for SAPI 5.0 this is always SPLO_NONE + + HRESULT UnloadProprietaryGrammar([in] void * pvEngineGrammar); + + HRESULT SetProprietaryRuleState([in] void * pvEngineGrammar, + [in, string] const WCHAR * pszName, + [in] void * pReserved, + [in] SPRULESTATE NewState, + [out] ULONG * pcRulesChanged); + HRESULT SetProprietaryRuleIdState([in] void * pvEngineGrammar, + [in] DWORD dwRuleId, + [in] SPRULESTATE NewState); + HRESULT LoadSLM([in] void * pvEngineGrammar, [in, string] const WCHAR * pszTopicName); + HRESULT UnloadSLM([in] void * pvEngineGrammar); + HRESULT SetSLMState([in] void * pvEngineGrammar, [in] SPRULESTATE NewState); + HRESULT SetWordSequenceData([in] void * pvEngineGrammar, [in] const WCHAR * pText, [in] ULONG cchText, [in] const SPTEXTSELECTIONINFO * pInfo); + HRESULT SetTextSelection([in] void * pvEngineGrammar, [in] const SPTEXTSELECTIONINFO * pInfo); + HRESULT IsPronounceable([in] void * pvEngineGrammar, [in, string] const WCHAR * pszWord, [out] SPWORDPRONOUNCEABLE *pWordPronounceable); + + HRESULT OnCreateRecoContext( + [in] SPRECOCONTEXTHANDLE hSAPIRecoContext, + [out] void ** ppvEngineContext); + HRESULT OnDeleteRecoContext([in] void * pvEngineContext); + + HRESULT PrivateCall([in] void * pvEngineContext, [in, out] PVOID pCallFrame, [in] ULONG ulCallFrameSize); + + HRESULT SetAdaptationData([in] void * pvEngineContext, const WCHAR *pAdaptationData, const ULONG cch); + + HRESULT SetPropertyNum( [in]SPPROPSRC eSrc, [in]void* pvSrcObj, + [in]const WCHAR* pName, [in]LONG lValue ); + HRESULT GetPropertyNum( [in]SPPROPSRC eSrc, [in]void* pvSrcObj, + [in]const WCHAR* pName, [out]LONG* lValue ); + HRESULT SetPropertyString( [in]SPPROPSRC eSrc, [in]void* pvSrcObj, + [in]const WCHAR* pName, [in]const WCHAR* pValue ); + HRESULT GetPropertyString( [in]SPPROPSRC eSrc, [in]void* pvSrcObj, + [in]const WCHAR* pName, [out]WCHAR** ppCoMemValue ); + + HRESULT SetGrammarState([in] void * pvEngineGrammar, [in] SPGRAMMARSTATE eGrammarState); + + HRESULT WordNotify(SPCFGNOTIFY Action, ULONG cWords, const SPWORDENTRY * pWords); + HRESULT RuleNotify(SPCFGNOTIFY Action, ULONG cRules, const SPRULEENTRY * pRules); + + HRESULT PrivateCallEx([in] void * pvEngineContext, [in] const void * pInCallFrame, [in] ULONG ulInCallFrameSize, + [out] void ** ppvCoMemResponse, [out] ULONG * pulResponseSize); + + HRESULT SetContextState([in] void * pvEngineContext, [in] SPCONTEXTSTATE eContextState); +}; + + +//--- ISpSRAlternates + +typedef struct tagSPPHRASEALTREQUEST +{ + ULONG ulStartElement; + ULONG cElements; + ULONG ulRequestAltCount; + + void * pvResultExtra; + ULONG cbResultExtra; + + ISpPhrase * pPhrase; + ISpRecoContext * pRecoContext; +} SPPHRASEALTREQUEST; + +[ + object, + uuid(FECE8294-2BE1-408f-8E68-2DE377092F0E), + helpstring("ISpSRAlternates Interface"), + pointer_default(unique), + local +] +interface ISpSRAlternates : IUnknown +{ + HRESULT GetAlternates([in] SPPHRASEALTREQUEST * pAltRequest, + [out] SPPHRASEALT **ppAlts, + [out] ULONG *pcAlts); + HRESULT Commit([in] SPPHRASEALTREQUEST * pAltRequest, + [in] SPPHRASEALT * pAlt, + [out] void **ppvResultExtra, + [out] ULONG *pcbResultExtra); +} + +// Interface used by engine specific recoctxt extension object to call into engine +[ + object, + uuid(8E7C791E-4467-11d3-9723-00C04F72DB08), + helpstring("_ISpPrivateEngineCall Interface"), + pointer_default(unique), + local +] +interface _ISpPrivateEngineCall : IUnknown +{ + HRESULT CallEngine([in, out] void * pCallFrame, [in] ULONG ulCallFrameSize); + HRESULT CallEngineEx([in] const void * pInFrame, [in] ULONG ulInFrameSize, + [out] void ** ppCoMemOutFrame, [out] ULONG * pulOutFrameSize); +} + +// +//--- CoClass definitions --------------------------------------------------- +// + +[ + helpstring("Microsoft Speech Object DDK Library"), + uuid(9903F14C-12CE-4c99-9986-2EE3D7D588A8), + version(5.0) +] +library SpeechDDKLib +{ + importlib("stdole32.tlb"); + importlib("stdole2.tlb"); + + //--- SpDataKey --------------------------------------------------------- + [ + uuid(D9F6EE60-58C9-458b-88E1-2F908FD7F87C), + helpstring("Data Key") + ] + coclass SpDataKey + { + interface ISpRegDataKey; + [default] interface ISpDataKey; + } + + //--- SpObjectTokenEnum -------------------------------------------------- + [ + uuid(3918D75F-0ACB-41f2-B733-92AA15BCECF6), + helpstring("Object Token Enumerator") + ] + coclass SpObjectTokenEnum + { + interface ISpObjectTokenEnumBuilder; + [default] interface IEnumSpObjectTokens; + } + + //--- SpPhraseBuilder --------------------------------------------------- + [ + uuid(777B6BBD-2FF2-11d3-88FE-00C04F8EF9B5), + helpstring("Phrase Builder Class") + ] + coclass SpPhraseBuilder + { + [default] interface ISpPhraseBuilder; + } + //--- SpITNProcessor ---------------------------------------------------- + [ + uuid(12D73610-A1C9-11d3-BC90-00C04F72DF9F), + helpstring("SpITNProcessor Class"), + restricted + ] + coclass SpITNProcessor + { + [default] interface ISpITNProcessor; + }; + //--- SpGrammarCompiler --------------------------------------------- + [ + uuid(B1E29D59-A675-11D2-8302-00C04F8EE6C0), + helpstring("Microsoft Speech Grammar Compiler") + ] + coclass SpGrammarCompiler + { + [default] interface ISpGrammarCompiler; + }; + + //--- SpGramCompBackend --------------------------------------------- + [ + uuid(DA93E903-C843-11D2-A084-00C04F8EF9B5), + helpstring("Grammar Class"), + restricted + ] + coclass SpGramCompBackend + { + [default] interface ISpGramCompBackend; + }; + +} diff --git a/speech2/third_party/sapi5/include/Spddkhlp.h b/speech2/third_party/sapi5/include/Spddkhlp.h new file mode 100644 index 0000000..bc4134a --- /dev/null +++ b/speech2/third_party/sapi5/include/Spddkhlp.h @@ -0,0 +1,854 @@ +/******************************************************************************* +* SPDDKHLP.h * +*------------* +* Description: +* This is the header file for core helper functions implementation. +* +* Copyright (c) Microsoft Corporation. All rights reserved. +* +*******************************************************************************/ +#ifndef SPDDKHLP_h +#define SPDDKHLP_h + +#ifndef SPHelper_h +#include +#endif + +#include + +#ifndef SPError_h +#include +#endif + +#ifndef SPDebug_h +#include +#endif + +#ifndef _INC_LIMITS +#include +#endif + +#ifndef _INC_CRTDBG +#include +#endif + +#ifndef _INC_MALLOC +#include +#endif + +#ifndef _INC_MMSYSTEM +#include +#endif + +#ifndef __comcat_h__ +#include +#endif + +//=== Constants ============================================================== +#define sp_countof(x) ((sizeof(x) / sizeof(*(x)))) + +#define SP_IS_BAD_WRITE_PTR(p) ( SPIsBadWritePtr( p, sizeof(*(p)) )) +#define SP_IS_BAD_READ_PTR(p) ( SPIsBadReadPtr( p, sizeof(*(p)) )) +#define SP_IS_BAD_CODE_PTR(p) ( ::IsBadCodePtr((FARPROC)(p) ) +#define SP_IS_BAD_INTERFACE_PTR(p) ( SPIsBadInterfacePtr( (p) ) ) +#define SP_IS_BAD_VARIANT_PTR(p) ( SPIsBadVARIANTPtr( (p) ) ) +#define SP_IS_BAD_STRING_PTR(p) ( SPIsBadStringPtr( (p) ) ) + +#define SP_IS_BAD_OPTIONAL_WRITE_PTR(p) ((p) && SPIsBadWritePtr( p, sizeof(*(p)) )) +#define SP_IS_BAD_OPTIONAL_READ_PTR(p) ((p) && SPIsBadReadPtr( p, sizeof(*(p)) )) +#define SP_IS_BAD_OPTIONAL_INTERFACE_PTR(p) ((p) && SPIsBadInterfacePtr(p)) +#define SP_IS_BAD_OPTIONAL_STRING_PTR(p) ((p) && SPIsBadStringPtr(p)) + +//=== Class, Enum, Struct, Template, and Union Declarations ================== + +//=== Inlines ================================================================ + +/*** Pointer validation functions +*/ + +// TODO: Add decent debug output for bad parameters + +inline BOOL SPIsBadStringPtr( const WCHAR * psz, ULONG cMaxChars = 0xFFFF ) +{ + BOOL IsBad = false; + __try + { + do + { + if( *psz++ == 0 ) return IsBad; + } + while( --cMaxChars ); + } + __except( GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ) + { + IsBad = true; + } + + return IsBad; +} + +inline BOOL SPIsBadReadPtr( const void* pMem, UINT Size ) +{ +#ifdef _DEBUG + BOOL bIsBad = ::IsBadReadPtr( pMem, Size ); + SPDBG_ASSERT(!bIsBad); + return bIsBad; +#else + return ::IsBadReadPtr( pMem, Size ); +#endif +} + +inline BOOL SPIsBadWritePtr( void* pMem, UINT Size ) +{ +#ifdef _DEBUG + BOOL bIsBad = ::IsBadWritePtr( pMem, Size ); + SPDBG_ASSERT(!bIsBad); + return bIsBad; +#else + return ::IsBadWritePtr( pMem, Size ); +#endif +} + +inline BOOL SPIsBadInterfacePtr( const IUnknown* pUnknown ) +{ +#ifdef _DEBUG + BOOL bIsBad = ( ::IsBadReadPtr( pUnknown, sizeof( *pUnknown ) ) || + ::IsBadCodePtr( (FARPROC)((void**)pUnknown)[0] ))? + (true):(false); + SPDBG_ASSERT(!bIsBad); + return bIsBad; +#else + return ( ::IsBadReadPtr( pUnknown, sizeof( *pUnknown ) ) || + ::IsBadCodePtr( (FARPROC)((void**)pUnknown)[0] ))? + (true):(false); +#endif +} + +inline BOOL SPIsBadVARIANTPtr( const VARIANT* pVar ) +{ +#ifdef _DEBUG + BOOL bIsBad = ::IsBadReadPtr( pVar, sizeof( *pVar ) ); + SPDBG_ASSERT(!bIsBad); + return bIsBad; +#else + return ::IsBadReadPtr( pVar, sizeof( *pVar ) ); +#endif +} + +#ifdef __ATLCOM_H__ //--- Only enable these if ATL is being used + +// +// Helper functions can be used to implement GetObjectToken/SetObjectToken for objects that +// support ISpObjectWithToken +// +inline HRESULT SpGenericSetObjectToken(ISpObjectToken * pCallersToken, CComPtr & cpObjToken) +{ + HRESULT hr = S_OK; + if (SP_IS_BAD_INTERFACE_PTR(pCallersToken)) + { + hr = E_INVALIDARG; + } + else + { + if (cpObjToken) + { + hr = SPERR_ALREADY_INITIALIZED; + } + else + { + cpObjToken = pCallersToken; + } + } + return hr; +} + + +inline HRESULT SpGenericGetObjectToken(ISpObjectToken ** ppCallersToken, CComPtr & cpObjToken) +{ + HRESULT hr = S_OK; + if (SP_IS_BAD_WRITE_PTR(ppCallersToken)) + { + hr = E_POINTER; + } + else + { + *ppCallersToken = cpObjToken; + if (*ppCallersToken) + { + (*ppCallersToken)->AddRef(); + } + else + { + hr = S_FALSE; + } + } + return hr; +} + +#endif // __ATLCOM_H__ + + +// +// Helper class for SPSTATEINFO sturcture automatically initializes and cleans up +// the structure + provides a few helper functions. +// +class CSpStateInfo : public SPSTATEINFO +{ +public: + CSpStateInfo() + { + cAllocatedEntries = NULL; + pTransitions = NULL; + } + ~CSpStateInfo() + { + ::CoTaskMemFree(pTransitions); + } + SPTRANSITIONENTRY * FirstEpsilon() + { + return pTransitions; + } + SPTRANSITIONENTRY * FirstRule() + { + return pTransitions + cEpsilons; + } + SPTRANSITIONENTRY * FirstWord() + { + return pTransitions + cEpsilons + cRules; + } + SPTRANSITIONENTRY * FirstSpecialTransition() + { + return pTransitions + cEpsilons + cRules + cWords; + } +}; + + +// +// This basic queue implementation can be used to maintin linked lists of classes. The class T +// must contain the member m_pNext which is used by this template to point to the next element. +// If the bPurgeWhenDeleted is TRUE then all of the elements in the queue will be deleted +// when the queue is deleted, otherwise they will not. +// If bMaintainCount is TRUE then a running count will be maintained, and GetCount() will be +// efficent. If it is FALSE then a running count will not be maintained, and GetCount() will +// be an order N operation. If you do not require a count, then +// + +template class CSpBasicList; + +template +class CSpBasicQueue +{ +public: + T * m_pHead; + T * m_pTail; + ULONG m_cElements; // Warning! Use GetCount() -- Not maintained if bMaintainCount is FALSE. + + CSpBasicQueue() + { + m_pHead = NULL; + if (bMaintainCount) + { + m_cElements = 0; + } + } + + ~CSpBasicQueue() + { + if (bPurgeWhenDeleted) + { + Purge(); + } + } + + HRESULT CreateNode(T ** ppNode) + { + *ppNode = new T; + if (*ppNode) + { + return S_OK; + } + else + { + return E_OUTOFMEMORY; + } + } + + T * GetNext(const T * pNode) + { + return pNode->m_pNext; + } + + + T * Item(ULONG i) + { + T * pNode = m_pHead; + while (pNode && i) + { + i--; + pNode = pNode->m_pNext; + } + return pNode; + } + + void InsertAfter(T * pPrev, T * pNewNode) + { + if (pPrev) + { + pNewNode->m_pNext = pPrev->m_pNext; + pPrev->m_pNext = pNewNode; + if (pNewNode->m_pNext == NULL) + { + m_pTail = pNewNode; + } + if (bMaintainCount) ++m_cElements; + } + else + { + InsertHead(pNewNode); + } + } + + void InsertTail(T * pNode) + { + pNode->m_pNext = NULL; + if (m_pHead) + { + m_pTail->m_pNext = pNode; + } + else + { + m_pHead = pNode; + } + m_pTail = pNode; + if (bMaintainCount) ++m_cElements; + } + + void InsertHead(T * pNode) + { + pNode->m_pNext = m_pHead; + if (m_pHead == NULL) + { + m_pTail = pNode; + } + m_pHead = pNode; + if (bMaintainCount) ++m_cElements; + } + + T * RemoveHead() + { + T * pNode = m_pHead; + if (pNode) + { + m_pHead = pNode->m_pNext; + if (bMaintainCount) --m_cElements; + } + return pNode; + } + + T * RemoveTail() + { + T * pNode = m_pHead; + if (pNode) + { + if (pNode == m_pTail) + { + m_pHead = NULL; + } + else + { + T * pPrev; + do + { + pPrev = pNode; + pNode = pNode->m_pNext; + } while ( pNode != m_pTail ); + pPrev->m_pNext = NULL; + m_pTail = pPrev; + } + if (bMaintainCount) --m_cElements; + } + return pNode; + } + + void Purge() + { + while (m_pHead) + { + T * pDie = m_pHead; + m_pHead = pDie->m_pNext; + delete pDie; + } + if (bMaintainCount) m_cElements = 0; + } + + void ExplicitPurge() + { + T * pDie; + BYTE * pb; + + while (m_pHead) + { + pDie = m_pHead; + m_pHead = pDie->m_pNext; + + pDie->~T(); + + pb = reinterpret_cast(pDie); + delete [] pb; + } + if (bMaintainCount) m_cElements = 0; + } + + + T * GetTail() const + { + if (m_pHead) + { + return m_pTail; + } + return NULL; + } + + T * GetHead() const + { + return m_pHead; + } + + BOOL IsEmpty() const + { + return m_pHead == NULL; + } + + BOOL Remove(T * pNode) + { + if (m_pHead == pNode) + { + m_pHead = pNode->m_pNext; + if (bMaintainCount) --m_cElements; + return TRUE; + } + else + { + T * pCur = m_pHead; + while (pCur) + { + T * pNext = pCur->m_pNext; + if (pNext == pNode) + { + if ((pCur->m_pNext = pNode->m_pNext) == NULL) + { + m_pTail = pCur; + } + if (bMaintainCount) --m_cElements; + return TRUE; + } + pCur = pNext; + } + } + return FALSE; + } + + void MoveAllToHeadOf(CSpBasicQueue & DestQueue) + { + if (m_pHead) + { + m_pTail->m_pNext = DestQueue.m_pHead; + if (DestQueue.m_pHead == NULL) + { + DestQueue.m_pTail = m_pTail; + } + DestQueue.m_pHead = m_pHead; + m_pHead = NULL; + if (bMaintainCount) + { + DestQueue.m_cElements += m_cElements; + m_cElements = 0; + } + } + } + + void MoveAllToList(CSpBasicList & List) + { + if (m_pHead) + { + m_pTail->m_pNext = List.m_pFirst; + List.m_pFirst = m_pHead; + m_pHead = NULL; + } + if (bMaintainCount) + { + m_cElements = 0; + } + } + + BOOL MoveToList(T * pNode, CSpBasicList & List) + { + BOOL bFound = Remove(pNode); + if (bFound) + { + List.AddNode(pNode); + } + return bFound; + } + + ULONG GetCount() const + { + if (bMaintainCount) + { + return m_cElements; + } + else + { + ULONG c = 0; + for (T * pNode = m_pHead; + pNode; + pNode = pNode->m_pNext, c++) {} + return c; + } + } + + // + // The following functions require the class T to implement a static function: + // + // LONG Compare(const T * pElem1, const T * pElem2) + // + // which returns < 0 if pElem1 is less than pElem2, 0 if they are equal, and > 0 if + // pElem1 is greater than pElem2. + // + void InsertSorted(T * pNode) + { + if (m_pHead) + { + if (T::Compare(pNode, m_pTail) >= 0) + { + pNode->m_pNext = NULL; + m_pTail->m_pNext = pNode; + m_pTail = pNode; + } + else + { + // + // We don't have to worry about walking off of the end of the list here since + // we have already checked the tail. + // + T ** ppNext = &m_pHead; + while (T::Compare(pNode, *ppNext) >= 0) + { + ppNext = &((*ppNext)->m_pNext); + } + pNode->m_pNext = *ppNext; + *ppNext = pNode; + } + } + else + { + pNode->m_pNext = NULL; + m_pHead = m_pTail = pNode; + } + if (bMaintainCount) ++m_cElements; + } + + HRESULT InsertSortedUnique(T * pNode) + { + HRESULT hr = S_OK; + if (m_pHead) + { + if (T::Compare(pNode, m_pTail) > 0) + { + pNode->m_pNext = NULL; + m_pTail->m_pNext = pNode; + m_pTail = pNode; + } + else + { + // + // We don't have to worry about walking off of the end of the list here since + // we have already checked the tail. + // + T ** ppNext = &m_pHead; + while (T::Compare(pNode, *ppNext) > 0) + { + ppNext = &((*ppNext)->m_pNext); + } + if (T::Compare(pNode, *ppNext) != 0) + { + pNode->m_pNext = *ppNext; + *ppNext = pNode; + } + else + { + delete pNode; + hr = S_FALSE; + } + } + } + else + { + pNode->m_pNext = NULL; + m_pHead = m_pTail = pNode; + } + if (bMaintainCount) ++m_cElements; + return hr; + } + + // + // These functions must support the "==" operator for the TFIND type. + // + template + T * Find(TFIND & FindVal) const + { + for (T * pNode = m_pHead; pNode && (!(*pNode == FindVal)); pNode = pNode->m_pNext) + {} + return pNode; + } + + template + T * FindNext(const T * pCurNode, TFIND & FindVal) const + { + for (T * pNode = pCurNode->m_pNext; pNode && (!(*pNode == FindVal)); pNode = pNode->m_pNext) + {} + return pNode; + } + + // + // Searches for and removes a single list element + // + template + T * FindAndRemove(TFIND & FindVal) + { + T * pNode = m_pHead; + if (pNode) + { + if (*pNode == FindVal) + { + m_pHead = pNode->m_pNext; + if (bMaintainCount) --m_cElements; + } + else + { + T * pPrev = pNode; + for (pNode = pNode->m_pNext; + pNode; + pPrev = pNode, pNode = pNode->m_pNext) + { + if (*pNode == FindVal) + { + pPrev->m_pNext = pNode->m_pNext; + if (pNode->m_pNext == NULL) + { + m_pTail = pPrev; + } + if (bMaintainCount) --m_cElements; + break; + } + } + } + } + return pNode; + } + + // + // Searches for and deletes all list elements that match + // + template + void FindAndDeleteAll(TFIND & FindVal) + { + T * pNode = m_pHead; + while (pNode && *pNode == FindVal) + { + m_pHead = pNode->m_pNext; + delete pNode; + if (bMaintainCount) --m_cElements; + pNode = m_pHead; + } + T * pPrev = pNode; + while (pNode) + { + T * pNext = pNode->m_pNext; + if (*pNode == FindVal) + { + pPrev->m_pNext = pNext; + delete pNode; + if (bMaintainCount) --m_cElements; + } + else + { + pPrev = pNode; + } + pNode = pNext; + } + m_pTail = pPrev; // Just always set it in case we removed the tail. + } + + +}; + +template +class CSpBasicList +{ +public: + T * m_pFirst; + CSpBasicList() : m_pFirst(NULL) {} + ~CSpBasicList() + { + if (bPurgeWhenDeleted) + { + Purge(); + } + } + + void Purge() + { + while (m_pFirst) + { + T * pNext = m_pFirst->m_pNext; + delete m_pFirst; + m_pFirst = pNext; + } + } + + void ExplicitPurge() + { + T * pDie; + BYTE * pb; + + while (m_pFirst) + { + pDie = m_pFirst; + m_pFirst = pDie->m_pNext; + + pDie->~T(); + + pb = reinterpret_cast(pDie); + delete [] pb; + } + } + + HRESULT RemoveFirstOrAllocateNew(T ** ppNode) + { + if (m_pFirst) + { + *ppNode = m_pFirst; + m_pFirst = m_pFirst->m_pNext; + } + else + { + *ppNode = new T; + if (*ppNode == NULL) + { + return E_OUTOFMEMORY; + } + } + return S_OK; + } + + void AddNode(T * pNode) + { + pNode->m_pNext = m_pFirst; + m_pFirst = pNode; + } + T * GetFirst() + { + return m_pFirst; + } + T * RemoveFirst() + { + T * pNode = m_pFirst; + if (pNode) + { + m_pFirst = pNode->m_pNext; + } + return pNode; + } +}; + +#define STACK_ALLOC(TYPE, COUNT) (TYPE *)_alloca(sizeof(TYPE) * (COUNT)) +#define STACK_ALLOC_AND_ZERO(TYPE, COUNT) (TYPE *)memset(_alloca(sizeof(TYPE) * (COUNT)), 0, (sizeof(TYPE) * (COUNT))) +#define STACK_ALLOC_AND_COPY(TYPE, COUNT, SOURCE) (TYPE *)memcpy(_alloca(sizeof(TYPE) * (COUNT)), (SOURCE), (sizeof(TYPE) * (COUNT))) + +inline HRESULT SpGetSubTokenFromToken( + ISpObjectToken * pToken, + const WCHAR * pszSubKeyName, + ISpObjectToken ** ppToken, + BOOL fCreateIfNotExist = FALSE) +{ + SPDBG_FUNC("SpGetTokenFromDataKey"); + HRESULT hr = S_OK; + + if (SP_IS_BAD_INTERFACE_PTR(pToken) || + SP_IS_BAD_STRING_PTR(pszSubKeyName) || + SP_IS_BAD_WRITE_PTR(ppToken)) + { + hr = E_POINTER; + } + + // First, either create or open the datakey for the new token + CComPtr cpDataKeyForNewToken; + if (SUCCEEDED(hr)) + { + if (fCreateIfNotExist) + { + hr = pToken->CreateKey(pszSubKeyName, &cpDataKeyForNewToken); + } + else + { + hr = pToken->OpenKey(pszSubKeyName, &cpDataKeyForNewToken); + } + } + + // The sub token's category will be the token id of it's parent token + CSpDynamicString dstrCategoryId; + if (SUCCEEDED(hr)) + { + hr = pToken->GetId(&dstrCategoryId); + } + + // The sub token's token id will be it's category id + "\\" the key name + CSpDynamicString dstrTokenId; + if (SUCCEEDED(hr)) + { + dstrTokenId = dstrCategoryId; + dstrTokenId.Append2(L"\\", pszSubKeyName); + } + + // Now create the token and initalize it + CComPtr cpTokenInit; + if (SUCCEEDED(hr)) + { + hr = cpTokenInit.CoCreateInstance(CLSID_SpObjectToken); + } + + if (SUCCEEDED(hr)) + { + hr = cpTokenInit->InitFromDataKey(dstrCategoryId, dstrTokenId, cpDataKeyForNewToken); + } + + if (SUCCEEDED(hr)) + { + *ppToken = cpTokenInit.Detach(); + } + + SPDBG_REPORT_ON_FAIL(hr); + return hr; +} + +template +HRESULT SpCreateObjectFromSubToken(ISpObjectToken * pToken, const WCHAR * pszSubKeyName, T ** ppObject, + IUnknown * pUnkOuter = NULL, DWORD dwClsCtxt = CLSCTX_ALL) +{ + SPDBG_FUNC("SpCreateObjectFromSubToken"); + HRESULT hr; + + CComPtr cpSubToken; + hr = SpGetSubTokenFromToken(pToken, pszSubKeyName, &cpSubToken); + + if (SUCCEEDED(hr)) + { + hr = SpCreateObjectFromToken(cpSubToken, ppObject, pUnkOuter, dwClsCtxt); + } + + SPDBG_REPORT_ON_FAIL(hr); + return hr; +} + +#endif /* This must be the last line in the file */ diff --git a/speech2/third_party/sapi5/include/sapi.h b/speech2/third_party/sapi5/include/sapi.h new file mode 100644 index 0000000..6412e3d --- /dev/null +++ b/speech2/third_party/sapi5/include/sapi.h @@ -0,0 +1,25599 @@ + +#pragma warning( disable: 4049 ) /* more than 64k source lines */ + +/* this ALWAYS GENERATED file contains the definitions for the interfaces */ + + + /* File created by MIDL compiler version 6.00.0347 */ +/* Compiler settings for sapi.idl: + Oicf, W1, Zp8, env=Win32 (32b run) + protocol : dce , ms_ext, c_ext + error checks: allocation ref bounds_check enum stub_data + VC __declspec() decoration level: + __declspec(uuid()), __declspec(selectany), __declspec(novtable) + DECLSPEC_UUID(), MIDL_INTERFACE() +*/ +//@@MIDL_FILE_HEADING( ) + + +/* verify that the version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCNDR_H_VERSION__ +#define __REQUIRED_RPCNDR_H_VERSION__ 440 +#endif + +#include "rpc.h" +#include "rpcndr.h" + +#ifndef __RPCNDR_H_VERSION__ +#error this stub requires an updated version of +#endif // __RPCNDR_H_VERSION__ + +#ifndef COM_NO_WINDOWS_H +#include "windows.h" +#include "ole2.h" +#endif /*COM_NO_WINDOWS_H*/ + +#ifndef __sapi_h__ +#define __sapi_h__ + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#pragma once +#endif + +/* Forward Declarations */ + +#ifndef __ISpNotifySource_FWD_DEFINED__ +#define __ISpNotifySource_FWD_DEFINED__ +typedef interface ISpNotifySource ISpNotifySource; +#endif /* __ISpNotifySource_FWD_DEFINED__ */ + + +#ifndef __ISpNotifySink_FWD_DEFINED__ +#define __ISpNotifySink_FWD_DEFINED__ +typedef interface ISpNotifySink ISpNotifySink; +#endif /* __ISpNotifySink_FWD_DEFINED__ */ + + +#ifndef __ISpNotifyTranslator_FWD_DEFINED__ +#define __ISpNotifyTranslator_FWD_DEFINED__ +typedef interface ISpNotifyTranslator ISpNotifyTranslator; +#endif /* __ISpNotifyTranslator_FWD_DEFINED__ */ + + +#ifndef __ISpDataKey_FWD_DEFINED__ +#define __ISpDataKey_FWD_DEFINED__ +typedef interface ISpDataKey ISpDataKey; +#endif /* __ISpDataKey_FWD_DEFINED__ */ + + +#ifndef __ISpRegDataKey_FWD_DEFINED__ +#define __ISpRegDataKey_FWD_DEFINED__ +typedef interface ISpRegDataKey ISpRegDataKey; +#endif /* __ISpRegDataKey_FWD_DEFINED__ */ + + +#ifndef __ISpObjectTokenCategory_FWD_DEFINED__ +#define __ISpObjectTokenCategory_FWD_DEFINED__ +typedef interface ISpObjectTokenCategory ISpObjectTokenCategory; +#endif /* __ISpObjectTokenCategory_FWD_DEFINED__ */ + + +#ifndef __ISpObjectToken_FWD_DEFINED__ +#define __ISpObjectToken_FWD_DEFINED__ +typedef interface ISpObjectToken ISpObjectToken; +#endif /* __ISpObjectToken_FWD_DEFINED__ */ + + +#ifndef __ISpObjectTokenInit_FWD_DEFINED__ +#define __ISpObjectTokenInit_FWD_DEFINED__ +typedef interface ISpObjectTokenInit ISpObjectTokenInit; +#endif /* __ISpObjectTokenInit_FWD_DEFINED__ */ + + +#ifndef __IEnumSpObjectTokens_FWD_DEFINED__ +#define __IEnumSpObjectTokens_FWD_DEFINED__ +typedef interface IEnumSpObjectTokens IEnumSpObjectTokens; +#endif /* __IEnumSpObjectTokens_FWD_DEFINED__ */ + + +#ifndef __ISpObjectWithToken_FWD_DEFINED__ +#define __ISpObjectWithToken_FWD_DEFINED__ +typedef interface ISpObjectWithToken ISpObjectWithToken; +#endif /* __ISpObjectWithToken_FWD_DEFINED__ */ + + +#ifndef __ISpResourceManager_FWD_DEFINED__ +#define __ISpResourceManager_FWD_DEFINED__ +typedef interface ISpResourceManager ISpResourceManager; +#endif /* __ISpResourceManager_FWD_DEFINED__ */ + + +#ifndef __ISpEventSource_FWD_DEFINED__ +#define __ISpEventSource_FWD_DEFINED__ +typedef interface ISpEventSource ISpEventSource; +#endif /* __ISpEventSource_FWD_DEFINED__ */ + + +#ifndef __ISpEventSink_FWD_DEFINED__ +#define __ISpEventSink_FWD_DEFINED__ +typedef interface ISpEventSink ISpEventSink; +#endif /* __ISpEventSink_FWD_DEFINED__ */ + + +#ifndef __ISpStreamFormat_FWD_DEFINED__ +#define __ISpStreamFormat_FWD_DEFINED__ +typedef interface ISpStreamFormat ISpStreamFormat; +#endif /* __ISpStreamFormat_FWD_DEFINED__ */ + + +#ifndef __ISpStream_FWD_DEFINED__ +#define __ISpStream_FWD_DEFINED__ +typedef interface ISpStream ISpStream; +#endif /* __ISpStream_FWD_DEFINED__ */ + + +#ifndef __ISpStreamFormatConverter_FWD_DEFINED__ +#define __ISpStreamFormatConverter_FWD_DEFINED__ +typedef interface ISpStreamFormatConverter ISpStreamFormatConverter; +#endif /* __ISpStreamFormatConverter_FWD_DEFINED__ */ + + +#ifndef __ISpAudio_FWD_DEFINED__ +#define __ISpAudio_FWD_DEFINED__ +typedef interface ISpAudio ISpAudio; +#endif /* __ISpAudio_FWD_DEFINED__ */ + + +#ifndef __ISpMMSysAudio_FWD_DEFINED__ +#define __ISpMMSysAudio_FWD_DEFINED__ +typedef interface ISpMMSysAudio ISpMMSysAudio; +#endif /* __ISpMMSysAudio_FWD_DEFINED__ */ + + +#ifndef __ISpTranscript_FWD_DEFINED__ +#define __ISpTranscript_FWD_DEFINED__ +typedef interface ISpTranscript ISpTranscript; +#endif /* __ISpTranscript_FWD_DEFINED__ */ + + +#ifndef __ISpLexicon_FWD_DEFINED__ +#define __ISpLexicon_FWD_DEFINED__ +typedef interface ISpLexicon ISpLexicon; +#endif /* __ISpLexicon_FWD_DEFINED__ */ + + +#ifndef __ISpContainerLexicon_FWD_DEFINED__ +#define __ISpContainerLexicon_FWD_DEFINED__ +typedef interface ISpContainerLexicon ISpContainerLexicon; +#endif /* __ISpContainerLexicon_FWD_DEFINED__ */ + + +#ifndef __ISpPhoneConverter_FWD_DEFINED__ +#define __ISpPhoneConverter_FWD_DEFINED__ +typedef interface ISpPhoneConverter ISpPhoneConverter; +#endif /* __ISpPhoneConverter_FWD_DEFINED__ */ + + +#ifndef __ISpVoice_FWD_DEFINED__ +#define __ISpVoice_FWD_DEFINED__ +typedef interface ISpVoice ISpVoice; +#endif /* __ISpVoice_FWD_DEFINED__ */ + + +#ifndef __ISpPhrase_FWD_DEFINED__ +#define __ISpPhrase_FWD_DEFINED__ +typedef interface ISpPhrase ISpPhrase; +#endif /* __ISpPhrase_FWD_DEFINED__ */ + + +#ifndef __ISpPhraseAlt_FWD_DEFINED__ +#define __ISpPhraseAlt_FWD_DEFINED__ +typedef interface ISpPhraseAlt ISpPhraseAlt; +#endif /* __ISpPhraseAlt_FWD_DEFINED__ */ + + +#ifndef __ISpRecoResult_FWD_DEFINED__ +#define __ISpRecoResult_FWD_DEFINED__ +typedef interface ISpRecoResult ISpRecoResult; +#endif /* __ISpRecoResult_FWD_DEFINED__ */ + + +#ifndef __ISpGrammarBuilder_FWD_DEFINED__ +#define __ISpGrammarBuilder_FWD_DEFINED__ +typedef interface ISpGrammarBuilder ISpGrammarBuilder; +#endif /* __ISpGrammarBuilder_FWD_DEFINED__ */ + + +#ifndef __ISpRecoGrammar_FWD_DEFINED__ +#define __ISpRecoGrammar_FWD_DEFINED__ +typedef interface ISpRecoGrammar ISpRecoGrammar; +#endif /* __ISpRecoGrammar_FWD_DEFINED__ */ + + +#ifndef __ISpRecoContext_FWD_DEFINED__ +#define __ISpRecoContext_FWD_DEFINED__ +typedef interface ISpRecoContext ISpRecoContext; +#endif /* __ISpRecoContext_FWD_DEFINED__ */ + + +#ifndef __ISpProperties_FWD_DEFINED__ +#define __ISpProperties_FWD_DEFINED__ +typedef interface ISpProperties ISpProperties; +#endif /* __ISpProperties_FWD_DEFINED__ */ + + +#ifndef __ISpRecognizer_FWD_DEFINED__ +#define __ISpRecognizer_FWD_DEFINED__ +typedef interface ISpRecognizer ISpRecognizer; +#endif /* __ISpRecognizer_FWD_DEFINED__ */ + + +#ifndef __ISpeechDataKey_FWD_DEFINED__ +#define __ISpeechDataKey_FWD_DEFINED__ +typedef interface ISpeechDataKey ISpeechDataKey; +#endif /* __ISpeechDataKey_FWD_DEFINED__ */ + + +#ifndef __ISpeechObjectToken_FWD_DEFINED__ +#define __ISpeechObjectToken_FWD_DEFINED__ +typedef interface ISpeechObjectToken ISpeechObjectToken; +#endif /* __ISpeechObjectToken_FWD_DEFINED__ */ + + +#ifndef __ISpeechObjectTokens_FWD_DEFINED__ +#define __ISpeechObjectTokens_FWD_DEFINED__ +typedef interface ISpeechObjectTokens ISpeechObjectTokens; +#endif /* __ISpeechObjectTokens_FWD_DEFINED__ */ + + +#ifndef __ISpeechObjectTokenCategory_FWD_DEFINED__ +#define __ISpeechObjectTokenCategory_FWD_DEFINED__ +typedef interface ISpeechObjectTokenCategory ISpeechObjectTokenCategory; +#endif /* __ISpeechObjectTokenCategory_FWD_DEFINED__ */ + + +#ifndef __ISpeechAudioBufferInfo_FWD_DEFINED__ +#define __ISpeechAudioBufferInfo_FWD_DEFINED__ +typedef interface ISpeechAudioBufferInfo ISpeechAudioBufferInfo; +#endif /* __ISpeechAudioBufferInfo_FWD_DEFINED__ */ + + +#ifndef __ISpeechAudioStatus_FWD_DEFINED__ +#define __ISpeechAudioStatus_FWD_DEFINED__ +typedef interface ISpeechAudioStatus ISpeechAudioStatus; +#endif /* __ISpeechAudioStatus_FWD_DEFINED__ */ + + +#ifndef __ISpeechAudioFormat_FWD_DEFINED__ +#define __ISpeechAudioFormat_FWD_DEFINED__ +typedef interface ISpeechAudioFormat ISpeechAudioFormat; +#endif /* __ISpeechAudioFormat_FWD_DEFINED__ */ + + +#ifndef __ISpeechWaveFormatEx_FWD_DEFINED__ +#define __ISpeechWaveFormatEx_FWD_DEFINED__ +typedef interface ISpeechWaveFormatEx ISpeechWaveFormatEx; +#endif /* __ISpeechWaveFormatEx_FWD_DEFINED__ */ + + +#ifndef __ISpeechBaseStream_FWD_DEFINED__ +#define __ISpeechBaseStream_FWD_DEFINED__ +typedef interface ISpeechBaseStream ISpeechBaseStream; +#endif /* __ISpeechBaseStream_FWD_DEFINED__ */ + + +#ifndef __ISpeechFileStream_FWD_DEFINED__ +#define __ISpeechFileStream_FWD_DEFINED__ +typedef interface ISpeechFileStream ISpeechFileStream; +#endif /* __ISpeechFileStream_FWD_DEFINED__ */ + + +#ifndef __ISpeechMemoryStream_FWD_DEFINED__ +#define __ISpeechMemoryStream_FWD_DEFINED__ +typedef interface ISpeechMemoryStream ISpeechMemoryStream; +#endif /* __ISpeechMemoryStream_FWD_DEFINED__ */ + + +#ifndef __ISpeechCustomStream_FWD_DEFINED__ +#define __ISpeechCustomStream_FWD_DEFINED__ +typedef interface ISpeechCustomStream ISpeechCustomStream; +#endif /* __ISpeechCustomStream_FWD_DEFINED__ */ + + +#ifndef __ISpeechAudio_FWD_DEFINED__ +#define __ISpeechAudio_FWD_DEFINED__ +typedef interface ISpeechAudio ISpeechAudio; +#endif /* __ISpeechAudio_FWD_DEFINED__ */ + + +#ifndef __ISpeechMMSysAudio_FWD_DEFINED__ +#define __ISpeechMMSysAudio_FWD_DEFINED__ +typedef interface ISpeechMMSysAudio ISpeechMMSysAudio; +#endif /* __ISpeechMMSysAudio_FWD_DEFINED__ */ + + +#ifndef __ISpeechVoice_FWD_DEFINED__ +#define __ISpeechVoice_FWD_DEFINED__ +typedef interface ISpeechVoice ISpeechVoice; +#endif /* __ISpeechVoice_FWD_DEFINED__ */ + + +#ifndef __ISpeechVoiceStatus_FWD_DEFINED__ +#define __ISpeechVoiceStatus_FWD_DEFINED__ +typedef interface ISpeechVoiceStatus ISpeechVoiceStatus; +#endif /* __ISpeechVoiceStatus_FWD_DEFINED__ */ + + +#ifndef ___ISpeechVoiceEvents_FWD_DEFINED__ +#define ___ISpeechVoiceEvents_FWD_DEFINED__ +typedef interface _ISpeechVoiceEvents _ISpeechVoiceEvents; +#endif /* ___ISpeechVoiceEvents_FWD_DEFINED__ */ + + +#ifndef __ISpeechRecognizer_FWD_DEFINED__ +#define __ISpeechRecognizer_FWD_DEFINED__ +typedef interface ISpeechRecognizer ISpeechRecognizer; +#endif /* __ISpeechRecognizer_FWD_DEFINED__ */ + + +#ifndef __ISpeechRecognizerStatus_FWD_DEFINED__ +#define __ISpeechRecognizerStatus_FWD_DEFINED__ +typedef interface ISpeechRecognizerStatus ISpeechRecognizerStatus; +#endif /* __ISpeechRecognizerStatus_FWD_DEFINED__ */ + + +#ifndef __ISpeechRecoContext_FWD_DEFINED__ +#define __ISpeechRecoContext_FWD_DEFINED__ +typedef interface ISpeechRecoContext ISpeechRecoContext; +#endif /* __ISpeechRecoContext_FWD_DEFINED__ */ + + +#ifndef __ISpeechRecoGrammar_FWD_DEFINED__ +#define __ISpeechRecoGrammar_FWD_DEFINED__ +typedef interface ISpeechRecoGrammar ISpeechRecoGrammar; +#endif /* __ISpeechRecoGrammar_FWD_DEFINED__ */ + + +#ifndef ___ISpeechRecoContextEvents_FWD_DEFINED__ +#define ___ISpeechRecoContextEvents_FWD_DEFINED__ +typedef interface _ISpeechRecoContextEvents _ISpeechRecoContextEvents; +#endif /* ___ISpeechRecoContextEvents_FWD_DEFINED__ */ + + +#ifndef __ISpeechGrammarRule_FWD_DEFINED__ +#define __ISpeechGrammarRule_FWD_DEFINED__ +typedef interface ISpeechGrammarRule ISpeechGrammarRule; +#endif /* __ISpeechGrammarRule_FWD_DEFINED__ */ + + +#ifndef __ISpeechGrammarRules_FWD_DEFINED__ +#define __ISpeechGrammarRules_FWD_DEFINED__ +typedef interface ISpeechGrammarRules ISpeechGrammarRules; +#endif /* __ISpeechGrammarRules_FWD_DEFINED__ */ + + +#ifndef __ISpeechGrammarRuleState_FWD_DEFINED__ +#define __ISpeechGrammarRuleState_FWD_DEFINED__ +typedef interface ISpeechGrammarRuleState ISpeechGrammarRuleState; +#endif /* __ISpeechGrammarRuleState_FWD_DEFINED__ */ + + +#ifndef __ISpeechGrammarRuleStateTransition_FWD_DEFINED__ +#define __ISpeechGrammarRuleStateTransition_FWD_DEFINED__ +typedef interface ISpeechGrammarRuleStateTransition ISpeechGrammarRuleStateTransition; +#endif /* __ISpeechGrammarRuleStateTransition_FWD_DEFINED__ */ + + +#ifndef __ISpeechGrammarRuleStateTransitions_FWD_DEFINED__ +#define __ISpeechGrammarRuleStateTransitions_FWD_DEFINED__ +typedef interface ISpeechGrammarRuleStateTransitions ISpeechGrammarRuleStateTransitions; +#endif /* __ISpeechGrammarRuleStateTransitions_FWD_DEFINED__ */ + + +#ifndef __ISpeechTextSelectionInformation_FWD_DEFINED__ +#define __ISpeechTextSelectionInformation_FWD_DEFINED__ +typedef interface ISpeechTextSelectionInformation ISpeechTextSelectionInformation; +#endif /* __ISpeechTextSelectionInformation_FWD_DEFINED__ */ + + +#ifndef __ISpeechRecoResult_FWD_DEFINED__ +#define __ISpeechRecoResult_FWD_DEFINED__ +typedef interface ISpeechRecoResult ISpeechRecoResult; +#endif /* __ISpeechRecoResult_FWD_DEFINED__ */ + + +#ifndef __ISpeechRecoResultTimes_FWD_DEFINED__ +#define __ISpeechRecoResultTimes_FWD_DEFINED__ +typedef interface ISpeechRecoResultTimes ISpeechRecoResultTimes; +#endif /* __ISpeechRecoResultTimes_FWD_DEFINED__ */ + + +#ifndef __ISpeechPhraseAlternate_FWD_DEFINED__ +#define __ISpeechPhraseAlternate_FWD_DEFINED__ +typedef interface ISpeechPhraseAlternate ISpeechPhraseAlternate; +#endif /* __ISpeechPhraseAlternate_FWD_DEFINED__ */ + + +#ifndef __ISpeechPhraseAlternates_FWD_DEFINED__ +#define __ISpeechPhraseAlternates_FWD_DEFINED__ +typedef interface ISpeechPhraseAlternates ISpeechPhraseAlternates; +#endif /* __ISpeechPhraseAlternates_FWD_DEFINED__ */ + + +#ifndef __ISpeechPhraseInfo_FWD_DEFINED__ +#define __ISpeechPhraseInfo_FWD_DEFINED__ +typedef interface ISpeechPhraseInfo ISpeechPhraseInfo; +#endif /* __ISpeechPhraseInfo_FWD_DEFINED__ */ + + +#ifndef __ISpeechPhraseElement_FWD_DEFINED__ +#define __ISpeechPhraseElement_FWD_DEFINED__ +typedef interface ISpeechPhraseElement ISpeechPhraseElement; +#endif /* __ISpeechPhraseElement_FWD_DEFINED__ */ + + +#ifndef __ISpeechPhraseElements_FWD_DEFINED__ +#define __ISpeechPhraseElements_FWD_DEFINED__ +typedef interface ISpeechPhraseElements ISpeechPhraseElements; +#endif /* __ISpeechPhraseElements_FWD_DEFINED__ */ + + +#ifndef __ISpeechPhraseReplacement_FWD_DEFINED__ +#define __ISpeechPhraseReplacement_FWD_DEFINED__ +typedef interface ISpeechPhraseReplacement ISpeechPhraseReplacement; +#endif /* __ISpeechPhraseReplacement_FWD_DEFINED__ */ + + +#ifndef __ISpeechPhraseReplacements_FWD_DEFINED__ +#define __ISpeechPhraseReplacements_FWD_DEFINED__ +typedef interface ISpeechPhraseReplacements ISpeechPhraseReplacements; +#endif /* __ISpeechPhraseReplacements_FWD_DEFINED__ */ + + +#ifndef __ISpeechPhraseProperty_FWD_DEFINED__ +#define __ISpeechPhraseProperty_FWD_DEFINED__ +typedef interface ISpeechPhraseProperty ISpeechPhraseProperty; +#endif /* __ISpeechPhraseProperty_FWD_DEFINED__ */ + + +#ifndef __ISpeechPhraseProperties_FWD_DEFINED__ +#define __ISpeechPhraseProperties_FWD_DEFINED__ +typedef interface ISpeechPhraseProperties ISpeechPhraseProperties; +#endif /* __ISpeechPhraseProperties_FWD_DEFINED__ */ + + +#ifndef __ISpeechPhraseRule_FWD_DEFINED__ +#define __ISpeechPhraseRule_FWD_DEFINED__ +typedef interface ISpeechPhraseRule ISpeechPhraseRule; +#endif /* __ISpeechPhraseRule_FWD_DEFINED__ */ + + +#ifndef __ISpeechPhraseRules_FWD_DEFINED__ +#define __ISpeechPhraseRules_FWD_DEFINED__ +typedef interface ISpeechPhraseRules ISpeechPhraseRules; +#endif /* __ISpeechPhraseRules_FWD_DEFINED__ */ + + +#ifndef __ISpeechLexicon_FWD_DEFINED__ +#define __ISpeechLexicon_FWD_DEFINED__ +typedef interface ISpeechLexicon ISpeechLexicon; +#endif /* __ISpeechLexicon_FWD_DEFINED__ */ + + +#ifndef __ISpeechLexiconWords_FWD_DEFINED__ +#define __ISpeechLexiconWords_FWD_DEFINED__ +typedef interface ISpeechLexiconWords ISpeechLexiconWords; +#endif /* __ISpeechLexiconWords_FWD_DEFINED__ */ + + +#ifndef __ISpeechLexiconWord_FWD_DEFINED__ +#define __ISpeechLexiconWord_FWD_DEFINED__ +typedef interface ISpeechLexiconWord ISpeechLexiconWord; +#endif /* __ISpeechLexiconWord_FWD_DEFINED__ */ + + +#ifndef __ISpeechLexiconPronunciations_FWD_DEFINED__ +#define __ISpeechLexiconPronunciations_FWD_DEFINED__ +typedef interface ISpeechLexiconPronunciations ISpeechLexiconPronunciations; +#endif /* __ISpeechLexiconPronunciations_FWD_DEFINED__ */ + + +#ifndef __ISpeechLexiconPronunciation_FWD_DEFINED__ +#define __ISpeechLexiconPronunciation_FWD_DEFINED__ +typedef interface ISpeechLexiconPronunciation ISpeechLexiconPronunciation; +#endif /* __ISpeechLexiconPronunciation_FWD_DEFINED__ */ + + +#ifndef __ISpeechPhraseInfoBuilder_FWD_DEFINED__ +#define __ISpeechPhraseInfoBuilder_FWD_DEFINED__ +typedef interface ISpeechPhraseInfoBuilder ISpeechPhraseInfoBuilder; +#endif /* __ISpeechPhraseInfoBuilder_FWD_DEFINED__ */ + + +#ifndef __ISpeechPhoneConverter_FWD_DEFINED__ +#define __ISpeechPhoneConverter_FWD_DEFINED__ +typedef interface ISpeechPhoneConverter ISpeechPhoneConverter; +#endif /* __ISpeechPhoneConverter_FWD_DEFINED__ */ + + +#ifndef __SpNotifyTranslator_FWD_DEFINED__ +#define __SpNotifyTranslator_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpNotifyTranslator SpNotifyTranslator; +#else +typedef struct SpNotifyTranslator SpNotifyTranslator; +#endif /* __cplusplus */ + +#endif /* __SpNotifyTranslator_FWD_DEFINED__ */ + + +#ifndef __SpObjectTokenCategory_FWD_DEFINED__ +#define __SpObjectTokenCategory_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpObjectTokenCategory SpObjectTokenCategory; +#else +typedef struct SpObjectTokenCategory SpObjectTokenCategory; +#endif /* __cplusplus */ + +#endif /* __SpObjectTokenCategory_FWD_DEFINED__ */ + + +#ifndef __SpObjectToken_FWD_DEFINED__ +#define __SpObjectToken_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpObjectToken SpObjectToken; +#else +typedef struct SpObjectToken SpObjectToken; +#endif /* __cplusplus */ + +#endif /* __SpObjectToken_FWD_DEFINED__ */ + + +#ifndef __SpResourceManager_FWD_DEFINED__ +#define __SpResourceManager_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpResourceManager SpResourceManager; +#else +typedef struct SpResourceManager SpResourceManager; +#endif /* __cplusplus */ + +#endif /* __SpResourceManager_FWD_DEFINED__ */ + + +#ifndef __SpStreamFormatConverter_FWD_DEFINED__ +#define __SpStreamFormatConverter_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpStreamFormatConverter SpStreamFormatConverter; +#else +typedef struct SpStreamFormatConverter SpStreamFormatConverter; +#endif /* __cplusplus */ + +#endif /* __SpStreamFormatConverter_FWD_DEFINED__ */ + + +#ifndef __SpMMAudioEnum_FWD_DEFINED__ +#define __SpMMAudioEnum_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpMMAudioEnum SpMMAudioEnum; +#else +typedef struct SpMMAudioEnum SpMMAudioEnum; +#endif /* __cplusplus */ + +#endif /* __SpMMAudioEnum_FWD_DEFINED__ */ + + +#ifndef __SpMMAudioIn_FWD_DEFINED__ +#define __SpMMAudioIn_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpMMAudioIn SpMMAudioIn; +#else +typedef struct SpMMAudioIn SpMMAudioIn; +#endif /* __cplusplus */ + +#endif /* __SpMMAudioIn_FWD_DEFINED__ */ + + +#ifndef __SpMMAudioOut_FWD_DEFINED__ +#define __SpMMAudioOut_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpMMAudioOut SpMMAudioOut; +#else +typedef struct SpMMAudioOut SpMMAudioOut; +#endif /* __cplusplus */ + +#endif /* __SpMMAudioOut_FWD_DEFINED__ */ + + +#ifndef __SpRecPlayAudio_FWD_DEFINED__ +#define __SpRecPlayAudio_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpRecPlayAudio SpRecPlayAudio; +#else +typedef struct SpRecPlayAudio SpRecPlayAudio; +#endif /* __cplusplus */ + +#endif /* __SpRecPlayAudio_FWD_DEFINED__ */ + + +#ifndef __SpStream_FWD_DEFINED__ +#define __SpStream_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpStream SpStream; +#else +typedef struct SpStream SpStream; +#endif /* __cplusplus */ + +#endif /* __SpStream_FWD_DEFINED__ */ + + +#ifndef __SpVoice_FWD_DEFINED__ +#define __SpVoice_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpVoice SpVoice; +#else +typedef struct SpVoice SpVoice; +#endif /* __cplusplus */ + +#endif /* __SpVoice_FWD_DEFINED__ */ + + +#ifndef __SpSharedRecoContext_FWD_DEFINED__ +#define __SpSharedRecoContext_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpSharedRecoContext SpSharedRecoContext; +#else +typedef struct SpSharedRecoContext SpSharedRecoContext; +#endif /* __cplusplus */ + +#endif /* __SpSharedRecoContext_FWD_DEFINED__ */ + + +#ifndef __SpInprocRecognizer_FWD_DEFINED__ +#define __SpInprocRecognizer_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpInprocRecognizer SpInprocRecognizer; +#else +typedef struct SpInprocRecognizer SpInprocRecognizer; +#endif /* __cplusplus */ + +#endif /* __SpInprocRecognizer_FWD_DEFINED__ */ + + +#ifndef __SpSharedRecognizer_FWD_DEFINED__ +#define __SpSharedRecognizer_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpSharedRecognizer SpSharedRecognizer; +#else +typedef struct SpSharedRecognizer SpSharedRecognizer; +#endif /* __cplusplus */ + +#endif /* __SpSharedRecognizer_FWD_DEFINED__ */ + + +#ifndef __SpLexicon_FWD_DEFINED__ +#define __SpLexicon_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpLexicon SpLexicon; +#else +typedef struct SpLexicon SpLexicon; +#endif /* __cplusplus */ + +#endif /* __SpLexicon_FWD_DEFINED__ */ + + +#ifndef __SpUnCompressedLexicon_FWD_DEFINED__ +#define __SpUnCompressedLexicon_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpUnCompressedLexicon SpUnCompressedLexicon; +#else +typedef struct SpUnCompressedLexicon SpUnCompressedLexicon; +#endif /* __cplusplus */ + +#endif /* __SpUnCompressedLexicon_FWD_DEFINED__ */ + + +#ifndef __SpCompressedLexicon_FWD_DEFINED__ +#define __SpCompressedLexicon_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpCompressedLexicon SpCompressedLexicon; +#else +typedef struct SpCompressedLexicon SpCompressedLexicon; +#endif /* __cplusplus */ + +#endif /* __SpCompressedLexicon_FWD_DEFINED__ */ + + +#ifndef __SpPhoneConverter_FWD_DEFINED__ +#define __SpPhoneConverter_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpPhoneConverter SpPhoneConverter; +#else +typedef struct SpPhoneConverter SpPhoneConverter; +#endif /* __cplusplus */ + +#endif /* __SpPhoneConverter_FWD_DEFINED__ */ + + +#ifndef __SpNullPhoneConverter_FWD_DEFINED__ +#define __SpNullPhoneConverter_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpNullPhoneConverter SpNullPhoneConverter; +#else +typedef struct SpNullPhoneConverter SpNullPhoneConverter; +#endif /* __cplusplus */ + +#endif /* __SpNullPhoneConverter_FWD_DEFINED__ */ + + +#ifndef __SpTextSelectionInformation_FWD_DEFINED__ +#define __SpTextSelectionInformation_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpTextSelectionInformation SpTextSelectionInformation; +#else +typedef struct SpTextSelectionInformation SpTextSelectionInformation; +#endif /* __cplusplus */ + +#endif /* __SpTextSelectionInformation_FWD_DEFINED__ */ + + +#ifndef __SpPhraseInfoBuilder_FWD_DEFINED__ +#define __SpPhraseInfoBuilder_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpPhraseInfoBuilder SpPhraseInfoBuilder; +#else +typedef struct SpPhraseInfoBuilder SpPhraseInfoBuilder; +#endif /* __cplusplus */ + +#endif /* __SpPhraseInfoBuilder_FWD_DEFINED__ */ + + +#ifndef __SpAudioFormat_FWD_DEFINED__ +#define __SpAudioFormat_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpAudioFormat SpAudioFormat; +#else +typedef struct SpAudioFormat SpAudioFormat; +#endif /* __cplusplus */ + +#endif /* __SpAudioFormat_FWD_DEFINED__ */ + + +#ifndef __SpWaveFormatEx_FWD_DEFINED__ +#define __SpWaveFormatEx_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpWaveFormatEx SpWaveFormatEx; +#else +typedef struct SpWaveFormatEx SpWaveFormatEx; +#endif /* __cplusplus */ + +#endif /* __SpWaveFormatEx_FWD_DEFINED__ */ + + +#ifndef __SpInProcRecoContext_FWD_DEFINED__ +#define __SpInProcRecoContext_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpInProcRecoContext SpInProcRecoContext; +#else +typedef struct SpInProcRecoContext SpInProcRecoContext; +#endif /* __cplusplus */ + +#endif /* __SpInProcRecoContext_FWD_DEFINED__ */ + + +#ifndef __SpCustomStream_FWD_DEFINED__ +#define __SpCustomStream_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpCustomStream SpCustomStream; +#else +typedef struct SpCustomStream SpCustomStream; +#endif /* __cplusplus */ + +#endif /* __SpCustomStream_FWD_DEFINED__ */ + + +#ifndef __SpFileStream_FWD_DEFINED__ +#define __SpFileStream_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpFileStream SpFileStream; +#else +typedef struct SpFileStream SpFileStream; +#endif /* __cplusplus */ + +#endif /* __SpFileStream_FWD_DEFINED__ */ + + +#ifndef __SpMemoryStream_FWD_DEFINED__ +#define __SpMemoryStream_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpMemoryStream SpMemoryStream; +#else +typedef struct SpMemoryStream SpMemoryStream; +#endif /* __cplusplus */ + +#endif /* __SpMemoryStream_FWD_DEFINED__ */ + + +/* header files for imported files */ +#include "oaidl.h" +#include "ocidl.h" + +#ifdef __cplusplus +extern "C"{ +#endif + +void * __RPC_USER MIDL_user_allocate(size_t); +void __RPC_USER MIDL_user_free( void * ); + +/* interface __MIDL_itf_sapi_0000 */ +/* [local] */ + +#pragma warning(disable:4201) // Allow nameless structs/unions +#pragma comment(lib, "sapi.lib") +#if 0 +typedef /* [hidden][restricted] */ struct WAVEFORMATEX + { + WORD wFormatTag; + WORD nChannels; + DWORD nSamplesPerSec; + DWORD nAvgBytesPerSec; + WORD nBlockAlign; + WORD wBitsPerSample; + WORD cbSize; + } WAVEFORMATEX; + +#else +#include +#endif + + + + + + + + + + + + + + + + + + + + + + + + + +typedef /* [hidden] */ +enum SPDATAKEYLOCATION + { SPDKL_DefaultLocation = 0, + SPDKL_CurrentUser = 1, + SPDKL_LocalMachine = 2, + SPDKL_CurrentConfig = 5 + } SPDATAKEYLOCATION; + +#define SPDUI_EngineProperties L"EngineProperties" +#define SPDUI_AddRemoveWord L"AddRemoveWord" +#define SPDUI_UserTraining L"UserTraining" +#define SPDUI_MicTraining L"MicTraining" +#define SPDUI_RecoProfileProperties L"RecoProfileProperties" +#define SPDUI_AudioProperties L"AudioProperties" +#define SPDUI_AudioVolume L"AudioVolume" +typedef /* [hidden] */ +enum SPSTREAMFORMAT + { SPSF_Default = -1, + SPSF_NoAssignedFormat = 0, + SPSF_Text = SPSF_NoAssignedFormat + 1, + SPSF_NonStandardFormat = SPSF_Text + 1, + SPSF_ExtendedAudioFormat = SPSF_NonStandardFormat + 1, + SPSF_8kHz8BitMono = SPSF_ExtendedAudioFormat + 1, + SPSF_8kHz8BitStereo = SPSF_8kHz8BitMono + 1, + SPSF_8kHz16BitMono = SPSF_8kHz8BitStereo + 1, + SPSF_8kHz16BitStereo = SPSF_8kHz16BitMono + 1, + SPSF_11kHz8BitMono = SPSF_8kHz16BitStereo + 1, + SPSF_11kHz8BitStereo = SPSF_11kHz8BitMono + 1, + SPSF_11kHz16BitMono = SPSF_11kHz8BitStereo + 1, + SPSF_11kHz16BitStereo = SPSF_11kHz16BitMono + 1, + SPSF_12kHz8BitMono = SPSF_11kHz16BitStereo + 1, + SPSF_12kHz8BitStereo = SPSF_12kHz8BitMono + 1, + SPSF_12kHz16BitMono = SPSF_12kHz8BitStereo + 1, + SPSF_12kHz16BitStereo = SPSF_12kHz16BitMono + 1, + SPSF_16kHz8BitMono = SPSF_12kHz16BitStereo + 1, + SPSF_16kHz8BitStereo = SPSF_16kHz8BitMono + 1, + SPSF_16kHz16BitMono = SPSF_16kHz8BitStereo + 1, + SPSF_16kHz16BitStereo = SPSF_16kHz16BitMono + 1, + SPSF_22kHz8BitMono = SPSF_16kHz16BitStereo + 1, + SPSF_22kHz8BitStereo = SPSF_22kHz8BitMono + 1, + SPSF_22kHz16BitMono = SPSF_22kHz8BitStereo + 1, + SPSF_22kHz16BitStereo = SPSF_22kHz16BitMono + 1, + SPSF_24kHz8BitMono = SPSF_22kHz16BitStereo + 1, + SPSF_24kHz8BitStereo = SPSF_24kHz8BitMono + 1, + SPSF_24kHz16BitMono = SPSF_24kHz8BitStereo + 1, + SPSF_24kHz16BitStereo = SPSF_24kHz16BitMono + 1, + SPSF_32kHz8BitMono = SPSF_24kHz16BitStereo + 1, + SPSF_32kHz8BitStereo = SPSF_32kHz8BitMono + 1, + SPSF_32kHz16BitMono = SPSF_32kHz8BitStereo + 1, + SPSF_32kHz16BitStereo = SPSF_32kHz16BitMono + 1, + SPSF_44kHz8BitMono = SPSF_32kHz16BitStereo + 1, + SPSF_44kHz8BitStereo = SPSF_44kHz8BitMono + 1, + SPSF_44kHz16BitMono = SPSF_44kHz8BitStereo + 1, + SPSF_44kHz16BitStereo = SPSF_44kHz16BitMono + 1, + SPSF_48kHz8BitMono = SPSF_44kHz16BitStereo + 1, + SPSF_48kHz8BitStereo = SPSF_48kHz8BitMono + 1, + SPSF_48kHz16BitMono = SPSF_48kHz8BitStereo + 1, + SPSF_48kHz16BitStereo = SPSF_48kHz16BitMono + 1, + SPSF_TrueSpeech_8kHz1BitMono = SPSF_48kHz16BitStereo + 1, + SPSF_CCITT_ALaw_8kHzMono = SPSF_TrueSpeech_8kHz1BitMono + 1, + SPSF_CCITT_ALaw_8kHzStereo = SPSF_CCITT_ALaw_8kHzMono + 1, + SPSF_CCITT_ALaw_11kHzMono = SPSF_CCITT_ALaw_8kHzStereo + 1, + SPSF_CCITT_ALaw_11kHzStereo = SPSF_CCITT_ALaw_11kHzMono + 1, + SPSF_CCITT_ALaw_22kHzMono = SPSF_CCITT_ALaw_11kHzStereo + 1, + SPSF_CCITT_ALaw_22kHzStereo = SPSF_CCITT_ALaw_22kHzMono + 1, + SPSF_CCITT_ALaw_44kHzMono = SPSF_CCITT_ALaw_22kHzStereo + 1, + SPSF_CCITT_ALaw_44kHzStereo = SPSF_CCITT_ALaw_44kHzMono + 1, + SPSF_CCITT_uLaw_8kHzMono = SPSF_CCITT_ALaw_44kHzStereo + 1, + SPSF_CCITT_uLaw_8kHzStereo = SPSF_CCITT_uLaw_8kHzMono + 1, + SPSF_CCITT_uLaw_11kHzMono = SPSF_CCITT_uLaw_8kHzStereo + 1, + SPSF_CCITT_uLaw_11kHzStereo = SPSF_CCITT_uLaw_11kHzMono + 1, + SPSF_CCITT_uLaw_22kHzMono = SPSF_CCITT_uLaw_11kHzStereo + 1, + SPSF_CCITT_uLaw_22kHzStereo = SPSF_CCITT_uLaw_22kHzMono + 1, + SPSF_CCITT_uLaw_44kHzMono = SPSF_CCITT_uLaw_22kHzStereo + 1, + SPSF_CCITT_uLaw_44kHzStereo = SPSF_CCITT_uLaw_44kHzMono + 1, + SPSF_ADPCM_8kHzMono = SPSF_CCITT_uLaw_44kHzStereo + 1, + SPSF_ADPCM_8kHzStereo = SPSF_ADPCM_8kHzMono + 1, + SPSF_ADPCM_11kHzMono = SPSF_ADPCM_8kHzStereo + 1, + SPSF_ADPCM_11kHzStereo = SPSF_ADPCM_11kHzMono + 1, + SPSF_ADPCM_22kHzMono = SPSF_ADPCM_11kHzStereo + 1, + SPSF_ADPCM_22kHzStereo = SPSF_ADPCM_22kHzMono + 1, + SPSF_ADPCM_44kHzMono = SPSF_ADPCM_22kHzStereo + 1, + SPSF_ADPCM_44kHzStereo = SPSF_ADPCM_44kHzMono + 1, + SPSF_GSM610_8kHzMono = SPSF_ADPCM_44kHzStereo + 1, + SPSF_GSM610_11kHzMono = SPSF_GSM610_8kHzMono + 1, + SPSF_GSM610_22kHzMono = SPSF_GSM610_11kHzMono + 1, + SPSF_GSM610_44kHzMono = SPSF_GSM610_22kHzMono + 1, + SPSF_NUM_FORMATS = SPSF_GSM610_44kHzMono + 1 + } SPSTREAMFORMAT; + +EXTERN_C const GUID SPDFID_Text; +EXTERN_C const GUID SPDFID_WaveFormatEx; +#define SPREG_USER_ROOT L"HKEY_CURRENT_USER\\SOFTWARE\\Microsoft\\Speech" +#define SPREG_LOCAL_MACHINE_ROOT L"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech" +#define SPCAT_AUDIOOUT L"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\AudioOutput" +#define SPCAT_AUDIOIN L"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\AudioInput" +#define SPCAT_VOICES L"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\Voices" +#define SPCAT_RECOGNIZERS L"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\Recognizers" +#define SPCAT_APPLEXICONS L"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\AppLexicons" +#define SPCAT_PHONECONVERTERS L"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\PhoneConverters" +#define SPCAT_RECOPROFILES L"HKEY_CURRENT_USER\\SOFTWARE\\Microsoft\\Speech\\RecoProfiles" +#define SPMMSYS_AUDIO_IN_TOKEN_ID L"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\AudioInput\\TokenEnums\\MMAudioIn\\" +#define SPMMSYS_AUDIO_OUT_TOKEN_ID L"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\AudioOutput\\TokenEnums\\MMAudioOut\\" +#define SPCURRENT_USER_LEXICON_TOKEN_ID L"HKEY_CURRENT_USER\\SOFTWARE\\Microsoft\\Speech\\CurrentUserLexicon" +#define SPTOKENVALUE_CLSID L"CLSID" +#define SPTOKENKEY_FILES L"Files" +#define SPTOKENKEY_UI L"UI" +#define SPTOKENKEY_ATTRIBUTES L"Attributes" +#define SPVOICECATEGORY_TTSRATE L"DefaultTTSRate" +#define SPPROP_RESOURCE_USAGE L"ResourceUsage" +#define SPPROP_HIGH_CONFIDENCE_THRESHOLD L"HighConfidenceThreshold" +#define SPPROP_NORMAL_CONFIDENCE_THRESHOLD L"NormalConfidenceThreshold" +#define SPPROP_LOW_CONFIDENCE_THRESHOLD L"LowConfidenceThreshold" +#define SPPROP_RESPONSE_SPEED L"ResponseSpeed" +#define SPPROP_COMPLEX_RESPONSE_SPEED L"ComplexResponseSpeed" +#define SPPROP_ADAPTATION_ON L"AdaptationOn" +#define SPTOPIC_SPELLING L"Spelling" +#define SPWILDCARD L"..." +#define SPDICTATION L"*" +#define SPINFDICTATION L"*+" +#define SP_LOW_CONFIDENCE ( -1 ) + +#define SP_NORMAL_CONFIDENCE ( 0 ) + +#define SP_HIGH_CONFIDENCE ( +1 ) + +#define DEFAULT_WEIGHT ( 1 ) + +#define SP_MAX_WORD_LENGTH ( 128 ) + +#define SP_MAX_PRON_LENGTH ( 384 ) + +#if defined(__cplusplus) +interface ISpNotifyCallback +{ +virtual HRESULT STDMETHODCALLTYPE NotifyCallback( + WPARAM wParam, + LPARAM lParam) = 0; +}; +#else +typedef void *ISpNotifyCallback; + +#endif +#if 0 +typedef void *SPNOTIFYCALLBACK; + +#else +typedef void __stdcall SPNOTIFYCALLBACK(WPARAM wParam, LPARAM lParam); +#endif + + +extern RPC_IF_HANDLE __MIDL_itf_sapi_0000_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_sapi_0000_v0_0_s_ifspec; + +#ifndef __ISpNotifySource_INTERFACE_DEFINED__ +#define __ISpNotifySource_INTERFACE_DEFINED__ + +/* interface ISpNotifySource */ +/* [restricted][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpNotifySource; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("5EFF4AEF-8487-11D2-961C-00C04F8EE628") + ISpNotifySource : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetNotifySink( + /* [in] */ ISpNotifySink *pNotifySink) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE SetNotifyWindowMessage( + /* [in] */ HWND hWnd, + /* [in] */ UINT Msg, + /* [in] */ WPARAM wParam, + /* [in] */ LPARAM lParam) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE SetNotifyCallbackFunction( + /* [in] */ SPNOTIFYCALLBACK *pfnCallback, + /* [in] */ WPARAM wParam, + /* [in] */ LPARAM lParam) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE SetNotifyCallbackInterface( + /* [in] */ ISpNotifyCallback *pSpCallback, + /* [in] */ WPARAM wParam, + /* [in] */ LPARAM lParam) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE SetNotifyWin32Event( void) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE WaitForNotifyEvent( + /* [in] */ DWORD dwMilliseconds) = 0; + + virtual /* [local] */ HANDLE STDMETHODCALLTYPE GetNotifyEventHandle( void) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpNotifySourceVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpNotifySource * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpNotifySource * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpNotifySource * This); + + HRESULT ( STDMETHODCALLTYPE *SetNotifySink )( + ISpNotifySource * This, + /* [in] */ ISpNotifySink *pNotifySink); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *SetNotifyWindowMessage )( + ISpNotifySource * This, + /* [in] */ HWND hWnd, + /* [in] */ UINT Msg, + /* [in] */ WPARAM wParam, + /* [in] */ LPARAM lParam); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *SetNotifyCallbackFunction )( + ISpNotifySource * This, + /* [in] */ SPNOTIFYCALLBACK *pfnCallback, + /* [in] */ WPARAM wParam, + /* [in] */ LPARAM lParam); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *SetNotifyCallbackInterface )( + ISpNotifySource * This, + /* [in] */ ISpNotifyCallback *pSpCallback, + /* [in] */ WPARAM wParam, + /* [in] */ LPARAM lParam); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *SetNotifyWin32Event )( + ISpNotifySource * This); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *WaitForNotifyEvent )( + ISpNotifySource * This, + /* [in] */ DWORD dwMilliseconds); + + /* [local] */ HANDLE ( STDMETHODCALLTYPE *GetNotifyEventHandle )( + ISpNotifySource * This); + + END_INTERFACE + } ISpNotifySourceVtbl; + + interface ISpNotifySource + { + CONST_VTBL struct ISpNotifySourceVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpNotifySource_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpNotifySource_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpNotifySource_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpNotifySource_SetNotifySink(This,pNotifySink) \ + (This)->lpVtbl -> SetNotifySink(This,pNotifySink) + +#define ISpNotifySource_SetNotifyWindowMessage(This,hWnd,Msg,wParam,lParam) \ + (This)->lpVtbl -> SetNotifyWindowMessage(This,hWnd,Msg,wParam,lParam) + +#define ISpNotifySource_SetNotifyCallbackFunction(This,pfnCallback,wParam,lParam) \ + (This)->lpVtbl -> SetNotifyCallbackFunction(This,pfnCallback,wParam,lParam) + +#define ISpNotifySource_SetNotifyCallbackInterface(This,pSpCallback,wParam,lParam) \ + (This)->lpVtbl -> SetNotifyCallbackInterface(This,pSpCallback,wParam,lParam) + +#define ISpNotifySource_SetNotifyWin32Event(This) \ + (This)->lpVtbl -> SetNotifyWin32Event(This) + +#define ISpNotifySource_WaitForNotifyEvent(This,dwMilliseconds) \ + (This)->lpVtbl -> WaitForNotifyEvent(This,dwMilliseconds) + +#define ISpNotifySource_GetNotifyEventHandle(This) \ + (This)->lpVtbl -> GetNotifyEventHandle(This) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpNotifySource_SetNotifySink_Proxy( + ISpNotifySource * This, + /* [in] */ ISpNotifySink *pNotifySink); + + +void __RPC_STUB ISpNotifySource_SetNotifySink_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [local] */ HRESULT STDMETHODCALLTYPE ISpNotifySource_SetNotifyWindowMessage_Proxy( + ISpNotifySource * This, + /* [in] */ HWND hWnd, + /* [in] */ UINT Msg, + /* [in] */ WPARAM wParam, + /* [in] */ LPARAM lParam); + + +void __RPC_STUB ISpNotifySource_SetNotifyWindowMessage_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [local] */ HRESULT STDMETHODCALLTYPE ISpNotifySource_SetNotifyCallbackFunction_Proxy( + ISpNotifySource * This, + /* [in] */ SPNOTIFYCALLBACK *pfnCallback, + /* [in] */ WPARAM wParam, + /* [in] */ LPARAM lParam); + + +void __RPC_STUB ISpNotifySource_SetNotifyCallbackFunction_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [local] */ HRESULT STDMETHODCALLTYPE ISpNotifySource_SetNotifyCallbackInterface_Proxy( + ISpNotifySource * This, + /* [in] */ ISpNotifyCallback *pSpCallback, + /* [in] */ WPARAM wParam, + /* [in] */ LPARAM lParam); + + +void __RPC_STUB ISpNotifySource_SetNotifyCallbackInterface_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [local] */ HRESULT STDMETHODCALLTYPE ISpNotifySource_SetNotifyWin32Event_Proxy( + ISpNotifySource * This); + + +void __RPC_STUB ISpNotifySource_SetNotifyWin32Event_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [local] */ HRESULT STDMETHODCALLTYPE ISpNotifySource_WaitForNotifyEvent_Proxy( + ISpNotifySource * This, + /* [in] */ DWORD dwMilliseconds); + + +void __RPC_STUB ISpNotifySource_WaitForNotifyEvent_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [local] */ HANDLE STDMETHODCALLTYPE ISpNotifySource_GetNotifyEventHandle_Proxy( + ISpNotifySource * This); + + +void __RPC_STUB ISpNotifySource_GetNotifyEventHandle_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpNotifySource_INTERFACE_DEFINED__ */ + + +#ifndef __ISpNotifySink_INTERFACE_DEFINED__ +#define __ISpNotifySink_INTERFACE_DEFINED__ + +/* interface ISpNotifySink */ +/* [restricted][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpNotifySink; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("259684DC-37C3-11D2-9603-00C04F8EE628") + ISpNotifySink : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Notify( void) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpNotifySinkVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpNotifySink * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpNotifySink * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpNotifySink * This); + + HRESULT ( STDMETHODCALLTYPE *Notify )( + ISpNotifySink * This); + + END_INTERFACE + } ISpNotifySinkVtbl; + + interface ISpNotifySink + { + CONST_VTBL struct ISpNotifySinkVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpNotifySink_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpNotifySink_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpNotifySink_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpNotifySink_Notify(This) \ + (This)->lpVtbl -> Notify(This) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpNotifySink_Notify_Proxy( + ISpNotifySink * This); + + +void __RPC_STUB ISpNotifySink_Notify_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpNotifySink_INTERFACE_DEFINED__ */ + + +#ifndef __ISpNotifyTranslator_INTERFACE_DEFINED__ +#define __ISpNotifyTranslator_INTERFACE_DEFINED__ + +/* interface ISpNotifyTranslator */ +/* [restricted][local][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpNotifyTranslator; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("ACA16614-5D3D-11D2-960E-00C04F8EE628") + ISpNotifyTranslator : public ISpNotifySink + { + public: + virtual HRESULT STDMETHODCALLTYPE InitWindowMessage( + /* [in] */ HWND hWnd, + /* [in] */ UINT Msg, + /* [in] */ WPARAM wParam, + /* [in] */ LPARAM lParam) = 0; + + virtual HRESULT STDMETHODCALLTYPE InitCallback( + /* [in] */ SPNOTIFYCALLBACK *pfnCallback, + /* [in] */ WPARAM wParam, + /* [in] */ LPARAM lParam) = 0; + + virtual HRESULT STDMETHODCALLTYPE InitSpNotifyCallback( + /* [in] */ ISpNotifyCallback *pSpCallback, + /* [in] */ WPARAM wParam, + /* [in] */ LPARAM lParam) = 0; + + virtual HRESULT STDMETHODCALLTYPE InitWin32Event( + HANDLE hEvent, + BOOL fCloseHandleOnRelease) = 0; + + virtual HRESULT STDMETHODCALLTYPE Wait( + /* [in] */ DWORD dwMilliseconds) = 0; + + virtual HANDLE STDMETHODCALLTYPE GetEventHandle( void) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpNotifyTranslatorVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpNotifyTranslator * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpNotifyTranslator * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpNotifyTranslator * This); + + HRESULT ( STDMETHODCALLTYPE *Notify )( + ISpNotifyTranslator * This); + + HRESULT ( STDMETHODCALLTYPE *InitWindowMessage )( + ISpNotifyTranslator * This, + /* [in] */ HWND hWnd, + /* [in] */ UINT Msg, + /* [in] */ WPARAM wParam, + /* [in] */ LPARAM lParam); + + HRESULT ( STDMETHODCALLTYPE *InitCallback )( + ISpNotifyTranslator * This, + /* [in] */ SPNOTIFYCALLBACK *pfnCallback, + /* [in] */ WPARAM wParam, + /* [in] */ LPARAM lParam); + + HRESULT ( STDMETHODCALLTYPE *InitSpNotifyCallback )( + ISpNotifyTranslator * This, + /* [in] */ ISpNotifyCallback *pSpCallback, + /* [in] */ WPARAM wParam, + /* [in] */ LPARAM lParam); + + HRESULT ( STDMETHODCALLTYPE *InitWin32Event )( + ISpNotifyTranslator * This, + HANDLE hEvent, + BOOL fCloseHandleOnRelease); + + HRESULT ( STDMETHODCALLTYPE *Wait )( + ISpNotifyTranslator * This, + /* [in] */ DWORD dwMilliseconds); + + HANDLE ( STDMETHODCALLTYPE *GetEventHandle )( + ISpNotifyTranslator * This); + + END_INTERFACE + } ISpNotifyTranslatorVtbl; + + interface ISpNotifyTranslator + { + CONST_VTBL struct ISpNotifyTranslatorVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpNotifyTranslator_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpNotifyTranslator_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpNotifyTranslator_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpNotifyTranslator_Notify(This) \ + (This)->lpVtbl -> Notify(This) + + +#define ISpNotifyTranslator_InitWindowMessage(This,hWnd,Msg,wParam,lParam) \ + (This)->lpVtbl -> InitWindowMessage(This,hWnd,Msg,wParam,lParam) + +#define ISpNotifyTranslator_InitCallback(This,pfnCallback,wParam,lParam) \ + (This)->lpVtbl -> InitCallback(This,pfnCallback,wParam,lParam) + +#define ISpNotifyTranslator_InitSpNotifyCallback(This,pSpCallback,wParam,lParam) \ + (This)->lpVtbl -> InitSpNotifyCallback(This,pSpCallback,wParam,lParam) + +#define ISpNotifyTranslator_InitWin32Event(This,hEvent,fCloseHandleOnRelease) \ + (This)->lpVtbl -> InitWin32Event(This,hEvent,fCloseHandleOnRelease) + +#define ISpNotifyTranslator_Wait(This,dwMilliseconds) \ + (This)->lpVtbl -> Wait(This,dwMilliseconds) + +#define ISpNotifyTranslator_GetEventHandle(This) \ + (This)->lpVtbl -> GetEventHandle(This) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpNotifyTranslator_InitWindowMessage_Proxy( + ISpNotifyTranslator * This, + /* [in] */ HWND hWnd, + /* [in] */ UINT Msg, + /* [in] */ WPARAM wParam, + /* [in] */ LPARAM lParam); + + +void __RPC_STUB ISpNotifyTranslator_InitWindowMessage_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpNotifyTranslator_InitCallback_Proxy( + ISpNotifyTranslator * This, + /* [in] */ SPNOTIFYCALLBACK *pfnCallback, + /* [in] */ WPARAM wParam, + /* [in] */ LPARAM lParam); + + +void __RPC_STUB ISpNotifyTranslator_InitCallback_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpNotifyTranslator_InitSpNotifyCallback_Proxy( + ISpNotifyTranslator * This, + /* [in] */ ISpNotifyCallback *pSpCallback, + /* [in] */ WPARAM wParam, + /* [in] */ LPARAM lParam); + + +void __RPC_STUB ISpNotifyTranslator_InitSpNotifyCallback_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpNotifyTranslator_InitWin32Event_Proxy( + ISpNotifyTranslator * This, + HANDLE hEvent, + BOOL fCloseHandleOnRelease); + + +void __RPC_STUB ISpNotifyTranslator_InitWin32Event_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpNotifyTranslator_Wait_Proxy( + ISpNotifyTranslator * This, + /* [in] */ DWORD dwMilliseconds); + + +void __RPC_STUB ISpNotifyTranslator_Wait_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HANDLE STDMETHODCALLTYPE ISpNotifyTranslator_GetEventHandle_Proxy( + ISpNotifyTranslator * This); + + +void __RPC_STUB ISpNotifyTranslator_GetEventHandle_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpNotifyTranslator_INTERFACE_DEFINED__ */ + + +#ifndef __ISpDataKey_INTERFACE_DEFINED__ +#define __ISpDataKey_INTERFACE_DEFINED__ + +/* interface ISpDataKey */ +/* [restricted][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpDataKey; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("14056581-E16C-11D2-BB90-00C04F8EE6C0") + ISpDataKey : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetData( + const WCHAR *pszValueName, + ULONG cbData, + const BYTE *pData) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetData( + const WCHAR *pszValueName, + ULONG *pcbData, + BYTE *pData) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetStringValue( + const WCHAR *pszValueName, + const WCHAR *pszValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStringValue( + const WCHAR *pszValueName, + WCHAR **ppszValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetDWORD( + const WCHAR *pszValueName, + DWORD dwValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDWORD( + const WCHAR *pszValueName, + DWORD *pdwValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE OpenKey( + const WCHAR *pszSubKeyName, + ISpDataKey **ppSubKey) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateKey( + const WCHAR *pszSubKey, + ISpDataKey **ppSubKey) = 0; + + virtual HRESULT STDMETHODCALLTYPE DeleteKey( + const WCHAR *pszSubKey) = 0; + + virtual HRESULT STDMETHODCALLTYPE DeleteValue( + const WCHAR *pszValueName) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnumKeys( + ULONG Index, + WCHAR **ppszSubKeyName) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnumValues( + ULONG Index, + WCHAR **ppszValueName) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpDataKeyVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpDataKey * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpDataKey * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpDataKey * This); + + HRESULT ( STDMETHODCALLTYPE *SetData )( + ISpDataKey * This, + const WCHAR *pszValueName, + ULONG cbData, + const BYTE *pData); + + HRESULT ( STDMETHODCALLTYPE *GetData )( + ISpDataKey * This, + const WCHAR *pszValueName, + ULONG *pcbData, + BYTE *pData); + + HRESULT ( STDMETHODCALLTYPE *SetStringValue )( + ISpDataKey * This, + const WCHAR *pszValueName, + const WCHAR *pszValue); + + HRESULT ( STDMETHODCALLTYPE *GetStringValue )( + ISpDataKey * This, + const WCHAR *pszValueName, + WCHAR **ppszValue); + + HRESULT ( STDMETHODCALLTYPE *SetDWORD )( + ISpDataKey * This, + const WCHAR *pszValueName, + DWORD dwValue); + + HRESULT ( STDMETHODCALLTYPE *GetDWORD )( + ISpDataKey * This, + const WCHAR *pszValueName, + DWORD *pdwValue); + + HRESULT ( STDMETHODCALLTYPE *OpenKey )( + ISpDataKey * This, + const WCHAR *pszSubKeyName, + ISpDataKey **ppSubKey); + + HRESULT ( STDMETHODCALLTYPE *CreateKey )( + ISpDataKey * This, + const WCHAR *pszSubKey, + ISpDataKey **ppSubKey); + + HRESULT ( STDMETHODCALLTYPE *DeleteKey )( + ISpDataKey * This, + const WCHAR *pszSubKey); + + HRESULT ( STDMETHODCALLTYPE *DeleteValue )( + ISpDataKey * This, + const WCHAR *pszValueName); + + HRESULT ( STDMETHODCALLTYPE *EnumKeys )( + ISpDataKey * This, + ULONG Index, + WCHAR **ppszSubKeyName); + + HRESULT ( STDMETHODCALLTYPE *EnumValues )( + ISpDataKey * This, + ULONG Index, + WCHAR **ppszValueName); + + END_INTERFACE + } ISpDataKeyVtbl; + + interface ISpDataKey + { + CONST_VTBL struct ISpDataKeyVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpDataKey_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpDataKey_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpDataKey_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpDataKey_SetData(This,pszValueName,cbData,pData) \ + (This)->lpVtbl -> SetData(This,pszValueName,cbData,pData) + +#define ISpDataKey_GetData(This,pszValueName,pcbData,pData) \ + (This)->lpVtbl -> GetData(This,pszValueName,pcbData,pData) + +#define ISpDataKey_SetStringValue(This,pszValueName,pszValue) \ + (This)->lpVtbl -> SetStringValue(This,pszValueName,pszValue) + +#define ISpDataKey_GetStringValue(This,pszValueName,ppszValue) \ + (This)->lpVtbl -> GetStringValue(This,pszValueName,ppszValue) + +#define ISpDataKey_SetDWORD(This,pszValueName,dwValue) \ + (This)->lpVtbl -> SetDWORD(This,pszValueName,dwValue) + +#define ISpDataKey_GetDWORD(This,pszValueName,pdwValue) \ + (This)->lpVtbl -> GetDWORD(This,pszValueName,pdwValue) + +#define ISpDataKey_OpenKey(This,pszSubKeyName,ppSubKey) \ + (This)->lpVtbl -> OpenKey(This,pszSubKeyName,ppSubKey) + +#define ISpDataKey_CreateKey(This,pszSubKey,ppSubKey) \ + (This)->lpVtbl -> CreateKey(This,pszSubKey,ppSubKey) + +#define ISpDataKey_DeleteKey(This,pszSubKey) \ + (This)->lpVtbl -> DeleteKey(This,pszSubKey) + +#define ISpDataKey_DeleteValue(This,pszValueName) \ + (This)->lpVtbl -> DeleteValue(This,pszValueName) + +#define ISpDataKey_EnumKeys(This,Index,ppszSubKeyName) \ + (This)->lpVtbl -> EnumKeys(This,Index,ppszSubKeyName) + +#define ISpDataKey_EnumValues(This,Index,ppszValueName) \ + (This)->lpVtbl -> EnumValues(This,Index,ppszValueName) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpDataKey_SetData_Proxy( + ISpDataKey * This, + const WCHAR *pszValueName, + ULONG cbData, + const BYTE *pData); + + +void __RPC_STUB ISpDataKey_SetData_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpDataKey_GetData_Proxy( + ISpDataKey * This, + const WCHAR *pszValueName, + ULONG *pcbData, + BYTE *pData); + + +void __RPC_STUB ISpDataKey_GetData_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpDataKey_SetStringValue_Proxy( + ISpDataKey * This, + const WCHAR *pszValueName, + const WCHAR *pszValue); + + +void __RPC_STUB ISpDataKey_SetStringValue_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpDataKey_GetStringValue_Proxy( + ISpDataKey * This, + const WCHAR *pszValueName, + WCHAR **ppszValue); + + +void __RPC_STUB ISpDataKey_GetStringValue_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpDataKey_SetDWORD_Proxy( + ISpDataKey * This, + const WCHAR *pszValueName, + DWORD dwValue); + + +void __RPC_STUB ISpDataKey_SetDWORD_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpDataKey_GetDWORD_Proxy( + ISpDataKey * This, + const WCHAR *pszValueName, + DWORD *pdwValue); + + +void __RPC_STUB ISpDataKey_GetDWORD_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpDataKey_OpenKey_Proxy( + ISpDataKey * This, + const WCHAR *pszSubKeyName, + ISpDataKey **ppSubKey); + + +void __RPC_STUB ISpDataKey_OpenKey_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpDataKey_CreateKey_Proxy( + ISpDataKey * This, + const WCHAR *pszSubKey, + ISpDataKey **ppSubKey); + + +void __RPC_STUB ISpDataKey_CreateKey_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpDataKey_DeleteKey_Proxy( + ISpDataKey * This, + const WCHAR *pszSubKey); + + +void __RPC_STUB ISpDataKey_DeleteKey_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpDataKey_DeleteValue_Proxy( + ISpDataKey * This, + const WCHAR *pszValueName); + + +void __RPC_STUB ISpDataKey_DeleteValue_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpDataKey_EnumKeys_Proxy( + ISpDataKey * This, + ULONG Index, + WCHAR **ppszSubKeyName); + + +void __RPC_STUB ISpDataKey_EnumKeys_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpDataKey_EnumValues_Proxy( + ISpDataKey * This, + ULONG Index, + WCHAR **ppszValueName); + + +void __RPC_STUB ISpDataKey_EnumValues_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpDataKey_INTERFACE_DEFINED__ */ + + +#ifndef __ISpRegDataKey_INTERFACE_DEFINED__ +#define __ISpRegDataKey_INTERFACE_DEFINED__ + +/* interface ISpRegDataKey */ +/* [restricted][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpRegDataKey; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("92A66E2B-C830-4149-83DF-6FC2BA1E7A5B") + ISpRegDataKey : public ISpDataKey + { + public: + virtual /* [local] */ HRESULT STDMETHODCALLTYPE SetKey( + /* [in] */ HKEY hkey, + /* [in] */ BOOL fReadOnly) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpRegDataKeyVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpRegDataKey * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpRegDataKey * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpRegDataKey * This); + + HRESULT ( STDMETHODCALLTYPE *SetData )( + ISpRegDataKey * This, + const WCHAR *pszValueName, + ULONG cbData, + const BYTE *pData); + + HRESULT ( STDMETHODCALLTYPE *GetData )( + ISpRegDataKey * This, + const WCHAR *pszValueName, + ULONG *pcbData, + BYTE *pData); + + HRESULT ( STDMETHODCALLTYPE *SetStringValue )( + ISpRegDataKey * This, + const WCHAR *pszValueName, + const WCHAR *pszValue); + + HRESULT ( STDMETHODCALLTYPE *GetStringValue )( + ISpRegDataKey * This, + const WCHAR *pszValueName, + WCHAR **ppszValue); + + HRESULT ( STDMETHODCALLTYPE *SetDWORD )( + ISpRegDataKey * This, + const WCHAR *pszValueName, + DWORD dwValue); + + HRESULT ( STDMETHODCALLTYPE *GetDWORD )( + ISpRegDataKey * This, + const WCHAR *pszValueName, + DWORD *pdwValue); + + HRESULT ( STDMETHODCALLTYPE *OpenKey )( + ISpRegDataKey * This, + const WCHAR *pszSubKeyName, + ISpDataKey **ppSubKey); + + HRESULT ( STDMETHODCALLTYPE *CreateKey )( + ISpRegDataKey * This, + const WCHAR *pszSubKey, + ISpDataKey **ppSubKey); + + HRESULT ( STDMETHODCALLTYPE *DeleteKey )( + ISpRegDataKey * This, + const WCHAR *pszSubKey); + + HRESULT ( STDMETHODCALLTYPE *DeleteValue )( + ISpRegDataKey * This, + const WCHAR *pszValueName); + + HRESULT ( STDMETHODCALLTYPE *EnumKeys )( + ISpRegDataKey * This, + ULONG Index, + WCHAR **ppszSubKeyName); + + HRESULT ( STDMETHODCALLTYPE *EnumValues )( + ISpRegDataKey * This, + ULONG Index, + WCHAR **ppszValueName); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *SetKey )( + ISpRegDataKey * This, + /* [in] */ HKEY hkey, + /* [in] */ BOOL fReadOnly); + + END_INTERFACE + } ISpRegDataKeyVtbl; + + interface ISpRegDataKey + { + CONST_VTBL struct ISpRegDataKeyVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpRegDataKey_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpRegDataKey_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpRegDataKey_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpRegDataKey_SetData(This,pszValueName,cbData,pData) \ + (This)->lpVtbl -> SetData(This,pszValueName,cbData,pData) + +#define ISpRegDataKey_GetData(This,pszValueName,pcbData,pData) \ + (This)->lpVtbl -> GetData(This,pszValueName,pcbData,pData) + +#define ISpRegDataKey_SetStringValue(This,pszValueName,pszValue) \ + (This)->lpVtbl -> SetStringValue(This,pszValueName,pszValue) + +#define ISpRegDataKey_GetStringValue(This,pszValueName,ppszValue) \ + (This)->lpVtbl -> GetStringValue(This,pszValueName,ppszValue) + +#define ISpRegDataKey_SetDWORD(This,pszValueName,dwValue) \ + (This)->lpVtbl -> SetDWORD(This,pszValueName,dwValue) + +#define ISpRegDataKey_GetDWORD(This,pszValueName,pdwValue) \ + (This)->lpVtbl -> GetDWORD(This,pszValueName,pdwValue) + +#define ISpRegDataKey_OpenKey(This,pszSubKeyName,ppSubKey) \ + (This)->lpVtbl -> OpenKey(This,pszSubKeyName,ppSubKey) + +#define ISpRegDataKey_CreateKey(This,pszSubKey,ppSubKey) \ + (This)->lpVtbl -> CreateKey(This,pszSubKey,ppSubKey) + +#define ISpRegDataKey_DeleteKey(This,pszSubKey) \ + (This)->lpVtbl -> DeleteKey(This,pszSubKey) + +#define ISpRegDataKey_DeleteValue(This,pszValueName) \ + (This)->lpVtbl -> DeleteValue(This,pszValueName) + +#define ISpRegDataKey_EnumKeys(This,Index,ppszSubKeyName) \ + (This)->lpVtbl -> EnumKeys(This,Index,ppszSubKeyName) + +#define ISpRegDataKey_EnumValues(This,Index,ppszValueName) \ + (This)->lpVtbl -> EnumValues(This,Index,ppszValueName) + + +#define ISpRegDataKey_SetKey(This,hkey,fReadOnly) \ + (This)->lpVtbl -> SetKey(This,hkey,fReadOnly) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [local] */ HRESULT STDMETHODCALLTYPE ISpRegDataKey_SetKey_Proxy( + ISpRegDataKey * This, + /* [in] */ HKEY hkey, + /* [in] */ BOOL fReadOnly); + + +void __RPC_STUB ISpRegDataKey_SetKey_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpRegDataKey_INTERFACE_DEFINED__ */ + + +#ifndef __ISpObjectTokenCategory_INTERFACE_DEFINED__ +#define __ISpObjectTokenCategory_INTERFACE_DEFINED__ + +/* interface ISpObjectTokenCategory */ +/* [restricted][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpObjectTokenCategory; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("2D3D3845-39AF-4850-BBF9-40B49780011D") + ISpObjectTokenCategory : public ISpDataKey + { + public: + virtual HRESULT STDMETHODCALLTYPE SetId( + /* [in] */ const WCHAR *pszCategoryId, + BOOL fCreateIfNotExist) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetId( + /* [out] */ WCHAR **ppszCoMemCategoryId) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDataKey( + SPDATAKEYLOCATION spdkl, + ISpDataKey **ppDataKey) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnumTokens( + /* [string][in] */ const WCHAR *pzsReqAttribs, + /* [string][in] */ const WCHAR *pszOptAttribs, + /* [out] */ IEnumSpObjectTokens **ppEnum) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetDefaultTokenId( + /* [in] */ const WCHAR *pszTokenId) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDefaultTokenId( + /* [out] */ WCHAR **ppszCoMemTokenId) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpObjectTokenCategoryVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpObjectTokenCategory * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpObjectTokenCategory * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpObjectTokenCategory * This); + + HRESULT ( STDMETHODCALLTYPE *SetData )( + ISpObjectTokenCategory * This, + const WCHAR *pszValueName, + ULONG cbData, + const BYTE *pData); + + HRESULT ( STDMETHODCALLTYPE *GetData )( + ISpObjectTokenCategory * This, + const WCHAR *pszValueName, + ULONG *pcbData, + BYTE *pData); + + HRESULT ( STDMETHODCALLTYPE *SetStringValue )( + ISpObjectTokenCategory * This, + const WCHAR *pszValueName, + const WCHAR *pszValue); + + HRESULT ( STDMETHODCALLTYPE *GetStringValue )( + ISpObjectTokenCategory * This, + const WCHAR *pszValueName, + WCHAR **ppszValue); + + HRESULT ( STDMETHODCALLTYPE *SetDWORD )( + ISpObjectTokenCategory * This, + const WCHAR *pszValueName, + DWORD dwValue); + + HRESULT ( STDMETHODCALLTYPE *GetDWORD )( + ISpObjectTokenCategory * This, + const WCHAR *pszValueName, + DWORD *pdwValue); + + HRESULT ( STDMETHODCALLTYPE *OpenKey )( + ISpObjectTokenCategory * This, + const WCHAR *pszSubKeyName, + ISpDataKey **ppSubKey); + + HRESULT ( STDMETHODCALLTYPE *CreateKey )( + ISpObjectTokenCategory * This, + const WCHAR *pszSubKey, + ISpDataKey **ppSubKey); + + HRESULT ( STDMETHODCALLTYPE *DeleteKey )( + ISpObjectTokenCategory * This, + const WCHAR *pszSubKey); + + HRESULT ( STDMETHODCALLTYPE *DeleteValue )( + ISpObjectTokenCategory * This, + const WCHAR *pszValueName); + + HRESULT ( STDMETHODCALLTYPE *EnumKeys )( + ISpObjectTokenCategory * This, + ULONG Index, + WCHAR **ppszSubKeyName); + + HRESULT ( STDMETHODCALLTYPE *EnumValues )( + ISpObjectTokenCategory * This, + ULONG Index, + WCHAR **ppszValueName); + + HRESULT ( STDMETHODCALLTYPE *SetId )( + ISpObjectTokenCategory * This, + /* [in] */ const WCHAR *pszCategoryId, + BOOL fCreateIfNotExist); + + HRESULT ( STDMETHODCALLTYPE *GetId )( + ISpObjectTokenCategory * This, + /* [out] */ WCHAR **ppszCoMemCategoryId); + + HRESULT ( STDMETHODCALLTYPE *GetDataKey )( + ISpObjectTokenCategory * This, + SPDATAKEYLOCATION spdkl, + ISpDataKey **ppDataKey); + + HRESULT ( STDMETHODCALLTYPE *EnumTokens )( + ISpObjectTokenCategory * This, + /* [string][in] */ const WCHAR *pzsReqAttribs, + /* [string][in] */ const WCHAR *pszOptAttribs, + /* [out] */ IEnumSpObjectTokens **ppEnum); + + HRESULT ( STDMETHODCALLTYPE *SetDefaultTokenId )( + ISpObjectTokenCategory * This, + /* [in] */ const WCHAR *pszTokenId); + + HRESULT ( STDMETHODCALLTYPE *GetDefaultTokenId )( + ISpObjectTokenCategory * This, + /* [out] */ WCHAR **ppszCoMemTokenId); + + END_INTERFACE + } ISpObjectTokenCategoryVtbl; + + interface ISpObjectTokenCategory + { + CONST_VTBL struct ISpObjectTokenCategoryVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpObjectTokenCategory_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpObjectTokenCategory_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpObjectTokenCategory_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpObjectTokenCategory_SetData(This,pszValueName,cbData,pData) \ + (This)->lpVtbl -> SetData(This,pszValueName,cbData,pData) + +#define ISpObjectTokenCategory_GetData(This,pszValueName,pcbData,pData) \ + (This)->lpVtbl -> GetData(This,pszValueName,pcbData,pData) + +#define ISpObjectTokenCategory_SetStringValue(This,pszValueName,pszValue) \ + (This)->lpVtbl -> SetStringValue(This,pszValueName,pszValue) + +#define ISpObjectTokenCategory_GetStringValue(This,pszValueName,ppszValue) \ + (This)->lpVtbl -> GetStringValue(This,pszValueName,ppszValue) + +#define ISpObjectTokenCategory_SetDWORD(This,pszValueName,dwValue) \ + (This)->lpVtbl -> SetDWORD(This,pszValueName,dwValue) + +#define ISpObjectTokenCategory_GetDWORD(This,pszValueName,pdwValue) \ + (This)->lpVtbl -> GetDWORD(This,pszValueName,pdwValue) + +#define ISpObjectTokenCategory_OpenKey(This,pszSubKeyName,ppSubKey) \ + (This)->lpVtbl -> OpenKey(This,pszSubKeyName,ppSubKey) + +#define ISpObjectTokenCategory_CreateKey(This,pszSubKey,ppSubKey) \ + (This)->lpVtbl -> CreateKey(This,pszSubKey,ppSubKey) + +#define ISpObjectTokenCategory_DeleteKey(This,pszSubKey) \ + (This)->lpVtbl -> DeleteKey(This,pszSubKey) + +#define ISpObjectTokenCategory_DeleteValue(This,pszValueName) \ + (This)->lpVtbl -> DeleteValue(This,pszValueName) + +#define ISpObjectTokenCategory_EnumKeys(This,Index,ppszSubKeyName) \ + (This)->lpVtbl -> EnumKeys(This,Index,ppszSubKeyName) + +#define ISpObjectTokenCategory_EnumValues(This,Index,ppszValueName) \ + (This)->lpVtbl -> EnumValues(This,Index,ppszValueName) + + +#define ISpObjectTokenCategory_SetId(This,pszCategoryId,fCreateIfNotExist) \ + (This)->lpVtbl -> SetId(This,pszCategoryId,fCreateIfNotExist) + +#define ISpObjectTokenCategory_GetId(This,ppszCoMemCategoryId) \ + (This)->lpVtbl -> GetId(This,ppszCoMemCategoryId) + +#define ISpObjectTokenCategory_GetDataKey(This,spdkl,ppDataKey) \ + (This)->lpVtbl -> GetDataKey(This,spdkl,ppDataKey) + +#define ISpObjectTokenCategory_EnumTokens(This,pzsReqAttribs,pszOptAttribs,ppEnum) \ + (This)->lpVtbl -> EnumTokens(This,pzsReqAttribs,pszOptAttribs,ppEnum) + +#define ISpObjectTokenCategory_SetDefaultTokenId(This,pszTokenId) \ + (This)->lpVtbl -> SetDefaultTokenId(This,pszTokenId) + +#define ISpObjectTokenCategory_GetDefaultTokenId(This,ppszCoMemTokenId) \ + (This)->lpVtbl -> GetDefaultTokenId(This,ppszCoMemTokenId) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpObjectTokenCategory_SetId_Proxy( + ISpObjectTokenCategory * This, + /* [in] */ const WCHAR *pszCategoryId, + BOOL fCreateIfNotExist); + + +void __RPC_STUB ISpObjectTokenCategory_SetId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpObjectTokenCategory_GetId_Proxy( + ISpObjectTokenCategory * This, + /* [out] */ WCHAR **ppszCoMemCategoryId); + + +void __RPC_STUB ISpObjectTokenCategory_GetId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpObjectTokenCategory_GetDataKey_Proxy( + ISpObjectTokenCategory * This, + SPDATAKEYLOCATION spdkl, + ISpDataKey **ppDataKey); + + +void __RPC_STUB ISpObjectTokenCategory_GetDataKey_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpObjectTokenCategory_EnumTokens_Proxy( + ISpObjectTokenCategory * This, + /* [string][in] */ const WCHAR *pzsReqAttribs, + /* [string][in] */ const WCHAR *pszOptAttribs, + /* [out] */ IEnumSpObjectTokens **ppEnum); + + +void __RPC_STUB ISpObjectTokenCategory_EnumTokens_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpObjectTokenCategory_SetDefaultTokenId_Proxy( + ISpObjectTokenCategory * This, + /* [in] */ const WCHAR *pszTokenId); + + +void __RPC_STUB ISpObjectTokenCategory_SetDefaultTokenId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpObjectTokenCategory_GetDefaultTokenId_Proxy( + ISpObjectTokenCategory * This, + /* [out] */ WCHAR **ppszCoMemTokenId); + + +void __RPC_STUB ISpObjectTokenCategory_GetDefaultTokenId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpObjectTokenCategory_INTERFACE_DEFINED__ */ + + +#ifndef __ISpObjectToken_INTERFACE_DEFINED__ +#define __ISpObjectToken_INTERFACE_DEFINED__ + +/* interface ISpObjectToken */ +/* [restricted][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpObjectToken; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("14056589-E16C-11D2-BB90-00C04F8EE6C0") + ISpObjectToken : public ISpDataKey + { + public: + virtual HRESULT STDMETHODCALLTYPE SetId( + const WCHAR *pszCategoryId, + const WCHAR *pszTokenId, + BOOL fCreateIfNotExist) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetId( + WCHAR **ppszCoMemTokenId) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCategory( + ISpObjectTokenCategory **ppTokenCategory) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateInstance( + /* [in] */ IUnknown *pUnkOuter, + /* [in] */ DWORD dwClsContext, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStorageFileName( + /* [in] */ REFCLSID clsidCaller, + /* [in] */ const WCHAR *pszValueName, + /* [in] */ const WCHAR *pszFileNameSpecifier, + /* [in] */ ULONG nFolder, + /* [out] */ WCHAR **ppszFilePath) = 0; + + virtual HRESULT STDMETHODCALLTYPE RemoveStorageFileName( + /* [in] */ REFCLSID clsidCaller, + /* [in] */ const WCHAR *pszKeyName, + /* [in] */ BOOL fDeleteFile) = 0; + + virtual HRESULT STDMETHODCALLTYPE Remove( + const CLSID *pclsidCaller) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE IsUISupported( + /* [in] */ const WCHAR *pszTypeOfUI, + /* [in] */ void *pvExtraData, + /* [in] */ ULONG cbExtraData, + /* [in] */ IUnknown *punkObject, + /* [out] */ BOOL *pfSupported) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE DisplayUI( + /* [in] */ HWND hwndParent, + /* [in] */ const WCHAR *pszTitle, + /* [in] */ const WCHAR *pszTypeOfUI, + /* [in] */ void *pvExtraData, + /* [in] */ ULONG cbExtraData, + /* [in] */ IUnknown *punkObject) = 0; + + virtual HRESULT STDMETHODCALLTYPE MatchesAttributes( + /* [in] */ const WCHAR *pszAttributes, + /* [out] */ BOOL *pfMatches) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpObjectTokenVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpObjectToken * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpObjectToken * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpObjectToken * This); + + HRESULT ( STDMETHODCALLTYPE *SetData )( + ISpObjectToken * This, + const WCHAR *pszValueName, + ULONG cbData, + const BYTE *pData); + + HRESULT ( STDMETHODCALLTYPE *GetData )( + ISpObjectToken * This, + const WCHAR *pszValueName, + ULONG *pcbData, + BYTE *pData); + + HRESULT ( STDMETHODCALLTYPE *SetStringValue )( + ISpObjectToken * This, + const WCHAR *pszValueName, + const WCHAR *pszValue); + + HRESULT ( STDMETHODCALLTYPE *GetStringValue )( + ISpObjectToken * This, + const WCHAR *pszValueName, + WCHAR **ppszValue); + + HRESULT ( STDMETHODCALLTYPE *SetDWORD )( + ISpObjectToken * This, + const WCHAR *pszValueName, + DWORD dwValue); + + HRESULT ( STDMETHODCALLTYPE *GetDWORD )( + ISpObjectToken * This, + const WCHAR *pszValueName, + DWORD *pdwValue); + + HRESULT ( STDMETHODCALLTYPE *OpenKey )( + ISpObjectToken * This, + const WCHAR *pszSubKeyName, + ISpDataKey **ppSubKey); + + HRESULT ( STDMETHODCALLTYPE *CreateKey )( + ISpObjectToken * This, + const WCHAR *pszSubKey, + ISpDataKey **ppSubKey); + + HRESULT ( STDMETHODCALLTYPE *DeleteKey )( + ISpObjectToken * This, + const WCHAR *pszSubKey); + + HRESULT ( STDMETHODCALLTYPE *DeleteValue )( + ISpObjectToken * This, + const WCHAR *pszValueName); + + HRESULT ( STDMETHODCALLTYPE *EnumKeys )( + ISpObjectToken * This, + ULONG Index, + WCHAR **ppszSubKeyName); + + HRESULT ( STDMETHODCALLTYPE *EnumValues )( + ISpObjectToken * This, + ULONG Index, + WCHAR **ppszValueName); + + HRESULT ( STDMETHODCALLTYPE *SetId )( + ISpObjectToken * This, + const WCHAR *pszCategoryId, + const WCHAR *pszTokenId, + BOOL fCreateIfNotExist); + + HRESULT ( STDMETHODCALLTYPE *GetId )( + ISpObjectToken * This, + WCHAR **ppszCoMemTokenId); + + HRESULT ( STDMETHODCALLTYPE *GetCategory )( + ISpObjectToken * This, + ISpObjectTokenCategory **ppTokenCategory); + + HRESULT ( STDMETHODCALLTYPE *CreateInstance )( + ISpObjectToken * This, + /* [in] */ IUnknown *pUnkOuter, + /* [in] */ DWORD dwClsContext, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + HRESULT ( STDMETHODCALLTYPE *GetStorageFileName )( + ISpObjectToken * This, + /* [in] */ REFCLSID clsidCaller, + /* [in] */ const WCHAR *pszValueName, + /* [in] */ const WCHAR *pszFileNameSpecifier, + /* [in] */ ULONG nFolder, + /* [out] */ WCHAR **ppszFilePath); + + HRESULT ( STDMETHODCALLTYPE *RemoveStorageFileName )( + ISpObjectToken * This, + /* [in] */ REFCLSID clsidCaller, + /* [in] */ const WCHAR *pszKeyName, + /* [in] */ BOOL fDeleteFile); + + HRESULT ( STDMETHODCALLTYPE *Remove )( + ISpObjectToken * This, + const CLSID *pclsidCaller); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *IsUISupported )( + ISpObjectToken * This, + /* [in] */ const WCHAR *pszTypeOfUI, + /* [in] */ void *pvExtraData, + /* [in] */ ULONG cbExtraData, + /* [in] */ IUnknown *punkObject, + /* [out] */ BOOL *pfSupported); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *DisplayUI )( + ISpObjectToken * This, + /* [in] */ HWND hwndParent, + /* [in] */ const WCHAR *pszTitle, + /* [in] */ const WCHAR *pszTypeOfUI, + /* [in] */ void *pvExtraData, + /* [in] */ ULONG cbExtraData, + /* [in] */ IUnknown *punkObject); + + HRESULT ( STDMETHODCALLTYPE *MatchesAttributes )( + ISpObjectToken * This, + /* [in] */ const WCHAR *pszAttributes, + /* [out] */ BOOL *pfMatches); + + END_INTERFACE + } ISpObjectTokenVtbl; + + interface ISpObjectToken + { + CONST_VTBL struct ISpObjectTokenVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpObjectToken_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpObjectToken_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpObjectToken_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpObjectToken_SetData(This,pszValueName,cbData,pData) \ + (This)->lpVtbl -> SetData(This,pszValueName,cbData,pData) + +#define ISpObjectToken_GetData(This,pszValueName,pcbData,pData) \ + (This)->lpVtbl -> GetData(This,pszValueName,pcbData,pData) + +#define ISpObjectToken_SetStringValue(This,pszValueName,pszValue) \ + (This)->lpVtbl -> SetStringValue(This,pszValueName,pszValue) + +#define ISpObjectToken_GetStringValue(This,pszValueName,ppszValue) \ + (This)->lpVtbl -> GetStringValue(This,pszValueName,ppszValue) + +#define ISpObjectToken_SetDWORD(This,pszValueName,dwValue) \ + (This)->lpVtbl -> SetDWORD(This,pszValueName,dwValue) + +#define ISpObjectToken_GetDWORD(This,pszValueName,pdwValue) \ + (This)->lpVtbl -> GetDWORD(This,pszValueName,pdwValue) + +#define ISpObjectToken_OpenKey(This,pszSubKeyName,ppSubKey) \ + (This)->lpVtbl -> OpenKey(This,pszSubKeyName,ppSubKey) + +#define ISpObjectToken_CreateKey(This,pszSubKey,ppSubKey) \ + (This)->lpVtbl -> CreateKey(This,pszSubKey,ppSubKey) + +#define ISpObjectToken_DeleteKey(This,pszSubKey) \ + (This)->lpVtbl -> DeleteKey(This,pszSubKey) + +#define ISpObjectToken_DeleteValue(This,pszValueName) \ + (This)->lpVtbl -> DeleteValue(This,pszValueName) + +#define ISpObjectToken_EnumKeys(This,Index,ppszSubKeyName) \ + (This)->lpVtbl -> EnumKeys(This,Index,ppszSubKeyName) + +#define ISpObjectToken_EnumValues(This,Index,ppszValueName) \ + (This)->lpVtbl -> EnumValues(This,Index,ppszValueName) + + +#define ISpObjectToken_SetId(This,pszCategoryId,pszTokenId,fCreateIfNotExist) \ + (This)->lpVtbl -> SetId(This,pszCategoryId,pszTokenId,fCreateIfNotExist) + +#define ISpObjectToken_GetId(This,ppszCoMemTokenId) \ + (This)->lpVtbl -> GetId(This,ppszCoMemTokenId) + +#define ISpObjectToken_GetCategory(This,ppTokenCategory) \ + (This)->lpVtbl -> GetCategory(This,ppTokenCategory) + +#define ISpObjectToken_CreateInstance(This,pUnkOuter,dwClsContext,riid,ppvObject) \ + (This)->lpVtbl -> CreateInstance(This,pUnkOuter,dwClsContext,riid,ppvObject) + +#define ISpObjectToken_GetStorageFileName(This,clsidCaller,pszValueName,pszFileNameSpecifier,nFolder,ppszFilePath) \ + (This)->lpVtbl -> GetStorageFileName(This,clsidCaller,pszValueName,pszFileNameSpecifier,nFolder,ppszFilePath) + +#define ISpObjectToken_RemoveStorageFileName(This,clsidCaller,pszKeyName,fDeleteFile) \ + (This)->lpVtbl -> RemoveStorageFileName(This,clsidCaller,pszKeyName,fDeleteFile) + +#define ISpObjectToken_Remove(This,pclsidCaller) \ + (This)->lpVtbl -> Remove(This,pclsidCaller) + +#define ISpObjectToken_IsUISupported(This,pszTypeOfUI,pvExtraData,cbExtraData,punkObject,pfSupported) \ + (This)->lpVtbl -> IsUISupported(This,pszTypeOfUI,pvExtraData,cbExtraData,punkObject,pfSupported) + +#define ISpObjectToken_DisplayUI(This,hwndParent,pszTitle,pszTypeOfUI,pvExtraData,cbExtraData,punkObject) \ + (This)->lpVtbl -> DisplayUI(This,hwndParent,pszTitle,pszTypeOfUI,pvExtraData,cbExtraData,punkObject) + +#define ISpObjectToken_MatchesAttributes(This,pszAttributes,pfMatches) \ + (This)->lpVtbl -> MatchesAttributes(This,pszAttributes,pfMatches) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpObjectToken_SetId_Proxy( + ISpObjectToken * This, + const WCHAR *pszCategoryId, + const WCHAR *pszTokenId, + BOOL fCreateIfNotExist); + + +void __RPC_STUB ISpObjectToken_SetId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpObjectToken_GetId_Proxy( + ISpObjectToken * This, + WCHAR **ppszCoMemTokenId); + + +void __RPC_STUB ISpObjectToken_GetId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpObjectToken_GetCategory_Proxy( + ISpObjectToken * This, + ISpObjectTokenCategory **ppTokenCategory); + + +void __RPC_STUB ISpObjectToken_GetCategory_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpObjectToken_CreateInstance_Proxy( + ISpObjectToken * This, + /* [in] */ IUnknown *pUnkOuter, + /* [in] */ DWORD dwClsContext, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + +void __RPC_STUB ISpObjectToken_CreateInstance_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpObjectToken_GetStorageFileName_Proxy( + ISpObjectToken * This, + /* [in] */ REFCLSID clsidCaller, + /* [in] */ const WCHAR *pszValueName, + /* [in] */ const WCHAR *pszFileNameSpecifier, + /* [in] */ ULONG nFolder, + /* [out] */ WCHAR **ppszFilePath); + + +void __RPC_STUB ISpObjectToken_GetStorageFileName_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpObjectToken_RemoveStorageFileName_Proxy( + ISpObjectToken * This, + /* [in] */ REFCLSID clsidCaller, + /* [in] */ const WCHAR *pszKeyName, + /* [in] */ BOOL fDeleteFile); + + +void __RPC_STUB ISpObjectToken_RemoveStorageFileName_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpObjectToken_Remove_Proxy( + ISpObjectToken * This, + const CLSID *pclsidCaller); + + +void __RPC_STUB ISpObjectToken_Remove_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [local] */ HRESULT STDMETHODCALLTYPE ISpObjectToken_IsUISupported_Proxy( + ISpObjectToken * This, + /* [in] */ const WCHAR *pszTypeOfUI, + /* [in] */ void *pvExtraData, + /* [in] */ ULONG cbExtraData, + /* [in] */ IUnknown *punkObject, + /* [out] */ BOOL *pfSupported); + + +void __RPC_STUB ISpObjectToken_IsUISupported_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [local] */ HRESULT STDMETHODCALLTYPE ISpObjectToken_DisplayUI_Proxy( + ISpObjectToken * This, + /* [in] */ HWND hwndParent, + /* [in] */ const WCHAR *pszTitle, + /* [in] */ const WCHAR *pszTypeOfUI, + /* [in] */ void *pvExtraData, + /* [in] */ ULONG cbExtraData, + /* [in] */ IUnknown *punkObject); + + +void __RPC_STUB ISpObjectToken_DisplayUI_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpObjectToken_MatchesAttributes_Proxy( + ISpObjectToken * This, + /* [in] */ const WCHAR *pszAttributes, + /* [out] */ BOOL *pfMatches); + + +void __RPC_STUB ISpObjectToken_MatchesAttributes_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpObjectToken_INTERFACE_DEFINED__ */ + + +#ifndef __ISpObjectTokenInit_INTERFACE_DEFINED__ +#define __ISpObjectTokenInit_INTERFACE_DEFINED__ + +/* interface ISpObjectTokenInit */ +/* [restricted][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpObjectTokenInit; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("B8AAB0CF-346F-49D8-9499-C8B03F161D51") + ISpObjectTokenInit : public ISpObjectToken + { + public: + virtual HRESULT STDMETHODCALLTYPE InitFromDataKey( + /* [in] */ const WCHAR *pszCategoryId, + /* [in] */ const WCHAR *pszTokenId, + /* [in] */ ISpDataKey *pDataKey) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpObjectTokenInitVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpObjectTokenInit * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpObjectTokenInit * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpObjectTokenInit * This); + + HRESULT ( STDMETHODCALLTYPE *SetData )( + ISpObjectTokenInit * This, + const WCHAR *pszValueName, + ULONG cbData, + const BYTE *pData); + + HRESULT ( STDMETHODCALLTYPE *GetData )( + ISpObjectTokenInit * This, + const WCHAR *pszValueName, + ULONG *pcbData, + BYTE *pData); + + HRESULT ( STDMETHODCALLTYPE *SetStringValue )( + ISpObjectTokenInit * This, + const WCHAR *pszValueName, + const WCHAR *pszValue); + + HRESULT ( STDMETHODCALLTYPE *GetStringValue )( + ISpObjectTokenInit * This, + const WCHAR *pszValueName, + WCHAR **ppszValue); + + HRESULT ( STDMETHODCALLTYPE *SetDWORD )( + ISpObjectTokenInit * This, + const WCHAR *pszValueName, + DWORD dwValue); + + HRESULT ( STDMETHODCALLTYPE *GetDWORD )( + ISpObjectTokenInit * This, + const WCHAR *pszValueName, + DWORD *pdwValue); + + HRESULT ( STDMETHODCALLTYPE *OpenKey )( + ISpObjectTokenInit * This, + const WCHAR *pszSubKeyName, + ISpDataKey **ppSubKey); + + HRESULT ( STDMETHODCALLTYPE *CreateKey )( + ISpObjectTokenInit * This, + const WCHAR *pszSubKey, + ISpDataKey **ppSubKey); + + HRESULT ( STDMETHODCALLTYPE *DeleteKey )( + ISpObjectTokenInit * This, + const WCHAR *pszSubKey); + + HRESULT ( STDMETHODCALLTYPE *DeleteValue )( + ISpObjectTokenInit * This, + const WCHAR *pszValueName); + + HRESULT ( STDMETHODCALLTYPE *EnumKeys )( + ISpObjectTokenInit * This, + ULONG Index, + WCHAR **ppszSubKeyName); + + HRESULT ( STDMETHODCALLTYPE *EnumValues )( + ISpObjectTokenInit * This, + ULONG Index, + WCHAR **ppszValueName); + + HRESULT ( STDMETHODCALLTYPE *SetId )( + ISpObjectTokenInit * This, + const WCHAR *pszCategoryId, + const WCHAR *pszTokenId, + BOOL fCreateIfNotExist); + + HRESULT ( STDMETHODCALLTYPE *GetId )( + ISpObjectTokenInit * This, + WCHAR **ppszCoMemTokenId); + + HRESULT ( STDMETHODCALLTYPE *GetCategory )( + ISpObjectTokenInit * This, + ISpObjectTokenCategory **ppTokenCategory); + + HRESULT ( STDMETHODCALLTYPE *CreateInstance )( + ISpObjectTokenInit * This, + /* [in] */ IUnknown *pUnkOuter, + /* [in] */ DWORD dwClsContext, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + HRESULT ( STDMETHODCALLTYPE *GetStorageFileName )( + ISpObjectTokenInit * This, + /* [in] */ REFCLSID clsidCaller, + /* [in] */ const WCHAR *pszValueName, + /* [in] */ const WCHAR *pszFileNameSpecifier, + /* [in] */ ULONG nFolder, + /* [out] */ WCHAR **ppszFilePath); + + HRESULT ( STDMETHODCALLTYPE *RemoveStorageFileName )( + ISpObjectTokenInit * This, + /* [in] */ REFCLSID clsidCaller, + /* [in] */ const WCHAR *pszKeyName, + /* [in] */ BOOL fDeleteFile); + + HRESULT ( STDMETHODCALLTYPE *Remove )( + ISpObjectTokenInit * This, + const CLSID *pclsidCaller); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *IsUISupported )( + ISpObjectTokenInit * This, + /* [in] */ const WCHAR *pszTypeOfUI, + /* [in] */ void *pvExtraData, + /* [in] */ ULONG cbExtraData, + /* [in] */ IUnknown *punkObject, + /* [out] */ BOOL *pfSupported); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *DisplayUI )( + ISpObjectTokenInit * This, + /* [in] */ HWND hwndParent, + /* [in] */ const WCHAR *pszTitle, + /* [in] */ const WCHAR *pszTypeOfUI, + /* [in] */ void *pvExtraData, + /* [in] */ ULONG cbExtraData, + /* [in] */ IUnknown *punkObject); + + HRESULT ( STDMETHODCALLTYPE *MatchesAttributes )( + ISpObjectTokenInit * This, + /* [in] */ const WCHAR *pszAttributes, + /* [out] */ BOOL *pfMatches); + + HRESULT ( STDMETHODCALLTYPE *InitFromDataKey )( + ISpObjectTokenInit * This, + /* [in] */ const WCHAR *pszCategoryId, + /* [in] */ const WCHAR *pszTokenId, + /* [in] */ ISpDataKey *pDataKey); + + END_INTERFACE + } ISpObjectTokenInitVtbl; + + interface ISpObjectTokenInit + { + CONST_VTBL struct ISpObjectTokenInitVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpObjectTokenInit_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpObjectTokenInit_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpObjectTokenInit_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpObjectTokenInit_SetData(This,pszValueName,cbData,pData) \ + (This)->lpVtbl -> SetData(This,pszValueName,cbData,pData) + +#define ISpObjectTokenInit_GetData(This,pszValueName,pcbData,pData) \ + (This)->lpVtbl -> GetData(This,pszValueName,pcbData,pData) + +#define ISpObjectTokenInit_SetStringValue(This,pszValueName,pszValue) \ + (This)->lpVtbl -> SetStringValue(This,pszValueName,pszValue) + +#define ISpObjectTokenInit_GetStringValue(This,pszValueName,ppszValue) \ + (This)->lpVtbl -> GetStringValue(This,pszValueName,ppszValue) + +#define ISpObjectTokenInit_SetDWORD(This,pszValueName,dwValue) \ + (This)->lpVtbl -> SetDWORD(This,pszValueName,dwValue) + +#define ISpObjectTokenInit_GetDWORD(This,pszValueName,pdwValue) \ + (This)->lpVtbl -> GetDWORD(This,pszValueName,pdwValue) + +#define ISpObjectTokenInit_OpenKey(This,pszSubKeyName,ppSubKey) \ + (This)->lpVtbl -> OpenKey(This,pszSubKeyName,ppSubKey) + +#define ISpObjectTokenInit_CreateKey(This,pszSubKey,ppSubKey) \ + (This)->lpVtbl -> CreateKey(This,pszSubKey,ppSubKey) + +#define ISpObjectTokenInit_DeleteKey(This,pszSubKey) \ + (This)->lpVtbl -> DeleteKey(This,pszSubKey) + +#define ISpObjectTokenInit_DeleteValue(This,pszValueName) \ + (This)->lpVtbl -> DeleteValue(This,pszValueName) + +#define ISpObjectTokenInit_EnumKeys(This,Index,ppszSubKeyName) \ + (This)->lpVtbl -> EnumKeys(This,Index,ppszSubKeyName) + +#define ISpObjectTokenInit_EnumValues(This,Index,ppszValueName) \ + (This)->lpVtbl -> EnumValues(This,Index,ppszValueName) + + +#define ISpObjectTokenInit_SetId(This,pszCategoryId,pszTokenId,fCreateIfNotExist) \ + (This)->lpVtbl -> SetId(This,pszCategoryId,pszTokenId,fCreateIfNotExist) + +#define ISpObjectTokenInit_GetId(This,ppszCoMemTokenId) \ + (This)->lpVtbl -> GetId(This,ppszCoMemTokenId) + +#define ISpObjectTokenInit_GetCategory(This,ppTokenCategory) \ + (This)->lpVtbl -> GetCategory(This,ppTokenCategory) + +#define ISpObjectTokenInit_CreateInstance(This,pUnkOuter,dwClsContext,riid,ppvObject) \ + (This)->lpVtbl -> CreateInstance(This,pUnkOuter,dwClsContext,riid,ppvObject) + +#define ISpObjectTokenInit_GetStorageFileName(This,clsidCaller,pszValueName,pszFileNameSpecifier,nFolder,ppszFilePath) \ + (This)->lpVtbl -> GetStorageFileName(This,clsidCaller,pszValueName,pszFileNameSpecifier,nFolder,ppszFilePath) + +#define ISpObjectTokenInit_RemoveStorageFileName(This,clsidCaller,pszKeyName,fDeleteFile) \ + (This)->lpVtbl -> RemoveStorageFileName(This,clsidCaller,pszKeyName,fDeleteFile) + +#define ISpObjectTokenInit_Remove(This,pclsidCaller) \ + (This)->lpVtbl -> Remove(This,pclsidCaller) + +#define ISpObjectTokenInit_IsUISupported(This,pszTypeOfUI,pvExtraData,cbExtraData,punkObject,pfSupported) \ + (This)->lpVtbl -> IsUISupported(This,pszTypeOfUI,pvExtraData,cbExtraData,punkObject,pfSupported) + +#define ISpObjectTokenInit_DisplayUI(This,hwndParent,pszTitle,pszTypeOfUI,pvExtraData,cbExtraData,punkObject) \ + (This)->lpVtbl -> DisplayUI(This,hwndParent,pszTitle,pszTypeOfUI,pvExtraData,cbExtraData,punkObject) + +#define ISpObjectTokenInit_MatchesAttributes(This,pszAttributes,pfMatches) \ + (This)->lpVtbl -> MatchesAttributes(This,pszAttributes,pfMatches) + + +#define ISpObjectTokenInit_InitFromDataKey(This,pszCategoryId,pszTokenId,pDataKey) \ + (This)->lpVtbl -> InitFromDataKey(This,pszCategoryId,pszTokenId,pDataKey) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpObjectTokenInit_InitFromDataKey_Proxy( + ISpObjectTokenInit * This, + /* [in] */ const WCHAR *pszCategoryId, + /* [in] */ const WCHAR *pszTokenId, + /* [in] */ ISpDataKey *pDataKey); + + +void __RPC_STUB ISpObjectTokenInit_InitFromDataKey_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpObjectTokenInit_INTERFACE_DEFINED__ */ + + +#ifndef __IEnumSpObjectTokens_INTERFACE_DEFINED__ +#define __IEnumSpObjectTokens_INTERFACE_DEFINED__ + +/* interface IEnumSpObjectTokens */ +/* [restricted][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IEnumSpObjectTokens; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("06B64F9E-7FDA-11D2-B4F2-00C04F797396") + IEnumSpObjectTokens : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Next( + /* [in] */ ULONG celt, + /* [length_is][size_is][out] */ ISpObjectToken **pelt, + /* [out] */ ULONG *pceltFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE Skip( + /* [in] */ ULONG celt) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + /* [out] */ IEnumSpObjectTokens **ppEnum) = 0; + + virtual HRESULT STDMETHODCALLTYPE Item( + /* [in] */ ULONG Index, + /* [out] */ ISpObjectToken **ppToken) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCount( + /* [out] */ ULONG *pCount) = 0; + + }; + +#else /* C style interface */ + + typedef struct IEnumSpObjectTokensVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IEnumSpObjectTokens * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IEnumSpObjectTokens * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IEnumSpObjectTokens * This); + + HRESULT ( STDMETHODCALLTYPE *Next )( + IEnumSpObjectTokens * This, + /* [in] */ ULONG celt, + /* [length_is][size_is][out] */ ISpObjectToken **pelt, + /* [out] */ ULONG *pceltFetched); + + HRESULT ( STDMETHODCALLTYPE *Skip )( + IEnumSpObjectTokens * This, + /* [in] */ ULONG celt); + + HRESULT ( STDMETHODCALLTYPE *Reset )( + IEnumSpObjectTokens * This); + + HRESULT ( STDMETHODCALLTYPE *Clone )( + IEnumSpObjectTokens * This, + /* [out] */ IEnumSpObjectTokens **ppEnum); + + HRESULT ( STDMETHODCALLTYPE *Item )( + IEnumSpObjectTokens * This, + /* [in] */ ULONG Index, + /* [out] */ ISpObjectToken **ppToken); + + HRESULT ( STDMETHODCALLTYPE *GetCount )( + IEnumSpObjectTokens * This, + /* [out] */ ULONG *pCount); + + END_INTERFACE + } IEnumSpObjectTokensVtbl; + + interface IEnumSpObjectTokens + { + CONST_VTBL struct IEnumSpObjectTokensVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IEnumSpObjectTokens_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define IEnumSpObjectTokens_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define IEnumSpObjectTokens_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define IEnumSpObjectTokens_Next(This,celt,pelt,pceltFetched) \ + (This)->lpVtbl -> Next(This,celt,pelt,pceltFetched) + +#define IEnumSpObjectTokens_Skip(This,celt) \ + (This)->lpVtbl -> Skip(This,celt) + +#define IEnumSpObjectTokens_Reset(This) \ + (This)->lpVtbl -> Reset(This) + +#define IEnumSpObjectTokens_Clone(This,ppEnum) \ + (This)->lpVtbl -> Clone(This,ppEnum) + +#define IEnumSpObjectTokens_Item(This,Index,ppToken) \ + (This)->lpVtbl -> Item(This,Index,ppToken) + +#define IEnumSpObjectTokens_GetCount(This,pCount) \ + (This)->lpVtbl -> GetCount(This,pCount) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE IEnumSpObjectTokens_Next_Proxy( + IEnumSpObjectTokens * This, + /* [in] */ ULONG celt, + /* [length_is][size_is][out] */ ISpObjectToken **pelt, + /* [out] */ ULONG *pceltFetched); + + +void __RPC_STUB IEnumSpObjectTokens_Next_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE IEnumSpObjectTokens_Skip_Proxy( + IEnumSpObjectTokens * This, + /* [in] */ ULONG celt); + + +void __RPC_STUB IEnumSpObjectTokens_Skip_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE IEnumSpObjectTokens_Reset_Proxy( + IEnumSpObjectTokens * This); + + +void __RPC_STUB IEnumSpObjectTokens_Reset_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE IEnumSpObjectTokens_Clone_Proxy( + IEnumSpObjectTokens * This, + /* [out] */ IEnumSpObjectTokens **ppEnum); + + +void __RPC_STUB IEnumSpObjectTokens_Clone_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE IEnumSpObjectTokens_Item_Proxy( + IEnumSpObjectTokens * This, + /* [in] */ ULONG Index, + /* [out] */ ISpObjectToken **ppToken); + + +void __RPC_STUB IEnumSpObjectTokens_Item_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE IEnumSpObjectTokens_GetCount_Proxy( + IEnumSpObjectTokens * This, + /* [out] */ ULONG *pCount); + + +void __RPC_STUB IEnumSpObjectTokens_GetCount_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __IEnumSpObjectTokens_INTERFACE_DEFINED__ */ + + +#ifndef __ISpObjectWithToken_INTERFACE_DEFINED__ +#define __ISpObjectWithToken_INTERFACE_DEFINED__ + +/* interface ISpObjectWithToken */ +/* [restricted][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpObjectWithToken; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("5B559F40-E952-11D2-BB91-00C04F8EE6C0") + ISpObjectWithToken : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetObjectToken( + ISpObjectToken *pToken) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetObjectToken( + ISpObjectToken **ppToken) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpObjectWithTokenVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpObjectWithToken * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpObjectWithToken * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpObjectWithToken * This); + + HRESULT ( STDMETHODCALLTYPE *SetObjectToken )( + ISpObjectWithToken * This, + ISpObjectToken *pToken); + + HRESULT ( STDMETHODCALLTYPE *GetObjectToken )( + ISpObjectWithToken * This, + ISpObjectToken **ppToken); + + END_INTERFACE + } ISpObjectWithTokenVtbl; + + interface ISpObjectWithToken + { + CONST_VTBL struct ISpObjectWithTokenVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpObjectWithToken_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpObjectWithToken_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpObjectWithToken_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpObjectWithToken_SetObjectToken(This,pToken) \ + (This)->lpVtbl -> SetObjectToken(This,pToken) + +#define ISpObjectWithToken_GetObjectToken(This,ppToken) \ + (This)->lpVtbl -> GetObjectToken(This,ppToken) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpObjectWithToken_SetObjectToken_Proxy( + ISpObjectWithToken * This, + ISpObjectToken *pToken); + + +void __RPC_STUB ISpObjectWithToken_SetObjectToken_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpObjectWithToken_GetObjectToken_Proxy( + ISpObjectWithToken * This, + ISpObjectToken **ppToken); + + +void __RPC_STUB ISpObjectWithToken_GetObjectToken_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpObjectWithToken_INTERFACE_DEFINED__ */ + + +#ifndef __ISpResourceManager_INTERFACE_DEFINED__ +#define __ISpResourceManager_INTERFACE_DEFINED__ + +/* interface ISpResourceManager */ +/* [restricted][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpResourceManager; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("93384E18-5014-43D5-ADBB-A78E055926BD") + ISpResourceManager : public IServiceProvider + { + public: + virtual HRESULT STDMETHODCALLTYPE SetObject( + /* [in] */ REFGUID guidServiceId, + /* [in] */ IUnknown *pUnkObject) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetObject( + /* [in] */ REFGUID guidServiceId, + /* [in] */ REFCLSID ObjectCLSID, + /* [in] */ REFIID ObjectIID, + /* [in] */ BOOL fReleaseWhenLastExternalRefReleased, + /* [iid_is][out] */ void **ppObject) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpResourceManagerVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpResourceManager * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpResourceManager * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpResourceManager * This); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *QueryService )( + ISpResourceManager * This, + /* [in] */ REFGUID guidService, + /* [in] */ REFIID riid, + /* [out] */ void **ppvObject); + + HRESULT ( STDMETHODCALLTYPE *SetObject )( + ISpResourceManager * This, + /* [in] */ REFGUID guidServiceId, + /* [in] */ IUnknown *pUnkObject); + + HRESULT ( STDMETHODCALLTYPE *GetObject )( + ISpResourceManager * This, + /* [in] */ REFGUID guidServiceId, + /* [in] */ REFCLSID ObjectCLSID, + /* [in] */ REFIID ObjectIID, + /* [in] */ BOOL fReleaseWhenLastExternalRefReleased, + /* [iid_is][out] */ void **ppObject); + + END_INTERFACE + } ISpResourceManagerVtbl; + + interface ISpResourceManager + { + CONST_VTBL struct ISpResourceManagerVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpResourceManager_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpResourceManager_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpResourceManager_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpResourceManager_QueryService(This,guidService,riid,ppvObject) \ + (This)->lpVtbl -> QueryService(This,guidService,riid,ppvObject) + + +#define ISpResourceManager_SetObject(This,guidServiceId,pUnkObject) \ + (This)->lpVtbl -> SetObject(This,guidServiceId,pUnkObject) + +#define ISpResourceManager_GetObject(This,guidServiceId,ObjectCLSID,ObjectIID,fReleaseWhenLastExternalRefReleased,ppObject) \ + (This)->lpVtbl -> GetObject(This,guidServiceId,ObjectCLSID,ObjectIID,fReleaseWhenLastExternalRefReleased,ppObject) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpResourceManager_SetObject_Proxy( + ISpResourceManager * This, + /* [in] */ REFGUID guidServiceId, + /* [in] */ IUnknown *pUnkObject); + + +void __RPC_STUB ISpResourceManager_SetObject_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpResourceManager_GetObject_Proxy( + ISpResourceManager * This, + /* [in] */ REFGUID guidServiceId, + /* [in] */ REFCLSID ObjectCLSID, + /* [in] */ REFIID ObjectIID, + /* [in] */ BOOL fReleaseWhenLastExternalRefReleased, + /* [iid_is][out] */ void **ppObject); + + +void __RPC_STUB ISpResourceManager_GetObject_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpResourceManager_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_sapi_0262 */ +/* [local] */ + +typedef /* [hidden] */ +enum SPEVENTLPARAMTYPE + { SPET_LPARAM_IS_UNDEFINED = 0, + SPET_LPARAM_IS_TOKEN = SPET_LPARAM_IS_UNDEFINED + 1, + SPET_LPARAM_IS_OBJECT = SPET_LPARAM_IS_TOKEN + 1, + SPET_LPARAM_IS_POINTER = SPET_LPARAM_IS_OBJECT + 1, + SPET_LPARAM_IS_STRING = SPET_LPARAM_IS_POINTER + 1 + } SPEVENTLPARAMTYPE; + +typedef /* [hidden] */ +enum SPEVENTENUM + { SPEI_UNDEFINED = 0, + SPEI_START_INPUT_STREAM = 1, + SPEI_END_INPUT_STREAM = 2, + SPEI_VOICE_CHANGE = 3, + SPEI_TTS_BOOKMARK = 4, + SPEI_WORD_BOUNDARY = 5, + SPEI_PHONEME = 6, + SPEI_SENTENCE_BOUNDARY = 7, + SPEI_VISEME = 8, + SPEI_TTS_AUDIO_LEVEL = 9, + SPEI_TTS_PRIVATE = 15, + SPEI_MIN_TTS = 1, + SPEI_MAX_TTS = 15, + SPEI_END_SR_STREAM = 34, + SPEI_SOUND_START = 35, + SPEI_SOUND_END = 36, + SPEI_PHRASE_START = 37, + SPEI_RECOGNITION = 38, + SPEI_HYPOTHESIS = 39, + SPEI_SR_BOOKMARK = 40, + SPEI_PROPERTY_NUM_CHANGE = 41, + SPEI_PROPERTY_STRING_CHANGE = 42, + SPEI_FALSE_RECOGNITION = 43, + SPEI_INTERFERENCE = 44, + SPEI_REQUEST_UI = 45, + SPEI_RECO_STATE_CHANGE = 46, + SPEI_ADAPTATION = 47, + SPEI_START_SR_STREAM = 48, + SPEI_RECO_OTHER_CONTEXT = 49, + SPEI_SR_AUDIO_LEVEL = 50, + SPEI_SR_PRIVATE = 52, + SPEI_MIN_SR = 34, + SPEI_MAX_SR = 52, + SPEI_RESERVED1 = 30, + SPEI_RESERVED2 = 33, + SPEI_RESERVED3 = 63 + } SPEVENTENUM; + +#define SPFEI_FLAGCHECK ( (1ui64 << SPEI_RESERVED1) | (1ui64 << SPEI_RESERVED2) ) +#define SPFEI_ALL_TTS_EVENTS (0x000000000000FFFEui64 | SPFEI_FLAGCHECK) +#define SPFEI_ALL_SR_EVENTS (0x001FFFFC00000000ui64 | SPFEI_FLAGCHECK) +#define SPFEI_ALL_EVENTS 0xEFFFFFFFFFFFFFFFui64 +#define SPFEI(SPEI_ord) ((1ui64 << SPEI_ord) | SPFEI_FLAGCHECK) +#if 0 +typedef /* [hidden][restricted] */ struct SPEVENT + { + WORD eEventId; + WORD elParamType; + ULONG ulStreamNum; + ULONGLONG ullAudioStreamOffset; + WPARAM wParam; + LPARAM lParam; + } SPEVENT; + +typedef /* [hidden][restricted] */ struct SPSERIALIZEDEVENT + { + WORD eEventId; + WORD elParamType; + ULONG ulStreamNum; + ULONGLONG ullAudioStreamOffset; + ULONG SerializedwParam; + LONG SerializedlParam; + } SPSERIALIZEDEVENT; + +typedef /* [hidden][restricted] */ struct SPSERIALIZEDEVENT64 + { + WORD eEventId; + WORD elParamType; + ULONG ulStreamNum; + ULONGLONG ullAudioStreamOffset; + ULONGLONG SerializedwParam; + LONGLONG SerializedlParam; + } SPSERIALIZEDEVENT64; + +#else +typedef struct SPEVENT +{ + SPEVENTENUM eEventId : 16; + SPEVENTLPARAMTYPE elParamType : 16; + ULONG ulStreamNum; + ULONGLONG ullAudioStreamOffset; + WPARAM wParam; + LPARAM lParam; +} SPEVENT; +typedef struct SPSERIALIZEDEVENT +{ + SPEVENTENUM eEventId : 16; + SPEVENTLPARAMTYPE elParamType : 16; + ULONG ulStreamNum; + ULONGLONG ullAudioStreamOffset; + ULONG SerializedwParam; + LONG SerializedlParam; +} SPSERIALIZEDEVENT; +typedef struct SPSERIALIZEDEVENT64 +{ + SPEVENTENUM eEventId : 16; + SPEVENTLPARAMTYPE elParamType : 16; + ULONG ulStreamNum; + ULONGLONG ullAudioStreamOffset; + ULONGLONG SerializedwParam; + LONGLONG SerializedlParam; +} SPSERIALIZEDEVENT64; +#endif +typedef /* [hidden] */ +enum SPINTERFERENCE + { SPINTERFERENCE_NONE = 0, + SPINTERFERENCE_NOISE = SPINTERFERENCE_NONE + 1, + SPINTERFERENCE_NOSIGNAL = SPINTERFERENCE_NOISE + 1, + SPINTERFERENCE_TOOLOUD = SPINTERFERENCE_NOSIGNAL + 1, + SPINTERFERENCE_TOOQUIET = SPINTERFERENCE_TOOLOUD + 1, + SPINTERFERENCE_TOOFAST = SPINTERFERENCE_TOOQUIET + 1, + SPINTERFERENCE_TOOSLOW = SPINTERFERENCE_TOOFAST + 1 + } SPINTERFERENCE; + +typedef /* [hidden] */ +enum SPENDSRSTREAMFLAGS + { SPESF_NONE = 0, + SPESF_STREAM_RELEASED = 1 << 0 + } SPENDSRSTREAMFLAGS; + +typedef /* [hidden] */ +enum SPVFEATURE + { SPVFEATURE_STRESSED = 1L << 0, + SPVFEATURE_EMPHASIS = 1L << 1 + } SPVFEATURE; + +typedef /* [hidden] */ +enum SPVISEMES + { SP_VISEME_0 = 0, + SP_VISEME_1 = SP_VISEME_0 + 1, + SP_VISEME_2 = SP_VISEME_1 + 1, + SP_VISEME_3 = SP_VISEME_2 + 1, + SP_VISEME_4 = SP_VISEME_3 + 1, + SP_VISEME_5 = SP_VISEME_4 + 1, + SP_VISEME_6 = SP_VISEME_5 + 1, + SP_VISEME_7 = SP_VISEME_6 + 1, + SP_VISEME_8 = SP_VISEME_7 + 1, + SP_VISEME_9 = SP_VISEME_8 + 1, + SP_VISEME_10 = SP_VISEME_9 + 1, + SP_VISEME_11 = SP_VISEME_10 + 1, + SP_VISEME_12 = SP_VISEME_11 + 1, + SP_VISEME_13 = SP_VISEME_12 + 1, + SP_VISEME_14 = SP_VISEME_13 + 1, + SP_VISEME_15 = SP_VISEME_14 + 1, + SP_VISEME_16 = SP_VISEME_15 + 1, + SP_VISEME_17 = SP_VISEME_16 + 1, + SP_VISEME_18 = SP_VISEME_17 + 1, + SP_VISEME_19 = SP_VISEME_18 + 1, + SP_VISEME_20 = SP_VISEME_19 + 1, + SP_VISEME_21 = SP_VISEME_20 + 1 + } SPVISEMES; + +typedef /* [hidden][restricted] */ struct SPEVENTSOURCEINFO + { + ULONGLONG ullEventInterest; + ULONGLONG ullQueuedInterest; + ULONG ulCount; + } SPEVENTSOURCEINFO; + + + +extern RPC_IF_HANDLE __MIDL_itf_sapi_0262_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_sapi_0262_v0_0_s_ifspec; + +#ifndef __ISpEventSource_INTERFACE_DEFINED__ +#define __ISpEventSource_INTERFACE_DEFINED__ + +/* interface ISpEventSource */ +/* [restricted][local][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpEventSource; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("BE7A9CCE-5F9E-11D2-960F-00C04F8EE628") + ISpEventSource : public ISpNotifySource + { + public: + virtual HRESULT STDMETHODCALLTYPE SetInterest( + /* [in] */ ULONGLONG ullEventInterest, + /* [in] */ ULONGLONG ullQueuedInterest) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetEvents( + /* [in] */ ULONG ulCount, + /* [size_is][out] */ SPEVENT *pEventArray, + /* [out] */ ULONG *pulFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInfo( + /* [out] */ SPEVENTSOURCEINFO *pInfo) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpEventSourceVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpEventSource * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpEventSource * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpEventSource * This); + + HRESULT ( STDMETHODCALLTYPE *SetNotifySink )( + ISpEventSource * This, + /* [in] */ ISpNotifySink *pNotifySink); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *SetNotifyWindowMessage )( + ISpEventSource * This, + /* [in] */ HWND hWnd, + /* [in] */ UINT Msg, + /* [in] */ WPARAM wParam, + /* [in] */ LPARAM lParam); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *SetNotifyCallbackFunction )( + ISpEventSource * This, + /* [in] */ SPNOTIFYCALLBACK *pfnCallback, + /* [in] */ WPARAM wParam, + /* [in] */ LPARAM lParam); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *SetNotifyCallbackInterface )( + ISpEventSource * This, + /* [in] */ ISpNotifyCallback *pSpCallback, + /* [in] */ WPARAM wParam, + /* [in] */ LPARAM lParam); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *SetNotifyWin32Event )( + ISpEventSource * This); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *WaitForNotifyEvent )( + ISpEventSource * This, + /* [in] */ DWORD dwMilliseconds); + + /* [local] */ HANDLE ( STDMETHODCALLTYPE *GetNotifyEventHandle )( + ISpEventSource * This); + + HRESULT ( STDMETHODCALLTYPE *SetInterest )( + ISpEventSource * This, + /* [in] */ ULONGLONG ullEventInterest, + /* [in] */ ULONGLONG ullQueuedInterest); + + HRESULT ( STDMETHODCALLTYPE *GetEvents )( + ISpEventSource * This, + /* [in] */ ULONG ulCount, + /* [size_is][out] */ SPEVENT *pEventArray, + /* [out] */ ULONG *pulFetched); + + HRESULT ( STDMETHODCALLTYPE *GetInfo )( + ISpEventSource * This, + /* [out] */ SPEVENTSOURCEINFO *pInfo); + + END_INTERFACE + } ISpEventSourceVtbl; + + interface ISpEventSource + { + CONST_VTBL struct ISpEventSourceVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpEventSource_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpEventSource_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpEventSource_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpEventSource_SetNotifySink(This,pNotifySink) \ + (This)->lpVtbl -> SetNotifySink(This,pNotifySink) + +#define ISpEventSource_SetNotifyWindowMessage(This,hWnd,Msg,wParam,lParam) \ + (This)->lpVtbl -> SetNotifyWindowMessage(This,hWnd,Msg,wParam,lParam) + +#define ISpEventSource_SetNotifyCallbackFunction(This,pfnCallback,wParam,lParam) \ + (This)->lpVtbl -> SetNotifyCallbackFunction(This,pfnCallback,wParam,lParam) + +#define ISpEventSource_SetNotifyCallbackInterface(This,pSpCallback,wParam,lParam) \ + (This)->lpVtbl -> SetNotifyCallbackInterface(This,pSpCallback,wParam,lParam) + +#define ISpEventSource_SetNotifyWin32Event(This) \ + (This)->lpVtbl -> SetNotifyWin32Event(This) + +#define ISpEventSource_WaitForNotifyEvent(This,dwMilliseconds) \ + (This)->lpVtbl -> WaitForNotifyEvent(This,dwMilliseconds) + +#define ISpEventSource_GetNotifyEventHandle(This) \ + (This)->lpVtbl -> GetNotifyEventHandle(This) + + +#define ISpEventSource_SetInterest(This,ullEventInterest,ullQueuedInterest) \ + (This)->lpVtbl -> SetInterest(This,ullEventInterest,ullQueuedInterest) + +#define ISpEventSource_GetEvents(This,ulCount,pEventArray,pulFetched) \ + (This)->lpVtbl -> GetEvents(This,ulCount,pEventArray,pulFetched) + +#define ISpEventSource_GetInfo(This,pInfo) \ + (This)->lpVtbl -> GetInfo(This,pInfo) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpEventSource_SetInterest_Proxy( + ISpEventSource * This, + /* [in] */ ULONGLONG ullEventInterest, + /* [in] */ ULONGLONG ullQueuedInterest); + + +void __RPC_STUB ISpEventSource_SetInterest_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpEventSource_GetEvents_Proxy( + ISpEventSource * This, + /* [in] */ ULONG ulCount, + /* [size_is][out] */ SPEVENT *pEventArray, + /* [out] */ ULONG *pulFetched); + + +void __RPC_STUB ISpEventSource_GetEvents_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpEventSource_GetInfo_Proxy( + ISpEventSource * This, + /* [out] */ SPEVENTSOURCEINFO *pInfo); + + +void __RPC_STUB ISpEventSource_GetInfo_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpEventSource_INTERFACE_DEFINED__ */ + + +#ifndef __ISpEventSink_INTERFACE_DEFINED__ +#define __ISpEventSink_INTERFACE_DEFINED__ + +/* interface ISpEventSink */ +/* [restricted][local][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpEventSink; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("BE7A9CC9-5F9E-11D2-960F-00C04F8EE628") + ISpEventSink : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE AddEvents( + /* [in] */ const SPEVENT *pEventArray, + /* [in] */ ULONG ulCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetEventInterest( + /* [out] */ ULONGLONG *pullEventInterest) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpEventSinkVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpEventSink * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpEventSink * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpEventSink * This); + + HRESULT ( STDMETHODCALLTYPE *AddEvents )( + ISpEventSink * This, + /* [in] */ const SPEVENT *pEventArray, + /* [in] */ ULONG ulCount); + + HRESULT ( STDMETHODCALLTYPE *GetEventInterest )( + ISpEventSink * This, + /* [out] */ ULONGLONG *pullEventInterest); + + END_INTERFACE + } ISpEventSinkVtbl; + + interface ISpEventSink + { + CONST_VTBL struct ISpEventSinkVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpEventSink_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpEventSink_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpEventSink_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpEventSink_AddEvents(This,pEventArray,ulCount) \ + (This)->lpVtbl -> AddEvents(This,pEventArray,ulCount) + +#define ISpEventSink_GetEventInterest(This,pullEventInterest) \ + (This)->lpVtbl -> GetEventInterest(This,pullEventInterest) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpEventSink_AddEvents_Proxy( + ISpEventSink * This, + /* [in] */ const SPEVENT *pEventArray, + /* [in] */ ULONG ulCount); + + +void __RPC_STUB ISpEventSink_AddEvents_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpEventSink_GetEventInterest_Proxy( + ISpEventSink * This, + /* [out] */ ULONGLONG *pullEventInterest); + + +void __RPC_STUB ISpEventSink_GetEventInterest_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpEventSink_INTERFACE_DEFINED__ */ + + +#ifndef __ISpStreamFormat_INTERFACE_DEFINED__ +#define __ISpStreamFormat_INTERFACE_DEFINED__ + +/* interface ISpStreamFormat */ +/* [restricted][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpStreamFormat; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("BED530BE-2606-4F4D-A1C0-54C5CDA5566F") + ISpStreamFormat : public IStream + { + public: + virtual HRESULT STDMETHODCALLTYPE GetFormat( + GUID *pguidFormatId, + WAVEFORMATEX **ppCoMemWaveFormatEx) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpStreamFormatVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpStreamFormat * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpStreamFormat * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpStreamFormat * This); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Read )( + ISpStreamFormat * This, + /* [length_is][size_is][out] */ void *pv, + /* [in] */ ULONG cb, + /* [out] */ ULONG *pcbRead); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Write )( + ISpStreamFormat * This, + /* [size_is][in] */ const void *pv, + /* [in] */ ULONG cb, + /* [out] */ ULONG *pcbWritten); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Seek )( + ISpStreamFormat * This, + /* [in] */ LARGE_INTEGER dlibMove, + /* [in] */ DWORD dwOrigin, + /* [out] */ ULARGE_INTEGER *plibNewPosition); + + HRESULT ( STDMETHODCALLTYPE *SetSize )( + ISpStreamFormat * This, + /* [in] */ ULARGE_INTEGER libNewSize); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *CopyTo )( + ISpStreamFormat * This, + /* [unique][in] */ IStream *pstm, + /* [in] */ ULARGE_INTEGER cb, + /* [out] */ ULARGE_INTEGER *pcbRead, + /* [out] */ ULARGE_INTEGER *pcbWritten); + + HRESULT ( STDMETHODCALLTYPE *Commit )( + ISpStreamFormat * This, + /* [in] */ DWORD grfCommitFlags); + + HRESULT ( STDMETHODCALLTYPE *Revert )( + ISpStreamFormat * This); + + HRESULT ( STDMETHODCALLTYPE *LockRegion )( + ISpStreamFormat * This, + /* [in] */ ULARGE_INTEGER libOffset, + /* [in] */ ULARGE_INTEGER cb, + /* [in] */ DWORD dwLockType); + + HRESULT ( STDMETHODCALLTYPE *UnlockRegion )( + ISpStreamFormat * This, + /* [in] */ ULARGE_INTEGER libOffset, + /* [in] */ ULARGE_INTEGER cb, + /* [in] */ DWORD dwLockType); + + HRESULT ( STDMETHODCALLTYPE *Stat )( + ISpStreamFormat * This, + /* [out] */ STATSTG *pstatstg, + /* [in] */ DWORD grfStatFlag); + + HRESULT ( STDMETHODCALLTYPE *Clone )( + ISpStreamFormat * This, + /* [out] */ IStream **ppstm); + + HRESULT ( STDMETHODCALLTYPE *GetFormat )( + ISpStreamFormat * This, + GUID *pguidFormatId, + WAVEFORMATEX **ppCoMemWaveFormatEx); + + END_INTERFACE + } ISpStreamFormatVtbl; + + interface ISpStreamFormat + { + CONST_VTBL struct ISpStreamFormatVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpStreamFormat_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpStreamFormat_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpStreamFormat_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpStreamFormat_Read(This,pv,cb,pcbRead) \ + (This)->lpVtbl -> Read(This,pv,cb,pcbRead) + +#define ISpStreamFormat_Write(This,pv,cb,pcbWritten) \ + (This)->lpVtbl -> Write(This,pv,cb,pcbWritten) + + +#define ISpStreamFormat_Seek(This,dlibMove,dwOrigin,plibNewPosition) \ + (This)->lpVtbl -> Seek(This,dlibMove,dwOrigin,plibNewPosition) + +#define ISpStreamFormat_SetSize(This,libNewSize) \ + (This)->lpVtbl -> SetSize(This,libNewSize) + +#define ISpStreamFormat_CopyTo(This,pstm,cb,pcbRead,pcbWritten) \ + (This)->lpVtbl -> CopyTo(This,pstm,cb,pcbRead,pcbWritten) + +#define ISpStreamFormat_Commit(This,grfCommitFlags) \ + (This)->lpVtbl -> Commit(This,grfCommitFlags) + +#define ISpStreamFormat_Revert(This) \ + (This)->lpVtbl -> Revert(This) + +#define ISpStreamFormat_LockRegion(This,libOffset,cb,dwLockType) \ + (This)->lpVtbl -> LockRegion(This,libOffset,cb,dwLockType) + +#define ISpStreamFormat_UnlockRegion(This,libOffset,cb,dwLockType) \ + (This)->lpVtbl -> UnlockRegion(This,libOffset,cb,dwLockType) + +#define ISpStreamFormat_Stat(This,pstatstg,grfStatFlag) \ + (This)->lpVtbl -> Stat(This,pstatstg,grfStatFlag) + +#define ISpStreamFormat_Clone(This,ppstm) \ + (This)->lpVtbl -> Clone(This,ppstm) + + +#define ISpStreamFormat_GetFormat(This,pguidFormatId,ppCoMemWaveFormatEx) \ + (This)->lpVtbl -> GetFormat(This,pguidFormatId,ppCoMemWaveFormatEx) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpStreamFormat_GetFormat_Proxy( + ISpStreamFormat * This, + GUID *pguidFormatId, + WAVEFORMATEX **ppCoMemWaveFormatEx); + + +void __RPC_STUB ISpStreamFormat_GetFormat_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpStreamFormat_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_sapi_0265 */ +/* [local] */ + +typedef /* [hidden] */ +enum SPFILEMODE + { SPFM_OPEN_READONLY = 0, + SPFM_OPEN_READWRITE = SPFM_OPEN_READONLY + 1, + SPFM_CREATE = SPFM_OPEN_READWRITE + 1, + SPFM_CREATE_ALWAYS = SPFM_CREATE + 1, + SPFM_NUM_MODES = SPFM_CREATE_ALWAYS + 1 + } SPFILEMODE; + + + +extern RPC_IF_HANDLE __MIDL_itf_sapi_0265_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_sapi_0265_v0_0_s_ifspec; + +#ifndef __ISpStream_INTERFACE_DEFINED__ +#define __ISpStream_INTERFACE_DEFINED__ + +/* interface ISpStream */ +/* [restricted][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpStream; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("12E3CCA9-7518-44C5-A5E7-BA5A79CB929E") + ISpStream : public ISpStreamFormat + { + public: + virtual HRESULT STDMETHODCALLTYPE SetBaseStream( + IStream *pStream, + REFGUID rguidFormat, + const WAVEFORMATEX *pWaveFormatEx) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBaseStream( + IStream **ppStream) = 0; + + virtual HRESULT STDMETHODCALLTYPE BindToFile( + const WCHAR *pszFileName, + SPFILEMODE eMode, + const GUID *pFormatId, + const WAVEFORMATEX *pWaveFormatEx, + ULONGLONG ullEventInterest) = 0; + + virtual HRESULT STDMETHODCALLTYPE Close( void) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpStreamVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpStream * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpStream * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpStream * This); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Read )( + ISpStream * This, + /* [length_is][size_is][out] */ void *pv, + /* [in] */ ULONG cb, + /* [out] */ ULONG *pcbRead); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Write )( + ISpStream * This, + /* [size_is][in] */ const void *pv, + /* [in] */ ULONG cb, + /* [out] */ ULONG *pcbWritten); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Seek )( + ISpStream * This, + /* [in] */ LARGE_INTEGER dlibMove, + /* [in] */ DWORD dwOrigin, + /* [out] */ ULARGE_INTEGER *plibNewPosition); + + HRESULT ( STDMETHODCALLTYPE *SetSize )( + ISpStream * This, + /* [in] */ ULARGE_INTEGER libNewSize); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *CopyTo )( + ISpStream * This, + /* [unique][in] */ IStream *pstm, + /* [in] */ ULARGE_INTEGER cb, + /* [out] */ ULARGE_INTEGER *pcbRead, + /* [out] */ ULARGE_INTEGER *pcbWritten); + + HRESULT ( STDMETHODCALLTYPE *Commit )( + ISpStream * This, + /* [in] */ DWORD grfCommitFlags); + + HRESULT ( STDMETHODCALLTYPE *Revert )( + ISpStream * This); + + HRESULT ( STDMETHODCALLTYPE *LockRegion )( + ISpStream * This, + /* [in] */ ULARGE_INTEGER libOffset, + /* [in] */ ULARGE_INTEGER cb, + /* [in] */ DWORD dwLockType); + + HRESULT ( STDMETHODCALLTYPE *UnlockRegion )( + ISpStream * This, + /* [in] */ ULARGE_INTEGER libOffset, + /* [in] */ ULARGE_INTEGER cb, + /* [in] */ DWORD dwLockType); + + HRESULT ( STDMETHODCALLTYPE *Stat )( + ISpStream * This, + /* [out] */ STATSTG *pstatstg, + /* [in] */ DWORD grfStatFlag); + + HRESULT ( STDMETHODCALLTYPE *Clone )( + ISpStream * This, + /* [out] */ IStream **ppstm); + + HRESULT ( STDMETHODCALLTYPE *GetFormat )( + ISpStream * This, + GUID *pguidFormatId, + WAVEFORMATEX **ppCoMemWaveFormatEx); + + HRESULT ( STDMETHODCALLTYPE *SetBaseStream )( + ISpStream * This, + IStream *pStream, + REFGUID rguidFormat, + const WAVEFORMATEX *pWaveFormatEx); + + HRESULT ( STDMETHODCALLTYPE *GetBaseStream )( + ISpStream * This, + IStream **ppStream); + + HRESULT ( STDMETHODCALLTYPE *BindToFile )( + ISpStream * This, + const WCHAR *pszFileName, + SPFILEMODE eMode, + const GUID *pFormatId, + const WAVEFORMATEX *pWaveFormatEx, + ULONGLONG ullEventInterest); + + HRESULT ( STDMETHODCALLTYPE *Close )( + ISpStream * This); + + END_INTERFACE + } ISpStreamVtbl; + + interface ISpStream + { + CONST_VTBL struct ISpStreamVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpStream_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpStream_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpStream_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpStream_Read(This,pv,cb,pcbRead) \ + (This)->lpVtbl -> Read(This,pv,cb,pcbRead) + +#define ISpStream_Write(This,pv,cb,pcbWritten) \ + (This)->lpVtbl -> Write(This,pv,cb,pcbWritten) + + +#define ISpStream_Seek(This,dlibMove,dwOrigin,plibNewPosition) \ + (This)->lpVtbl -> Seek(This,dlibMove,dwOrigin,plibNewPosition) + +#define ISpStream_SetSize(This,libNewSize) \ + (This)->lpVtbl -> SetSize(This,libNewSize) + +#define ISpStream_CopyTo(This,pstm,cb,pcbRead,pcbWritten) \ + (This)->lpVtbl -> CopyTo(This,pstm,cb,pcbRead,pcbWritten) + +#define ISpStream_Commit(This,grfCommitFlags) \ + (This)->lpVtbl -> Commit(This,grfCommitFlags) + +#define ISpStream_Revert(This) \ + (This)->lpVtbl -> Revert(This) + +#define ISpStream_LockRegion(This,libOffset,cb,dwLockType) \ + (This)->lpVtbl -> LockRegion(This,libOffset,cb,dwLockType) + +#define ISpStream_UnlockRegion(This,libOffset,cb,dwLockType) \ + (This)->lpVtbl -> UnlockRegion(This,libOffset,cb,dwLockType) + +#define ISpStream_Stat(This,pstatstg,grfStatFlag) \ + (This)->lpVtbl -> Stat(This,pstatstg,grfStatFlag) + +#define ISpStream_Clone(This,ppstm) \ + (This)->lpVtbl -> Clone(This,ppstm) + + +#define ISpStream_GetFormat(This,pguidFormatId,ppCoMemWaveFormatEx) \ + (This)->lpVtbl -> GetFormat(This,pguidFormatId,ppCoMemWaveFormatEx) + + +#define ISpStream_SetBaseStream(This,pStream,rguidFormat,pWaveFormatEx) \ + (This)->lpVtbl -> SetBaseStream(This,pStream,rguidFormat,pWaveFormatEx) + +#define ISpStream_GetBaseStream(This,ppStream) \ + (This)->lpVtbl -> GetBaseStream(This,ppStream) + +#define ISpStream_BindToFile(This,pszFileName,eMode,pFormatId,pWaveFormatEx,ullEventInterest) \ + (This)->lpVtbl -> BindToFile(This,pszFileName,eMode,pFormatId,pWaveFormatEx,ullEventInterest) + +#define ISpStream_Close(This) \ + (This)->lpVtbl -> Close(This) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpStream_SetBaseStream_Proxy( + ISpStream * This, + IStream *pStream, + REFGUID rguidFormat, + const WAVEFORMATEX *pWaveFormatEx); + + +void __RPC_STUB ISpStream_SetBaseStream_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpStream_GetBaseStream_Proxy( + ISpStream * This, + IStream **ppStream); + + +void __RPC_STUB ISpStream_GetBaseStream_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpStream_BindToFile_Proxy( + ISpStream * This, + const WCHAR *pszFileName, + SPFILEMODE eMode, + const GUID *pFormatId, + const WAVEFORMATEX *pWaveFormatEx, + ULONGLONG ullEventInterest); + + +void __RPC_STUB ISpStream_BindToFile_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpStream_Close_Proxy( + ISpStream * This); + + +void __RPC_STUB ISpStream_Close_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpStream_INTERFACE_DEFINED__ */ + + +#ifndef __ISpStreamFormatConverter_INTERFACE_DEFINED__ +#define __ISpStreamFormatConverter_INTERFACE_DEFINED__ + +/* interface ISpStreamFormatConverter */ +/* [restricted][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpStreamFormatConverter; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("678A932C-EA71-4446-9B41-78FDA6280A29") + ISpStreamFormatConverter : public ISpStreamFormat + { + public: + virtual HRESULT STDMETHODCALLTYPE SetBaseStream( + /* [in] */ ISpStreamFormat *pStream, + /* [in] */ BOOL fSetFormatToBaseStreamFormat, + /* [in] */ BOOL fWriteToBaseStream) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBaseStream( + /* [out] */ ISpStreamFormat **ppStream) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetFormat( + /* [in] */ REFGUID rguidFormatIdOfConvertedStream, + /* [in] */ const WAVEFORMATEX *pWaveFormatExOfConvertedStream) = 0; + + virtual HRESULT STDMETHODCALLTYPE ResetSeekPosition( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE ScaleConvertedToBaseOffset( + /* [in] */ ULONGLONG ullOffsetConvertedStream, + /* [out] */ ULONGLONG *pullOffsetBaseStream) = 0; + + virtual HRESULT STDMETHODCALLTYPE ScaleBaseToConvertedOffset( + /* [in] */ ULONGLONG ullOffsetBaseStream, + /* [out] */ ULONGLONG *pullOffsetConvertedStream) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpStreamFormatConverterVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpStreamFormatConverter * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpStreamFormatConverter * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpStreamFormatConverter * This); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Read )( + ISpStreamFormatConverter * This, + /* [length_is][size_is][out] */ void *pv, + /* [in] */ ULONG cb, + /* [out] */ ULONG *pcbRead); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Write )( + ISpStreamFormatConverter * This, + /* [size_is][in] */ const void *pv, + /* [in] */ ULONG cb, + /* [out] */ ULONG *pcbWritten); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Seek )( + ISpStreamFormatConverter * This, + /* [in] */ LARGE_INTEGER dlibMove, + /* [in] */ DWORD dwOrigin, + /* [out] */ ULARGE_INTEGER *plibNewPosition); + + HRESULT ( STDMETHODCALLTYPE *SetSize )( + ISpStreamFormatConverter * This, + /* [in] */ ULARGE_INTEGER libNewSize); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *CopyTo )( + ISpStreamFormatConverter * This, + /* [unique][in] */ IStream *pstm, + /* [in] */ ULARGE_INTEGER cb, + /* [out] */ ULARGE_INTEGER *pcbRead, + /* [out] */ ULARGE_INTEGER *pcbWritten); + + HRESULT ( STDMETHODCALLTYPE *Commit )( + ISpStreamFormatConverter * This, + /* [in] */ DWORD grfCommitFlags); + + HRESULT ( STDMETHODCALLTYPE *Revert )( + ISpStreamFormatConverter * This); + + HRESULT ( STDMETHODCALLTYPE *LockRegion )( + ISpStreamFormatConverter * This, + /* [in] */ ULARGE_INTEGER libOffset, + /* [in] */ ULARGE_INTEGER cb, + /* [in] */ DWORD dwLockType); + + HRESULT ( STDMETHODCALLTYPE *UnlockRegion )( + ISpStreamFormatConverter * This, + /* [in] */ ULARGE_INTEGER libOffset, + /* [in] */ ULARGE_INTEGER cb, + /* [in] */ DWORD dwLockType); + + HRESULT ( STDMETHODCALLTYPE *Stat )( + ISpStreamFormatConverter * This, + /* [out] */ STATSTG *pstatstg, + /* [in] */ DWORD grfStatFlag); + + HRESULT ( STDMETHODCALLTYPE *Clone )( + ISpStreamFormatConverter * This, + /* [out] */ IStream **ppstm); + + HRESULT ( STDMETHODCALLTYPE *GetFormat )( + ISpStreamFormatConverter * This, + GUID *pguidFormatId, + WAVEFORMATEX **ppCoMemWaveFormatEx); + + HRESULT ( STDMETHODCALLTYPE *SetBaseStream )( + ISpStreamFormatConverter * This, + /* [in] */ ISpStreamFormat *pStream, + /* [in] */ BOOL fSetFormatToBaseStreamFormat, + /* [in] */ BOOL fWriteToBaseStream); + + HRESULT ( STDMETHODCALLTYPE *GetBaseStream )( + ISpStreamFormatConverter * This, + /* [out] */ ISpStreamFormat **ppStream); + + HRESULT ( STDMETHODCALLTYPE *SetFormat )( + ISpStreamFormatConverter * This, + /* [in] */ REFGUID rguidFormatIdOfConvertedStream, + /* [in] */ const WAVEFORMATEX *pWaveFormatExOfConvertedStream); + + HRESULT ( STDMETHODCALLTYPE *ResetSeekPosition )( + ISpStreamFormatConverter * This); + + HRESULT ( STDMETHODCALLTYPE *ScaleConvertedToBaseOffset )( + ISpStreamFormatConverter * This, + /* [in] */ ULONGLONG ullOffsetConvertedStream, + /* [out] */ ULONGLONG *pullOffsetBaseStream); + + HRESULT ( STDMETHODCALLTYPE *ScaleBaseToConvertedOffset )( + ISpStreamFormatConverter * This, + /* [in] */ ULONGLONG ullOffsetBaseStream, + /* [out] */ ULONGLONG *pullOffsetConvertedStream); + + END_INTERFACE + } ISpStreamFormatConverterVtbl; + + interface ISpStreamFormatConverter + { + CONST_VTBL struct ISpStreamFormatConverterVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpStreamFormatConverter_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpStreamFormatConverter_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpStreamFormatConverter_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpStreamFormatConverter_Read(This,pv,cb,pcbRead) \ + (This)->lpVtbl -> Read(This,pv,cb,pcbRead) + +#define ISpStreamFormatConverter_Write(This,pv,cb,pcbWritten) \ + (This)->lpVtbl -> Write(This,pv,cb,pcbWritten) + + +#define ISpStreamFormatConverter_Seek(This,dlibMove,dwOrigin,plibNewPosition) \ + (This)->lpVtbl -> Seek(This,dlibMove,dwOrigin,plibNewPosition) + +#define ISpStreamFormatConverter_SetSize(This,libNewSize) \ + (This)->lpVtbl -> SetSize(This,libNewSize) + +#define ISpStreamFormatConverter_CopyTo(This,pstm,cb,pcbRead,pcbWritten) \ + (This)->lpVtbl -> CopyTo(This,pstm,cb,pcbRead,pcbWritten) + +#define ISpStreamFormatConverter_Commit(This,grfCommitFlags) \ + (This)->lpVtbl -> Commit(This,grfCommitFlags) + +#define ISpStreamFormatConverter_Revert(This) \ + (This)->lpVtbl -> Revert(This) + +#define ISpStreamFormatConverter_LockRegion(This,libOffset,cb,dwLockType) \ + (This)->lpVtbl -> LockRegion(This,libOffset,cb,dwLockType) + +#define ISpStreamFormatConverter_UnlockRegion(This,libOffset,cb,dwLockType) \ + (This)->lpVtbl -> UnlockRegion(This,libOffset,cb,dwLockType) + +#define ISpStreamFormatConverter_Stat(This,pstatstg,grfStatFlag) \ + (This)->lpVtbl -> Stat(This,pstatstg,grfStatFlag) + +#define ISpStreamFormatConverter_Clone(This,ppstm) \ + (This)->lpVtbl -> Clone(This,ppstm) + + +#define ISpStreamFormatConverter_GetFormat(This,pguidFormatId,ppCoMemWaveFormatEx) \ + (This)->lpVtbl -> GetFormat(This,pguidFormatId,ppCoMemWaveFormatEx) + + +#define ISpStreamFormatConverter_SetBaseStream(This,pStream,fSetFormatToBaseStreamFormat,fWriteToBaseStream) \ + (This)->lpVtbl -> SetBaseStream(This,pStream,fSetFormatToBaseStreamFormat,fWriteToBaseStream) + +#define ISpStreamFormatConverter_GetBaseStream(This,ppStream) \ + (This)->lpVtbl -> GetBaseStream(This,ppStream) + +#define ISpStreamFormatConverter_SetFormat(This,rguidFormatIdOfConvertedStream,pWaveFormatExOfConvertedStream) \ + (This)->lpVtbl -> SetFormat(This,rguidFormatIdOfConvertedStream,pWaveFormatExOfConvertedStream) + +#define ISpStreamFormatConverter_ResetSeekPosition(This) \ + (This)->lpVtbl -> ResetSeekPosition(This) + +#define ISpStreamFormatConverter_ScaleConvertedToBaseOffset(This,ullOffsetConvertedStream,pullOffsetBaseStream) \ + (This)->lpVtbl -> ScaleConvertedToBaseOffset(This,ullOffsetConvertedStream,pullOffsetBaseStream) + +#define ISpStreamFormatConverter_ScaleBaseToConvertedOffset(This,ullOffsetBaseStream,pullOffsetConvertedStream) \ + (This)->lpVtbl -> ScaleBaseToConvertedOffset(This,ullOffsetBaseStream,pullOffsetConvertedStream) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpStreamFormatConverter_SetBaseStream_Proxy( + ISpStreamFormatConverter * This, + /* [in] */ ISpStreamFormat *pStream, + /* [in] */ BOOL fSetFormatToBaseStreamFormat, + /* [in] */ BOOL fWriteToBaseStream); + + +void __RPC_STUB ISpStreamFormatConverter_SetBaseStream_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpStreamFormatConverter_GetBaseStream_Proxy( + ISpStreamFormatConverter * This, + /* [out] */ ISpStreamFormat **ppStream); + + +void __RPC_STUB ISpStreamFormatConverter_GetBaseStream_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpStreamFormatConverter_SetFormat_Proxy( + ISpStreamFormatConverter * This, + /* [in] */ REFGUID rguidFormatIdOfConvertedStream, + /* [in] */ const WAVEFORMATEX *pWaveFormatExOfConvertedStream); + + +void __RPC_STUB ISpStreamFormatConverter_SetFormat_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpStreamFormatConverter_ResetSeekPosition_Proxy( + ISpStreamFormatConverter * This); + + +void __RPC_STUB ISpStreamFormatConverter_ResetSeekPosition_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpStreamFormatConverter_ScaleConvertedToBaseOffset_Proxy( + ISpStreamFormatConverter * This, + /* [in] */ ULONGLONG ullOffsetConvertedStream, + /* [out] */ ULONGLONG *pullOffsetBaseStream); + + +void __RPC_STUB ISpStreamFormatConverter_ScaleConvertedToBaseOffset_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpStreamFormatConverter_ScaleBaseToConvertedOffset_Proxy( + ISpStreamFormatConverter * This, + /* [in] */ ULONGLONG ullOffsetBaseStream, + /* [out] */ ULONGLONG *pullOffsetConvertedStream); + + +void __RPC_STUB ISpStreamFormatConverter_ScaleBaseToConvertedOffset_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpStreamFormatConverter_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_sapi_0267 */ +/* [local] */ + +typedef /* [hidden] */ +enum _SPAUDIOSTATE + { SPAS_CLOSED = 0, + SPAS_STOP = SPAS_CLOSED + 1, + SPAS_PAUSE = SPAS_STOP + 1, + SPAS_RUN = SPAS_PAUSE + 1 + } SPAUDIOSTATE; + +typedef /* [hidden][restricted] */ struct SPAUDIOSTATUS + { + long cbFreeBuffSpace; + ULONG cbNonBlockingIO; + SPAUDIOSTATE State; + ULONGLONG CurSeekPos; + ULONGLONG CurDevicePos; + DWORD dwReserved1; + DWORD dwReserved2; + } SPAUDIOSTATUS; + +typedef /* [hidden][restricted] */ struct SPAUDIOBUFFERINFO + { + ULONG ulMsMinNotification; + ULONG ulMsBufferSize; + ULONG ulMsEventBias; + } SPAUDIOBUFFERINFO; + + + +extern RPC_IF_HANDLE __MIDL_itf_sapi_0267_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_sapi_0267_v0_0_s_ifspec; + +#ifndef __ISpAudio_INTERFACE_DEFINED__ +#define __ISpAudio_INTERFACE_DEFINED__ + +/* interface ISpAudio */ +/* [restricted][local][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpAudio; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("C05C768F-FAE8-4EC2-8E07-338321C12452") + ISpAudio : public ISpStreamFormat + { + public: + virtual HRESULT STDMETHODCALLTYPE SetState( + /* [in] */ SPAUDIOSTATE NewState, + /* [in] */ ULONGLONG ullReserved) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetFormat( + /* [in] */ REFGUID rguidFmtId, + /* [in] */ const WAVEFORMATEX *pWaveFormatEx) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStatus( + /* [out] */ SPAUDIOSTATUS *pStatus) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetBufferInfo( + /* [in] */ const SPAUDIOBUFFERINFO *pBuffInfo) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBufferInfo( + /* [out] */ SPAUDIOBUFFERINFO *pBuffInfo) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDefaultFormat( + /* [out] */ GUID *pFormatId, + /* [out] */ WAVEFORMATEX **ppCoMemWaveFormatEx) = 0; + + virtual HANDLE STDMETHODCALLTYPE EventHandle( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetVolumeLevel( + /* [out] */ ULONG *pLevel) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetVolumeLevel( + /* [in] */ ULONG Level) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBufferNotifySize( + /* [out] */ ULONG *pcbSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetBufferNotifySize( + /* [in] */ ULONG cbSize) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpAudioVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpAudio * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpAudio * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpAudio * This); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Read )( + ISpAudio * This, + /* [length_is][size_is][out] */ void *pv, + /* [in] */ ULONG cb, + /* [out] */ ULONG *pcbRead); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Write )( + ISpAudio * This, + /* [size_is][in] */ const void *pv, + /* [in] */ ULONG cb, + /* [out] */ ULONG *pcbWritten); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Seek )( + ISpAudio * This, + /* [in] */ LARGE_INTEGER dlibMove, + /* [in] */ DWORD dwOrigin, + /* [out] */ ULARGE_INTEGER *plibNewPosition); + + HRESULT ( STDMETHODCALLTYPE *SetSize )( + ISpAudio * This, + /* [in] */ ULARGE_INTEGER libNewSize); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *CopyTo )( + ISpAudio * This, + /* [unique][in] */ IStream *pstm, + /* [in] */ ULARGE_INTEGER cb, + /* [out] */ ULARGE_INTEGER *pcbRead, + /* [out] */ ULARGE_INTEGER *pcbWritten); + + HRESULT ( STDMETHODCALLTYPE *Commit )( + ISpAudio * This, + /* [in] */ DWORD grfCommitFlags); + + HRESULT ( STDMETHODCALLTYPE *Revert )( + ISpAudio * This); + + HRESULT ( STDMETHODCALLTYPE *LockRegion )( + ISpAudio * This, + /* [in] */ ULARGE_INTEGER libOffset, + /* [in] */ ULARGE_INTEGER cb, + /* [in] */ DWORD dwLockType); + + HRESULT ( STDMETHODCALLTYPE *UnlockRegion )( + ISpAudio * This, + /* [in] */ ULARGE_INTEGER libOffset, + /* [in] */ ULARGE_INTEGER cb, + /* [in] */ DWORD dwLockType); + + HRESULT ( STDMETHODCALLTYPE *Stat )( + ISpAudio * This, + /* [out] */ STATSTG *pstatstg, + /* [in] */ DWORD grfStatFlag); + + HRESULT ( STDMETHODCALLTYPE *Clone )( + ISpAudio * This, + /* [out] */ IStream **ppstm); + + HRESULT ( STDMETHODCALLTYPE *GetFormat )( + ISpAudio * This, + GUID *pguidFormatId, + WAVEFORMATEX **ppCoMemWaveFormatEx); + + HRESULT ( STDMETHODCALLTYPE *SetState )( + ISpAudio * This, + /* [in] */ SPAUDIOSTATE NewState, + /* [in] */ ULONGLONG ullReserved); + + HRESULT ( STDMETHODCALLTYPE *SetFormat )( + ISpAudio * This, + /* [in] */ REFGUID rguidFmtId, + /* [in] */ const WAVEFORMATEX *pWaveFormatEx); + + HRESULT ( STDMETHODCALLTYPE *GetStatus )( + ISpAudio * This, + /* [out] */ SPAUDIOSTATUS *pStatus); + + HRESULT ( STDMETHODCALLTYPE *SetBufferInfo )( + ISpAudio * This, + /* [in] */ const SPAUDIOBUFFERINFO *pBuffInfo); + + HRESULT ( STDMETHODCALLTYPE *GetBufferInfo )( + ISpAudio * This, + /* [out] */ SPAUDIOBUFFERINFO *pBuffInfo); + + HRESULT ( STDMETHODCALLTYPE *GetDefaultFormat )( + ISpAudio * This, + /* [out] */ GUID *pFormatId, + /* [out] */ WAVEFORMATEX **ppCoMemWaveFormatEx); + + HANDLE ( STDMETHODCALLTYPE *EventHandle )( + ISpAudio * This); + + HRESULT ( STDMETHODCALLTYPE *GetVolumeLevel )( + ISpAudio * This, + /* [out] */ ULONG *pLevel); + + HRESULT ( STDMETHODCALLTYPE *SetVolumeLevel )( + ISpAudio * This, + /* [in] */ ULONG Level); + + HRESULT ( STDMETHODCALLTYPE *GetBufferNotifySize )( + ISpAudio * This, + /* [out] */ ULONG *pcbSize); + + HRESULT ( STDMETHODCALLTYPE *SetBufferNotifySize )( + ISpAudio * This, + /* [in] */ ULONG cbSize); + + END_INTERFACE + } ISpAudioVtbl; + + interface ISpAudio + { + CONST_VTBL struct ISpAudioVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpAudio_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpAudio_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpAudio_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpAudio_Read(This,pv,cb,pcbRead) \ + (This)->lpVtbl -> Read(This,pv,cb,pcbRead) + +#define ISpAudio_Write(This,pv,cb,pcbWritten) \ + (This)->lpVtbl -> Write(This,pv,cb,pcbWritten) + + +#define ISpAudio_Seek(This,dlibMove,dwOrigin,plibNewPosition) \ + (This)->lpVtbl -> Seek(This,dlibMove,dwOrigin,plibNewPosition) + +#define ISpAudio_SetSize(This,libNewSize) \ + (This)->lpVtbl -> SetSize(This,libNewSize) + +#define ISpAudio_CopyTo(This,pstm,cb,pcbRead,pcbWritten) \ + (This)->lpVtbl -> CopyTo(This,pstm,cb,pcbRead,pcbWritten) + +#define ISpAudio_Commit(This,grfCommitFlags) \ + (This)->lpVtbl -> Commit(This,grfCommitFlags) + +#define ISpAudio_Revert(This) \ + (This)->lpVtbl -> Revert(This) + +#define ISpAudio_LockRegion(This,libOffset,cb,dwLockType) \ + (This)->lpVtbl -> LockRegion(This,libOffset,cb,dwLockType) + +#define ISpAudio_UnlockRegion(This,libOffset,cb,dwLockType) \ + (This)->lpVtbl -> UnlockRegion(This,libOffset,cb,dwLockType) + +#define ISpAudio_Stat(This,pstatstg,grfStatFlag) \ + (This)->lpVtbl -> Stat(This,pstatstg,grfStatFlag) + +#define ISpAudio_Clone(This,ppstm) \ + (This)->lpVtbl -> Clone(This,ppstm) + + +#define ISpAudio_GetFormat(This,pguidFormatId,ppCoMemWaveFormatEx) \ + (This)->lpVtbl -> GetFormat(This,pguidFormatId,ppCoMemWaveFormatEx) + + +#define ISpAudio_SetState(This,NewState,ullReserved) \ + (This)->lpVtbl -> SetState(This,NewState,ullReserved) + +#define ISpAudio_SetFormat(This,rguidFmtId,pWaveFormatEx) \ + (This)->lpVtbl -> SetFormat(This,rguidFmtId,pWaveFormatEx) + +#define ISpAudio_GetStatus(This,pStatus) \ + (This)->lpVtbl -> GetStatus(This,pStatus) + +#define ISpAudio_SetBufferInfo(This,pBuffInfo) \ + (This)->lpVtbl -> SetBufferInfo(This,pBuffInfo) + +#define ISpAudio_GetBufferInfo(This,pBuffInfo) \ + (This)->lpVtbl -> GetBufferInfo(This,pBuffInfo) + +#define ISpAudio_GetDefaultFormat(This,pFormatId,ppCoMemWaveFormatEx) \ + (This)->lpVtbl -> GetDefaultFormat(This,pFormatId,ppCoMemWaveFormatEx) + +#define ISpAudio_EventHandle(This) \ + (This)->lpVtbl -> EventHandle(This) + +#define ISpAudio_GetVolumeLevel(This,pLevel) \ + (This)->lpVtbl -> GetVolumeLevel(This,pLevel) + +#define ISpAudio_SetVolumeLevel(This,Level) \ + (This)->lpVtbl -> SetVolumeLevel(This,Level) + +#define ISpAudio_GetBufferNotifySize(This,pcbSize) \ + (This)->lpVtbl -> GetBufferNotifySize(This,pcbSize) + +#define ISpAudio_SetBufferNotifySize(This,cbSize) \ + (This)->lpVtbl -> SetBufferNotifySize(This,cbSize) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpAudio_SetState_Proxy( + ISpAudio * This, + /* [in] */ SPAUDIOSTATE NewState, + /* [in] */ ULONGLONG ullReserved); + + +void __RPC_STUB ISpAudio_SetState_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpAudio_SetFormat_Proxy( + ISpAudio * This, + /* [in] */ REFGUID rguidFmtId, + /* [in] */ const WAVEFORMATEX *pWaveFormatEx); + + +void __RPC_STUB ISpAudio_SetFormat_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpAudio_GetStatus_Proxy( + ISpAudio * This, + /* [out] */ SPAUDIOSTATUS *pStatus); + + +void __RPC_STUB ISpAudio_GetStatus_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpAudio_SetBufferInfo_Proxy( + ISpAudio * This, + /* [in] */ const SPAUDIOBUFFERINFO *pBuffInfo); + + +void __RPC_STUB ISpAudio_SetBufferInfo_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpAudio_GetBufferInfo_Proxy( + ISpAudio * This, + /* [out] */ SPAUDIOBUFFERINFO *pBuffInfo); + + +void __RPC_STUB ISpAudio_GetBufferInfo_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpAudio_GetDefaultFormat_Proxy( + ISpAudio * This, + /* [out] */ GUID *pFormatId, + /* [out] */ WAVEFORMATEX **ppCoMemWaveFormatEx); + + +void __RPC_STUB ISpAudio_GetDefaultFormat_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HANDLE STDMETHODCALLTYPE ISpAudio_EventHandle_Proxy( + ISpAudio * This); + + +void __RPC_STUB ISpAudio_EventHandle_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpAudio_GetVolumeLevel_Proxy( + ISpAudio * This, + /* [out] */ ULONG *pLevel); + + +void __RPC_STUB ISpAudio_GetVolumeLevel_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpAudio_SetVolumeLevel_Proxy( + ISpAudio * This, + /* [in] */ ULONG Level); + + +void __RPC_STUB ISpAudio_SetVolumeLevel_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpAudio_GetBufferNotifySize_Proxy( + ISpAudio * This, + /* [out] */ ULONG *pcbSize); + + +void __RPC_STUB ISpAudio_GetBufferNotifySize_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpAudio_SetBufferNotifySize_Proxy( + ISpAudio * This, + /* [in] */ ULONG cbSize); + + +void __RPC_STUB ISpAudio_SetBufferNotifySize_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpAudio_INTERFACE_DEFINED__ */ + + +#ifndef __ISpMMSysAudio_INTERFACE_DEFINED__ +#define __ISpMMSysAudio_INTERFACE_DEFINED__ + +/* interface ISpMMSysAudio */ +/* [restricted][local][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpMMSysAudio; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("15806F6E-1D70-4B48-98E6-3B1A007509AB") + ISpMMSysAudio : public ISpAudio + { + public: + virtual HRESULT STDMETHODCALLTYPE GetDeviceId( + /* [out] */ UINT *puDeviceId) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetDeviceId( + /* [in] */ UINT uDeviceId) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMMHandle( + void **pHandle) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetLineId( + /* [out] */ UINT *puLineId) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetLineId( + /* [in] */ UINT uLineId) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpMMSysAudioVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpMMSysAudio * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpMMSysAudio * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpMMSysAudio * This); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Read )( + ISpMMSysAudio * This, + /* [length_is][size_is][out] */ void *pv, + /* [in] */ ULONG cb, + /* [out] */ ULONG *pcbRead); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Write )( + ISpMMSysAudio * This, + /* [size_is][in] */ const void *pv, + /* [in] */ ULONG cb, + /* [out] */ ULONG *pcbWritten); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Seek )( + ISpMMSysAudio * This, + /* [in] */ LARGE_INTEGER dlibMove, + /* [in] */ DWORD dwOrigin, + /* [out] */ ULARGE_INTEGER *plibNewPosition); + + HRESULT ( STDMETHODCALLTYPE *SetSize )( + ISpMMSysAudio * This, + /* [in] */ ULARGE_INTEGER libNewSize); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *CopyTo )( + ISpMMSysAudio * This, + /* [unique][in] */ IStream *pstm, + /* [in] */ ULARGE_INTEGER cb, + /* [out] */ ULARGE_INTEGER *pcbRead, + /* [out] */ ULARGE_INTEGER *pcbWritten); + + HRESULT ( STDMETHODCALLTYPE *Commit )( + ISpMMSysAudio * This, + /* [in] */ DWORD grfCommitFlags); + + HRESULT ( STDMETHODCALLTYPE *Revert )( + ISpMMSysAudio * This); + + HRESULT ( STDMETHODCALLTYPE *LockRegion )( + ISpMMSysAudio * This, + /* [in] */ ULARGE_INTEGER libOffset, + /* [in] */ ULARGE_INTEGER cb, + /* [in] */ DWORD dwLockType); + + HRESULT ( STDMETHODCALLTYPE *UnlockRegion )( + ISpMMSysAudio * This, + /* [in] */ ULARGE_INTEGER libOffset, + /* [in] */ ULARGE_INTEGER cb, + /* [in] */ DWORD dwLockType); + + HRESULT ( STDMETHODCALLTYPE *Stat )( + ISpMMSysAudio * This, + /* [out] */ STATSTG *pstatstg, + /* [in] */ DWORD grfStatFlag); + + HRESULT ( STDMETHODCALLTYPE *Clone )( + ISpMMSysAudio * This, + /* [out] */ IStream **ppstm); + + HRESULT ( STDMETHODCALLTYPE *GetFormat )( + ISpMMSysAudio * This, + GUID *pguidFormatId, + WAVEFORMATEX **ppCoMemWaveFormatEx); + + HRESULT ( STDMETHODCALLTYPE *SetState )( + ISpMMSysAudio * This, + /* [in] */ SPAUDIOSTATE NewState, + /* [in] */ ULONGLONG ullReserved); + + HRESULT ( STDMETHODCALLTYPE *SetFormat )( + ISpMMSysAudio * This, + /* [in] */ REFGUID rguidFmtId, + /* [in] */ const WAVEFORMATEX *pWaveFormatEx); + + HRESULT ( STDMETHODCALLTYPE *GetStatus )( + ISpMMSysAudio * This, + /* [out] */ SPAUDIOSTATUS *pStatus); + + HRESULT ( STDMETHODCALLTYPE *SetBufferInfo )( + ISpMMSysAudio * This, + /* [in] */ const SPAUDIOBUFFERINFO *pBuffInfo); + + HRESULT ( STDMETHODCALLTYPE *GetBufferInfo )( + ISpMMSysAudio * This, + /* [out] */ SPAUDIOBUFFERINFO *pBuffInfo); + + HRESULT ( STDMETHODCALLTYPE *GetDefaultFormat )( + ISpMMSysAudio * This, + /* [out] */ GUID *pFormatId, + /* [out] */ WAVEFORMATEX **ppCoMemWaveFormatEx); + + HANDLE ( STDMETHODCALLTYPE *EventHandle )( + ISpMMSysAudio * This); + + HRESULT ( STDMETHODCALLTYPE *GetVolumeLevel )( + ISpMMSysAudio * This, + /* [out] */ ULONG *pLevel); + + HRESULT ( STDMETHODCALLTYPE *SetVolumeLevel )( + ISpMMSysAudio * This, + /* [in] */ ULONG Level); + + HRESULT ( STDMETHODCALLTYPE *GetBufferNotifySize )( + ISpMMSysAudio * This, + /* [out] */ ULONG *pcbSize); + + HRESULT ( STDMETHODCALLTYPE *SetBufferNotifySize )( + ISpMMSysAudio * This, + /* [in] */ ULONG cbSize); + + HRESULT ( STDMETHODCALLTYPE *GetDeviceId )( + ISpMMSysAudio * This, + /* [out] */ UINT *puDeviceId); + + HRESULT ( STDMETHODCALLTYPE *SetDeviceId )( + ISpMMSysAudio * This, + /* [in] */ UINT uDeviceId); + + HRESULT ( STDMETHODCALLTYPE *GetMMHandle )( + ISpMMSysAudio * This, + void **pHandle); + + HRESULT ( STDMETHODCALLTYPE *GetLineId )( + ISpMMSysAudio * This, + /* [out] */ UINT *puLineId); + + HRESULT ( STDMETHODCALLTYPE *SetLineId )( + ISpMMSysAudio * This, + /* [in] */ UINT uLineId); + + END_INTERFACE + } ISpMMSysAudioVtbl; + + interface ISpMMSysAudio + { + CONST_VTBL struct ISpMMSysAudioVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpMMSysAudio_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpMMSysAudio_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpMMSysAudio_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpMMSysAudio_Read(This,pv,cb,pcbRead) \ + (This)->lpVtbl -> Read(This,pv,cb,pcbRead) + +#define ISpMMSysAudio_Write(This,pv,cb,pcbWritten) \ + (This)->lpVtbl -> Write(This,pv,cb,pcbWritten) + + +#define ISpMMSysAudio_Seek(This,dlibMove,dwOrigin,plibNewPosition) \ + (This)->lpVtbl -> Seek(This,dlibMove,dwOrigin,plibNewPosition) + +#define ISpMMSysAudio_SetSize(This,libNewSize) \ + (This)->lpVtbl -> SetSize(This,libNewSize) + +#define ISpMMSysAudio_CopyTo(This,pstm,cb,pcbRead,pcbWritten) \ + (This)->lpVtbl -> CopyTo(This,pstm,cb,pcbRead,pcbWritten) + +#define ISpMMSysAudio_Commit(This,grfCommitFlags) \ + (This)->lpVtbl -> Commit(This,grfCommitFlags) + +#define ISpMMSysAudio_Revert(This) \ + (This)->lpVtbl -> Revert(This) + +#define ISpMMSysAudio_LockRegion(This,libOffset,cb,dwLockType) \ + (This)->lpVtbl -> LockRegion(This,libOffset,cb,dwLockType) + +#define ISpMMSysAudio_UnlockRegion(This,libOffset,cb,dwLockType) \ + (This)->lpVtbl -> UnlockRegion(This,libOffset,cb,dwLockType) + +#define ISpMMSysAudio_Stat(This,pstatstg,grfStatFlag) \ + (This)->lpVtbl -> Stat(This,pstatstg,grfStatFlag) + +#define ISpMMSysAudio_Clone(This,ppstm) \ + (This)->lpVtbl -> Clone(This,ppstm) + + +#define ISpMMSysAudio_GetFormat(This,pguidFormatId,ppCoMemWaveFormatEx) \ + (This)->lpVtbl -> GetFormat(This,pguidFormatId,ppCoMemWaveFormatEx) + + +#define ISpMMSysAudio_SetState(This,NewState,ullReserved) \ + (This)->lpVtbl -> SetState(This,NewState,ullReserved) + +#define ISpMMSysAudio_SetFormat(This,rguidFmtId,pWaveFormatEx) \ + (This)->lpVtbl -> SetFormat(This,rguidFmtId,pWaveFormatEx) + +#define ISpMMSysAudio_GetStatus(This,pStatus) \ + (This)->lpVtbl -> GetStatus(This,pStatus) + +#define ISpMMSysAudio_SetBufferInfo(This,pBuffInfo) \ + (This)->lpVtbl -> SetBufferInfo(This,pBuffInfo) + +#define ISpMMSysAudio_GetBufferInfo(This,pBuffInfo) \ + (This)->lpVtbl -> GetBufferInfo(This,pBuffInfo) + +#define ISpMMSysAudio_GetDefaultFormat(This,pFormatId,ppCoMemWaveFormatEx) \ + (This)->lpVtbl -> GetDefaultFormat(This,pFormatId,ppCoMemWaveFormatEx) + +#define ISpMMSysAudio_EventHandle(This) \ + (This)->lpVtbl -> EventHandle(This) + +#define ISpMMSysAudio_GetVolumeLevel(This,pLevel) \ + (This)->lpVtbl -> GetVolumeLevel(This,pLevel) + +#define ISpMMSysAudio_SetVolumeLevel(This,Level) \ + (This)->lpVtbl -> SetVolumeLevel(This,Level) + +#define ISpMMSysAudio_GetBufferNotifySize(This,pcbSize) \ + (This)->lpVtbl -> GetBufferNotifySize(This,pcbSize) + +#define ISpMMSysAudio_SetBufferNotifySize(This,cbSize) \ + (This)->lpVtbl -> SetBufferNotifySize(This,cbSize) + + +#define ISpMMSysAudio_GetDeviceId(This,puDeviceId) \ + (This)->lpVtbl -> GetDeviceId(This,puDeviceId) + +#define ISpMMSysAudio_SetDeviceId(This,uDeviceId) \ + (This)->lpVtbl -> SetDeviceId(This,uDeviceId) + +#define ISpMMSysAudio_GetMMHandle(This,pHandle) \ + (This)->lpVtbl -> GetMMHandle(This,pHandle) + +#define ISpMMSysAudio_GetLineId(This,puLineId) \ + (This)->lpVtbl -> GetLineId(This,puLineId) + +#define ISpMMSysAudio_SetLineId(This,uLineId) \ + (This)->lpVtbl -> SetLineId(This,uLineId) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpMMSysAudio_GetDeviceId_Proxy( + ISpMMSysAudio * This, + /* [out] */ UINT *puDeviceId); + + +void __RPC_STUB ISpMMSysAudio_GetDeviceId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpMMSysAudio_SetDeviceId_Proxy( + ISpMMSysAudio * This, + /* [in] */ UINT uDeviceId); + + +void __RPC_STUB ISpMMSysAudio_SetDeviceId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpMMSysAudio_GetMMHandle_Proxy( + ISpMMSysAudio * This, + void **pHandle); + + +void __RPC_STUB ISpMMSysAudio_GetMMHandle_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpMMSysAudio_GetLineId_Proxy( + ISpMMSysAudio * This, + /* [out] */ UINT *puLineId); + + +void __RPC_STUB ISpMMSysAudio_GetLineId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpMMSysAudio_SetLineId_Proxy( + ISpMMSysAudio * This, + /* [in] */ UINT uLineId); + + +void __RPC_STUB ISpMMSysAudio_SetLineId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpMMSysAudio_INTERFACE_DEFINED__ */ + + +#ifndef __ISpTranscript_INTERFACE_DEFINED__ +#define __ISpTranscript_INTERFACE_DEFINED__ + +/* interface ISpTranscript */ +/* [restricted][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpTranscript; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("10F63BCE-201A-11D3-AC70-00C04F8EE6C0") + ISpTranscript : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetTranscript( + /* [string][out] */ WCHAR **ppszTranscript) = 0; + + virtual HRESULT STDMETHODCALLTYPE AppendTranscript( + /* [string][in] */ const WCHAR *pszTranscript) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpTranscriptVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpTranscript * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpTranscript * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpTranscript * This); + + HRESULT ( STDMETHODCALLTYPE *GetTranscript )( + ISpTranscript * This, + /* [string][out] */ WCHAR **ppszTranscript); + + HRESULT ( STDMETHODCALLTYPE *AppendTranscript )( + ISpTranscript * This, + /* [string][in] */ const WCHAR *pszTranscript); + + END_INTERFACE + } ISpTranscriptVtbl; + + interface ISpTranscript + { + CONST_VTBL struct ISpTranscriptVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpTranscript_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpTranscript_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpTranscript_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpTranscript_GetTranscript(This,ppszTranscript) \ + (This)->lpVtbl -> GetTranscript(This,ppszTranscript) + +#define ISpTranscript_AppendTranscript(This,pszTranscript) \ + (This)->lpVtbl -> AppendTranscript(This,pszTranscript) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpTranscript_GetTranscript_Proxy( + ISpTranscript * This, + /* [string][out] */ WCHAR **ppszTranscript); + + +void __RPC_STUB ISpTranscript_GetTranscript_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpTranscript_AppendTranscript_Proxy( + ISpTranscript * This, + /* [string][in] */ const WCHAR *pszTranscript); + + +void __RPC_STUB ISpTranscript_AppendTranscript_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpTranscript_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_sapi_0270 */ +/* [local] */ + +typedef /* [hidden] */ +enum SPDISPLYATTRIBUTES + { SPAF_ONE_TRAILING_SPACE = 0x2, + SPAF_TWO_TRAILING_SPACES = 0x4, + SPAF_CONSUME_LEADING_SPACES = 0x8, + SPAF_ALL = 0xf + } SPDISPLAYATTRIBUTES; + +typedef unsigned short SPPHONEID; + +typedef /* [hidden][restricted] */ struct SPPHRASEELEMENT + { + ULONG ulAudioTimeOffset; + ULONG ulAudioSizeTime; + ULONG ulAudioStreamOffset; + ULONG ulAudioSizeBytes; + ULONG ulRetainedStreamOffset; + ULONG ulRetainedSizeBytes; + const WCHAR *pszDisplayText; + const WCHAR *pszLexicalForm; + const SPPHONEID *pszPronunciation; + BYTE bDisplayAttributes; + signed char RequiredConfidence; + signed char ActualConfidence; + BYTE Reserved; + float SREngineConfidence; + } SPPHRASEELEMENT; + +typedef /* [hidden][restricted] */ struct SPPHRASERULE SPPHRASERULE; + +/* [hidden] */ struct SPPHRASERULE + { + const WCHAR *pszName; + ULONG ulId; + ULONG ulFirstElement; + ULONG ulCountOfElements; + const SPPHRASERULE *pNextSibling; + const SPPHRASERULE *pFirstChild; + float SREngineConfidence; + signed char Confidence; + } ; +typedef /* [hidden][restricted] */ struct SPPHRASEPROPERTY SPPHRASEPROPERTY; + +/* [hidden] */ struct SPPHRASEPROPERTY + { + const WCHAR *pszName; + ULONG ulId; + const WCHAR *pszValue; + VARIANT vValue; + ULONG ulFirstElement; + ULONG ulCountOfElements; + const SPPHRASEPROPERTY *pNextSibling; + const SPPHRASEPROPERTY *pFirstChild; + float SREngineConfidence; + signed char Confidence; + } ; +typedef /* [hidden][restricted] */ struct SPPHRASEREPLACEMENT + { + BYTE bDisplayAttributes; + const WCHAR *pszReplacementText; + ULONG ulFirstElement; + ULONG ulCountOfElements; + } SPPHRASEREPLACEMENT; + +typedef /* [hidden][restricted] */ struct SPPHRASE + { + ULONG cbSize; + WORD LangID; + WORD wReserved; + ULONGLONG ullGrammarID; + ULONGLONG ftStartTime; + ULONGLONG ullAudioStreamPosition; + ULONG ulAudioSizeBytes; + ULONG ulRetainedSizeBytes; + ULONG ulAudioSizeTime; + SPPHRASERULE Rule; + const SPPHRASEPROPERTY *pProperties; + const SPPHRASEELEMENT *pElements; + ULONG cReplacements; + const SPPHRASEREPLACEMENT *pReplacements; + GUID SREngineID; + ULONG ulSREnginePrivateDataSize; + const BYTE *pSREnginePrivateData; + } SPPHRASE; + +typedef /* [hidden][restricted] */ struct SPSERIALIZEDPHRASE + { + ULONG ulSerializedSize; + } SPSERIALIZEDPHRASE; + +typedef /* [hidden] */ +enum SPVALUETYPE + { SPDF_PROPERTY = 0x1, + SPDF_REPLACEMENT = 0x2, + SPDF_RULE = 0x4, + SPDF_DISPLAYTEXT = 0x8, + SPDF_LEXICALFORM = 0x10, + SPDF_PRONUNCIATION = 0x20, + SPDF_AUDIO = 0x40, + SPDF_ALTERNATES = 0x80, + SPDF_ALL = 0xff + } SPVALUETYPE; + +typedef /* [hidden] */ struct SPBINARYGRAMMAR + { + ULONG ulTotalSerializedSize; + } SPBINARYGRAMMAR; + +typedef /* [hidden] */ +enum SPPHRASERNG + { SPPR_ALL_ELEMENTS = -1 + } SPPHRASERNG; + +#define SP_GETWHOLEPHRASE SPPR_ALL_ELEMENTS +#define SPRR_ALL_ELEMENTS SPPR_ALL_ELEMENTS +#if 0 +typedef void *SPSTATEHANDLE; + +#else +DECLARE_HANDLE(SPSTATEHANDLE); +#endif +typedef /* [hidden] */ +enum SPRECOEVENTFLAGS + { SPREF_AutoPause = 1 << 0, + SPREF_Emulated = 1 << 1 + } SPRECOEVENTFLAGS; + +typedef /* [hidden] */ +enum SPPARTOFSPEECH + { SPPS_NotOverriden = -1, + SPPS_Unknown = 0, + SPPS_Noun = 0x1000, + SPPS_Verb = 0x2000, + SPPS_Modifier = 0x3000, + SPPS_Function = 0x4000, + SPPS_Interjection = 0x5000 + } SPPARTOFSPEECH; + +typedef /* [hidden] */ +enum SPLEXICONTYPE + { eLEXTYPE_USER = 1L << 0, + eLEXTYPE_APP = 1L << 1, + eLEXTYPE_RESERVED1 = 1L << 2, + eLEXTYPE_RESERVED2 = 1L << 3, + eLEXTYPE_RESERVED3 = 1L << 4, + eLEXTYPE_RESERVED4 = 1L << 5, + eLEXTYPE_RESERVED5 = 1L << 6, + eLEXTYPE_RESERVED6 = 1L << 7, + eLEXTYPE_RESERVED7 = 1L << 8, + eLEXTYPE_RESERVED8 = 1L << 9, + eLEXTYPE_RESERVED9 = 1L << 10, + eLEXTYPE_RESERVED10 = 1L << 11, + eLEXTYPE_PRIVATE1 = 1L << 12, + eLEXTYPE_PRIVATE2 = 1L << 13, + eLEXTYPE_PRIVATE3 = 1L << 14, + eLEXTYPE_PRIVATE4 = 1L << 15, + eLEXTYPE_PRIVATE5 = 1L << 16, + eLEXTYPE_PRIVATE6 = 1L << 17, + eLEXTYPE_PRIVATE7 = 1L << 18, + eLEXTYPE_PRIVATE8 = 1L << 19, + eLEXTYPE_PRIVATE9 = 1L << 20, + eLEXTYPE_PRIVATE10 = 1L << 21, + eLEXTYPE_PRIVATE11 = 1L << 22, + eLEXTYPE_PRIVATE12 = 1L << 23, + eLEXTYPE_PRIVATE13 = 1L << 24, + eLEXTYPE_PRIVATE14 = 1L << 25, + eLEXTYPE_PRIVATE15 = 1L << 26, + eLEXTYPE_PRIVATE16 = 1L << 27, + eLEXTYPE_PRIVATE17 = 1L << 28, + eLEXTYPE_PRIVATE18 = 1L << 29, + eLEXTYPE_PRIVATE19 = 1L << 30, + eLEXTYPE_PRIVATE20 = 1L << 31 + } SPLEXICONTYPE; + +typedef /* [hidden] */ +enum SPWORDTYPE + { eWORDTYPE_ADDED = 1L << 0, + eWORDTYPE_DELETED = 1L << 1 + } SPWORDTYPE; + +typedef /* [hidden][restricted] */ struct SPWORDPRONUNCIATION + { + struct SPWORDPRONUNCIATION *pNextWordPronunciation; + SPLEXICONTYPE eLexiconType; + WORD LangID; + WORD wReserved; + SPPARTOFSPEECH ePartOfSpeech; + SPPHONEID szPronunciation[ 1 ]; + } SPWORDPRONUNCIATION; + +typedef /* [hidden][restricted] */ struct SPWORDPRONUNCIATIONLIST + { + ULONG ulSize; + BYTE *pvBuffer; + SPWORDPRONUNCIATION *pFirstWordPronunciation; + } SPWORDPRONUNCIATIONLIST; + +typedef /* [hidden][restricted] */ struct SPWORD + { + struct SPWORD *pNextWord; + WORD LangID; + WORD wReserved; + SPWORDTYPE eWordType; + WCHAR *pszWord; + SPWORDPRONUNCIATION *pFirstWordPronunciation; + } SPWORD; + +typedef /* [hidden][restricted] */ struct SPWORDLIST + { + ULONG ulSize; + BYTE *pvBuffer; + SPWORD *pFirstWord; + } SPWORDLIST; + + + +extern RPC_IF_HANDLE __MIDL_itf_sapi_0270_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_sapi_0270_v0_0_s_ifspec; + +#ifndef __ISpLexicon_INTERFACE_DEFINED__ +#define __ISpLexicon_INTERFACE_DEFINED__ + +/* interface ISpLexicon */ +/* [restricted][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpLexicon; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("DA41A7C2-5383-4DB2-916B-6C1719E3DB58") + ISpLexicon : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetPronunciations( + /* [in] */ const WCHAR *pszWord, + /* [in] */ WORD LangID, + /* [in] */ DWORD dwFlags, + /* [out][in] */ SPWORDPRONUNCIATIONLIST *pWordPronunciationList) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddPronunciation( + /* [in] */ const WCHAR *pszWord, + /* [in] */ WORD LangID, + /* [in] */ SPPARTOFSPEECH ePartOfSpeech, + /* [in] */ const SPPHONEID *pszPronunciation) = 0; + + virtual HRESULT STDMETHODCALLTYPE RemovePronunciation( + /* [in] */ const WCHAR *pszWord, + /* [in] */ WORD LangID, + /* [in] */ SPPARTOFSPEECH ePartOfSpeech, + /* [in] */ const SPPHONEID *pszPronunciation) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetGeneration( + DWORD *pdwGeneration) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetGenerationChange( + /* [in] */ DWORD dwFlags, + /* [out][in] */ DWORD *pdwGeneration, + /* [out][in] */ SPWORDLIST *pWordList) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetWords( + /* [in] */ DWORD dwFlags, + /* [out][in] */ DWORD *pdwGeneration, + /* [out][in] */ DWORD *pdwCookie, + /* [out][in] */ SPWORDLIST *pWordList) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpLexiconVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpLexicon * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpLexicon * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpLexicon * This); + + HRESULT ( STDMETHODCALLTYPE *GetPronunciations )( + ISpLexicon * This, + /* [in] */ const WCHAR *pszWord, + /* [in] */ WORD LangID, + /* [in] */ DWORD dwFlags, + /* [out][in] */ SPWORDPRONUNCIATIONLIST *pWordPronunciationList); + + HRESULT ( STDMETHODCALLTYPE *AddPronunciation )( + ISpLexicon * This, + /* [in] */ const WCHAR *pszWord, + /* [in] */ WORD LangID, + /* [in] */ SPPARTOFSPEECH ePartOfSpeech, + /* [in] */ const SPPHONEID *pszPronunciation); + + HRESULT ( STDMETHODCALLTYPE *RemovePronunciation )( + ISpLexicon * This, + /* [in] */ const WCHAR *pszWord, + /* [in] */ WORD LangID, + /* [in] */ SPPARTOFSPEECH ePartOfSpeech, + /* [in] */ const SPPHONEID *pszPronunciation); + + HRESULT ( STDMETHODCALLTYPE *GetGeneration )( + ISpLexicon * This, + DWORD *pdwGeneration); + + HRESULT ( STDMETHODCALLTYPE *GetGenerationChange )( + ISpLexicon * This, + /* [in] */ DWORD dwFlags, + /* [out][in] */ DWORD *pdwGeneration, + /* [out][in] */ SPWORDLIST *pWordList); + + HRESULT ( STDMETHODCALLTYPE *GetWords )( + ISpLexicon * This, + /* [in] */ DWORD dwFlags, + /* [out][in] */ DWORD *pdwGeneration, + /* [out][in] */ DWORD *pdwCookie, + /* [out][in] */ SPWORDLIST *pWordList); + + END_INTERFACE + } ISpLexiconVtbl; + + interface ISpLexicon + { + CONST_VTBL struct ISpLexiconVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpLexicon_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpLexicon_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpLexicon_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpLexicon_GetPronunciations(This,pszWord,LangID,dwFlags,pWordPronunciationList) \ + (This)->lpVtbl -> GetPronunciations(This,pszWord,LangID,dwFlags,pWordPronunciationList) + +#define ISpLexicon_AddPronunciation(This,pszWord,LangID,ePartOfSpeech,pszPronunciation) \ + (This)->lpVtbl -> AddPronunciation(This,pszWord,LangID,ePartOfSpeech,pszPronunciation) + +#define ISpLexicon_RemovePronunciation(This,pszWord,LangID,ePartOfSpeech,pszPronunciation) \ + (This)->lpVtbl -> RemovePronunciation(This,pszWord,LangID,ePartOfSpeech,pszPronunciation) + +#define ISpLexicon_GetGeneration(This,pdwGeneration) \ + (This)->lpVtbl -> GetGeneration(This,pdwGeneration) + +#define ISpLexicon_GetGenerationChange(This,dwFlags,pdwGeneration,pWordList) \ + (This)->lpVtbl -> GetGenerationChange(This,dwFlags,pdwGeneration,pWordList) + +#define ISpLexicon_GetWords(This,dwFlags,pdwGeneration,pdwCookie,pWordList) \ + (This)->lpVtbl -> GetWords(This,dwFlags,pdwGeneration,pdwCookie,pWordList) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpLexicon_GetPronunciations_Proxy( + ISpLexicon * This, + /* [in] */ const WCHAR *pszWord, + /* [in] */ WORD LangID, + /* [in] */ DWORD dwFlags, + /* [out][in] */ SPWORDPRONUNCIATIONLIST *pWordPronunciationList); + + +void __RPC_STUB ISpLexicon_GetPronunciations_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpLexicon_AddPronunciation_Proxy( + ISpLexicon * This, + /* [in] */ const WCHAR *pszWord, + /* [in] */ WORD LangID, + /* [in] */ SPPARTOFSPEECH ePartOfSpeech, + /* [in] */ const SPPHONEID *pszPronunciation); + + +void __RPC_STUB ISpLexicon_AddPronunciation_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpLexicon_RemovePronunciation_Proxy( + ISpLexicon * This, + /* [in] */ const WCHAR *pszWord, + /* [in] */ WORD LangID, + /* [in] */ SPPARTOFSPEECH ePartOfSpeech, + /* [in] */ const SPPHONEID *pszPronunciation); + + +void __RPC_STUB ISpLexicon_RemovePronunciation_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpLexicon_GetGeneration_Proxy( + ISpLexicon * This, + DWORD *pdwGeneration); + + +void __RPC_STUB ISpLexicon_GetGeneration_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpLexicon_GetGenerationChange_Proxy( + ISpLexicon * This, + /* [in] */ DWORD dwFlags, + /* [out][in] */ DWORD *pdwGeneration, + /* [out][in] */ SPWORDLIST *pWordList); + + +void __RPC_STUB ISpLexicon_GetGenerationChange_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpLexicon_GetWords_Proxy( + ISpLexicon * This, + /* [in] */ DWORD dwFlags, + /* [out][in] */ DWORD *pdwGeneration, + /* [out][in] */ DWORD *pdwCookie, + /* [out][in] */ SPWORDLIST *pWordList); + + +void __RPC_STUB ISpLexicon_GetWords_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpLexicon_INTERFACE_DEFINED__ */ + + +#ifndef __ISpContainerLexicon_INTERFACE_DEFINED__ +#define __ISpContainerLexicon_INTERFACE_DEFINED__ + +/* interface ISpContainerLexicon */ +/* [restricted][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpContainerLexicon; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("8565572F-C094-41CC-B56E-10BD9C3FF044") + ISpContainerLexicon : public ISpLexicon + { + public: + virtual HRESULT STDMETHODCALLTYPE AddLexicon( + /* [in] */ ISpLexicon *pAddLexicon, + /* [in] */ DWORD dwFlags) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpContainerLexiconVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpContainerLexicon * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpContainerLexicon * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpContainerLexicon * This); + + HRESULT ( STDMETHODCALLTYPE *GetPronunciations )( + ISpContainerLexicon * This, + /* [in] */ const WCHAR *pszWord, + /* [in] */ WORD LangID, + /* [in] */ DWORD dwFlags, + /* [out][in] */ SPWORDPRONUNCIATIONLIST *pWordPronunciationList); + + HRESULT ( STDMETHODCALLTYPE *AddPronunciation )( + ISpContainerLexicon * This, + /* [in] */ const WCHAR *pszWord, + /* [in] */ WORD LangID, + /* [in] */ SPPARTOFSPEECH ePartOfSpeech, + /* [in] */ const SPPHONEID *pszPronunciation); + + HRESULT ( STDMETHODCALLTYPE *RemovePronunciation )( + ISpContainerLexicon * This, + /* [in] */ const WCHAR *pszWord, + /* [in] */ WORD LangID, + /* [in] */ SPPARTOFSPEECH ePartOfSpeech, + /* [in] */ const SPPHONEID *pszPronunciation); + + HRESULT ( STDMETHODCALLTYPE *GetGeneration )( + ISpContainerLexicon * This, + DWORD *pdwGeneration); + + HRESULT ( STDMETHODCALLTYPE *GetGenerationChange )( + ISpContainerLexicon * This, + /* [in] */ DWORD dwFlags, + /* [out][in] */ DWORD *pdwGeneration, + /* [out][in] */ SPWORDLIST *pWordList); + + HRESULT ( STDMETHODCALLTYPE *GetWords )( + ISpContainerLexicon * This, + /* [in] */ DWORD dwFlags, + /* [out][in] */ DWORD *pdwGeneration, + /* [out][in] */ DWORD *pdwCookie, + /* [out][in] */ SPWORDLIST *pWordList); + + HRESULT ( STDMETHODCALLTYPE *AddLexicon )( + ISpContainerLexicon * This, + /* [in] */ ISpLexicon *pAddLexicon, + /* [in] */ DWORD dwFlags); + + END_INTERFACE + } ISpContainerLexiconVtbl; + + interface ISpContainerLexicon + { + CONST_VTBL struct ISpContainerLexiconVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpContainerLexicon_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpContainerLexicon_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpContainerLexicon_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpContainerLexicon_GetPronunciations(This,pszWord,LangID,dwFlags,pWordPronunciationList) \ + (This)->lpVtbl -> GetPronunciations(This,pszWord,LangID,dwFlags,pWordPronunciationList) + +#define ISpContainerLexicon_AddPronunciation(This,pszWord,LangID,ePartOfSpeech,pszPronunciation) \ + (This)->lpVtbl -> AddPronunciation(This,pszWord,LangID,ePartOfSpeech,pszPronunciation) + +#define ISpContainerLexicon_RemovePronunciation(This,pszWord,LangID,ePartOfSpeech,pszPronunciation) \ + (This)->lpVtbl -> RemovePronunciation(This,pszWord,LangID,ePartOfSpeech,pszPronunciation) + +#define ISpContainerLexicon_GetGeneration(This,pdwGeneration) \ + (This)->lpVtbl -> GetGeneration(This,pdwGeneration) + +#define ISpContainerLexicon_GetGenerationChange(This,dwFlags,pdwGeneration,pWordList) \ + (This)->lpVtbl -> GetGenerationChange(This,dwFlags,pdwGeneration,pWordList) + +#define ISpContainerLexicon_GetWords(This,dwFlags,pdwGeneration,pdwCookie,pWordList) \ + (This)->lpVtbl -> GetWords(This,dwFlags,pdwGeneration,pdwCookie,pWordList) + + +#define ISpContainerLexicon_AddLexicon(This,pAddLexicon,dwFlags) \ + (This)->lpVtbl -> AddLexicon(This,pAddLexicon,dwFlags) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpContainerLexicon_AddLexicon_Proxy( + ISpContainerLexicon * This, + /* [in] */ ISpLexicon *pAddLexicon, + /* [in] */ DWORD dwFlags); + + +void __RPC_STUB ISpContainerLexicon_AddLexicon_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpContainerLexicon_INTERFACE_DEFINED__ */ + + +#ifndef __ISpPhoneConverter_INTERFACE_DEFINED__ +#define __ISpPhoneConverter_INTERFACE_DEFINED__ + +/* interface ISpPhoneConverter */ +/* [restricted][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpPhoneConverter; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("8445C581-0CAC-4A38-ABFE-9B2CE2826455") + ISpPhoneConverter : public ISpObjectWithToken + { + public: + virtual HRESULT STDMETHODCALLTYPE PhoneToId( + /* [in] */ const WCHAR *pszPhone, + /* [out] */ SPPHONEID *pId) = 0; + + virtual HRESULT STDMETHODCALLTYPE IdToPhone( + /* [in] */ const SPPHONEID *pId, + /* [out] */ WCHAR *pszPhone) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpPhoneConverterVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpPhoneConverter * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpPhoneConverter * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpPhoneConverter * This); + + HRESULT ( STDMETHODCALLTYPE *SetObjectToken )( + ISpPhoneConverter * This, + ISpObjectToken *pToken); + + HRESULT ( STDMETHODCALLTYPE *GetObjectToken )( + ISpPhoneConverter * This, + ISpObjectToken **ppToken); + + HRESULT ( STDMETHODCALLTYPE *PhoneToId )( + ISpPhoneConverter * This, + /* [in] */ const WCHAR *pszPhone, + /* [out] */ SPPHONEID *pId); + + HRESULT ( STDMETHODCALLTYPE *IdToPhone )( + ISpPhoneConverter * This, + /* [in] */ const SPPHONEID *pId, + /* [out] */ WCHAR *pszPhone); + + END_INTERFACE + } ISpPhoneConverterVtbl; + + interface ISpPhoneConverter + { + CONST_VTBL struct ISpPhoneConverterVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpPhoneConverter_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpPhoneConverter_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpPhoneConverter_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpPhoneConverter_SetObjectToken(This,pToken) \ + (This)->lpVtbl -> SetObjectToken(This,pToken) + +#define ISpPhoneConverter_GetObjectToken(This,ppToken) \ + (This)->lpVtbl -> GetObjectToken(This,ppToken) + + +#define ISpPhoneConverter_PhoneToId(This,pszPhone,pId) \ + (This)->lpVtbl -> PhoneToId(This,pszPhone,pId) + +#define ISpPhoneConverter_IdToPhone(This,pId,pszPhone) \ + (This)->lpVtbl -> IdToPhone(This,pId,pszPhone) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpPhoneConverter_PhoneToId_Proxy( + ISpPhoneConverter * This, + /* [in] */ const WCHAR *pszPhone, + /* [out] */ SPPHONEID *pId); + + +void __RPC_STUB ISpPhoneConverter_PhoneToId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpPhoneConverter_IdToPhone_Proxy( + ISpPhoneConverter * This, + /* [in] */ const SPPHONEID *pId, + /* [out] */ WCHAR *pszPhone); + + +void __RPC_STUB ISpPhoneConverter_IdToPhone_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpPhoneConverter_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_sapi_0273 */ +/* [local] */ + +typedef /* [hidden][restricted] */ struct SPVPITCH + { + long MiddleAdj; + long RangeAdj; + } SPVPITCH; + +typedef /* [hidden] */ +enum SPVACTIONS + { SPVA_Speak = 0, + SPVA_Silence = SPVA_Speak + 1, + SPVA_Pronounce = SPVA_Silence + 1, + SPVA_Bookmark = SPVA_Pronounce + 1, + SPVA_SpellOut = SPVA_Bookmark + 1, + SPVA_Section = SPVA_SpellOut + 1, + SPVA_ParseUnknownTag = SPVA_Section + 1 + } SPVACTIONS; + +typedef /* [hidden][restricted] */ struct SPVCONTEXT + { + LPCWSTR pCategory; + LPCWSTR pBefore; + LPCWSTR pAfter; + } SPVCONTEXT; + +typedef /* [hidden][restricted] */ struct SPVSTATE + { + SPVACTIONS eAction; + WORD LangID; + WORD wReserved; + long EmphAdj; + long RateAdj; + ULONG Volume; + SPVPITCH PitchAdj; + ULONG SilenceMSecs; + SPPHONEID *pPhoneIds; + SPPARTOFSPEECH ePartOfSpeech; + SPVCONTEXT Context; + } SPVSTATE; + +typedef /* [hidden] */ +enum SPRUNSTATE + { SPRS_DONE = 1L << 0, + SPRS_IS_SPEAKING = 1L << 1 + } SPRUNSTATE; + +typedef /* [hidden] */ +enum SPVLIMITS + { SPMIN_VOLUME = 0, + SPMAX_VOLUME = 100, + SPMIN_RATE = -10, + SPMAX_RATE = 10 + } SPVLIMITS; + +typedef /* [hidden] */ +enum SPVPRIORITY + { SPVPRI_NORMAL = 0, + SPVPRI_ALERT = 1L << 0, + SPVPRI_OVER = 1L << 1 + } SPVPRIORITY; + +typedef /* [hidden][restricted] */ struct SPVOICESTATUS + { + ULONG ulCurrentStream; + ULONG ulLastStreamQueued; + HRESULT hrLastResult; + DWORD dwRunningState; + ULONG ulInputWordPos; + ULONG ulInputWordLen; + ULONG ulInputSentPos; + ULONG ulInputSentLen; + LONG lBookmarkId; + SPPHONEID PhonemeId; + SPVISEMES VisemeId; + DWORD dwReserved1; + DWORD dwReserved2; + } SPVOICESTATUS; + +typedef /* [hidden] */ +enum SPEAKFLAGS + { SPF_DEFAULT = 0, + SPF_ASYNC = 1L << 0, + SPF_PURGEBEFORESPEAK = 1L << 1, + SPF_IS_FILENAME = 1L << 2, + SPF_IS_XML = 1L << 3, + SPF_IS_NOT_XML = 1L << 4, + SPF_PERSIST_XML = 1L << 5, + SPF_NLP_SPEAK_PUNC = 1L << 6, + SPF_NLP_MASK = SPF_NLP_SPEAK_PUNC, + SPF_VOICE_MASK = SPF_ASYNC | SPF_PURGEBEFORESPEAK | SPF_IS_FILENAME | SPF_IS_XML | SPF_IS_NOT_XML | SPF_NLP_MASK | SPF_PERSIST_XML, + SPF_UNUSED_FLAGS = ~SPF_VOICE_MASK + } SPEAKFLAGS; + + + +extern RPC_IF_HANDLE __MIDL_itf_sapi_0273_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_sapi_0273_v0_0_s_ifspec; + +#ifndef __ISpVoice_INTERFACE_DEFINED__ +#define __ISpVoice_INTERFACE_DEFINED__ + +/* interface ISpVoice */ +/* [restricted][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpVoice; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("6C44DF74-72B9-4992-A1EC-EF996E0422D4") + ISpVoice : public ISpEventSource + { + public: + virtual HRESULT STDMETHODCALLTYPE SetOutput( + /* [in] */ IUnknown *pUnkOutput, + /* [in] */ BOOL fAllowFormatChanges) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetOutputObjectToken( + /* [out] */ ISpObjectToken **ppObjectToken) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetOutputStream( + /* [out] */ ISpStreamFormat **ppStream) = 0; + + virtual HRESULT STDMETHODCALLTYPE Pause( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Resume( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetVoice( + /* [in] */ ISpObjectToken *pToken) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetVoice( + /* [out] */ ISpObjectToken **ppToken) = 0; + + virtual HRESULT STDMETHODCALLTYPE Speak( + /* [string][in] */ const WCHAR *pwcs, + /* [in] */ DWORD dwFlags, + /* [out] */ ULONG *pulStreamNumber) = 0; + + virtual HRESULT STDMETHODCALLTYPE SpeakStream( + /* [in] */ IStream *pStream, + /* [in] */ DWORD dwFlags, + /* [out] */ ULONG *pulStreamNumber) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStatus( + /* [out] */ SPVOICESTATUS *pStatus, + /* [string][out] */ WCHAR **ppszLastBookmark) = 0; + + virtual HRESULT STDMETHODCALLTYPE Skip( + /* [string][in] */ WCHAR *pItemType, + /* [in] */ long lNumItems, + /* [out] */ ULONG *pulNumSkipped) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetPriority( + /* [in] */ SPVPRIORITY ePriority) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPriority( + /* [out] */ SPVPRIORITY *pePriority) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetAlertBoundary( + /* [in] */ SPEVENTENUM eBoundary) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAlertBoundary( + /* [out] */ SPEVENTENUM *peBoundary) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetRate( + /* [in] */ long RateAdjust) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetRate( + /* [out] */ long *pRateAdjust) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetVolume( + /* [in] */ USHORT usVolume) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetVolume( + /* [out] */ USHORT *pusVolume) = 0; + + virtual HRESULT STDMETHODCALLTYPE WaitUntilDone( + /* [in] */ ULONG msTimeout) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetSyncSpeakTimeout( + /* [in] */ ULONG msTimeout) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSyncSpeakTimeout( + /* [out] */ ULONG *pmsTimeout) = 0; + + virtual /* [local] */ HANDLE STDMETHODCALLTYPE SpeakCompleteEvent( void) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE IsUISupported( + /* [in] */ const WCHAR *pszTypeOfUI, + /* [in] */ void *pvExtraData, + /* [in] */ ULONG cbExtraData, + /* [out] */ BOOL *pfSupported) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE DisplayUI( + /* [in] */ HWND hwndParent, + /* [in] */ const WCHAR *pszTitle, + /* [in] */ const WCHAR *pszTypeOfUI, + /* [in] */ void *pvExtraData, + /* [in] */ ULONG cbExtraData) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpVoiceVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpVoice * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpVoice * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpVoice * This); + + HRESULT ( STDMETHODCALLTYPE *SetNotifySink )( + ISpVoice * This, + /* [in] */ ISpNotifySink *pNotifySink); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *SetNotifyWindowMessage )( + ISpVoice * This, + /* [in] */ HWND hWnd, + /* [in] */ UINT Msg, + /* [in] */ WPARAM wParam, + /* [in] */ LPARAM lParam); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *SetNotifyCallbackFunction )( + ISpVoice * This, + /* [in] */ SPNOTIFYCALLBACK *pfnCallback, + /* [in] */ WPARAM wParam, + /* [in] */ LPARAM lParam); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *SetNotifyCallbackInterface )( + ISpVoice * This, + /* [in] */ ISpNotifyCallback *pSpCallback, + /* [in] */ WPARAM wParam, + /* [in] */ LPARAM lParam); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *SetNotifyWin32Event )( + ISpVoice * This); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *WaitForNotifyEvent )( + ISpVoice * This, + /* [in] */ DWORD dwMilliseconds); + + /* [local] */ HANDLE ( STDMETHODCALLTYPE *GetNotifyEventHandle )( + ISpVoice * This); + + HRESULT ( STDMETHODCALLTYPE *SetInterest )( + ISpVoice * This, + /* [in] */ ULONGLONG ullEventInterest, + /* [in] */ ULONGLONG ullQueuedInterest); + + HRESULT ( STDMETHODCALLTYPE *GetEvents )( + ISpVoice * This, + /* [in] */ ULONG ulCount, + /* [size_is][out] */ SPEVENT *pEventArray, + /* [out] */ ULONG *pulFetched); + + HRESULT ( STDMETHODCALLTYPE *GetInfo )( + ISpVoice * This, + /* [out] */ SPEVENTSOURCEINFO *pInfo); + + HRESULT ( STDMETHODCALLTYPE *SetOutput )( + ISpVoice * This, + /* [in] */ IUnknown *pUnkOutput, + /* [in] */ BOOL fAllowFormatChanges); + + HRESULT ( STDMETHODCALLTYPE *GetOutputObjectToken )( + ISpVoice * This, + /* [out] */ ISpObjectToken **ppObjectToken); + + HRESULT ( STDMETHODCALLTYPE *GetOutputStream )( + ISpVoice * This, + /* [out] */ ISpStreamFormat **ppStream); + + HRESULT ( STDMETHODCALLTYPE *Pause )( + ISpVoice * This); + + HRESULT ( STDMETHODCALLTYPE *Resume )( + ISpVoice * This); + + HRESULT ( STDMETHODCALLTYPE *SetVoice )( + ISpVoice * This, + /* [in] */ ISpObjectToken *pToken); + + HRESULT ( STDMETHODCALLTYPE *GetVoice )( + ISpVoice * This, + /* [out] */ ISpObjectToken **ppToken); + + HRESULT ( STDMETHODCALLTYPE *Speak )( + ISpVoice * This, + /* [string][in] */ const WCHAR *pwcs, + /* [in] */ DWORD dwFlags, + /* [out] */ ULONG *pulStreamNumber); + + HRESULT ( STDMETHODCALLTYPE *SpeakStream )( + ISpVoice * This, + /* [in] */ IStream *pStream, + /* [in] */ DWORD dwFlags, + /* [out] */ ULONG *pulStreamNumber); + + HRESULT ( STDMETHODCALLTYPE *GetStatus )( + ISpVoice * This, + /* [out] */ SPVOICESTATUS *pStatus, + /* [string][out] */ WCHAR **ppszLastBookmark); + + HRESULT ( STDMETHODCALLTYPE *Skip )( + ISpVoice * This, + /* [string][in] */ WCHAR *pItemType, + /* [in] */ long lNumItems, + /* [out] */ ULONG *pulNumSkipped); + + HRESULT ( STDMETHODCALLTYPE *SetPriority )( + ISpVoice * This, + /* [in] */ SPVPRIORITY ePriority); + + HRESULT ( STDMETHODCALLTYPE *GetPriority )( + ISpVoice * This, + /* [out] */ SPVPRIORITY *pePriority); + + HRESULT ( STDMETHODCALLTYPE *SetAlertBoundary )( + ISpVoice * This, + /* [in] */ SPEVENTENUM eBoundary); + + HRESULT ( STDMETHODCALLTYPE *GetAlertBoundary )( + ISpVoice * This, + /* [out] */ SPEVENTENUM *peBoundary); + + HRESULT ( STDMETHODCALLTYPE *SetRate )( + ISpVoice * This, + /* [in] */ long RateAdjust); + + HRESULT ( STDMETHODCALLTYPE *GetRate )( + ISpVoice * This, + /* [out] */ long *pRateAdjust); + + HRESULT ( STDMETHODCALLTYPE *SetVolume )( + ISpVoice * This, + /* [in] */ USHORT usVolume); + + HRESULT ( STDMETHODCALLTYPE *GetVolume )( + ISpVoice * This, + /* [out] */ USHORT *pusVolume); + + HRESULT ( STDMETHODCALLTYPE *WaitUntilDone )( + ISpVoice * This, + /* [in] */ ULONG msTimeout); + + HRESULT ( STDMETHODCALLTYPE *SetSyncSpeakTimeout )( + ISpVoice * This, + /* [in] */ ULONG msTimeout); + + HRESULT ( STDMETHODCALLTYPE *GetSyncSpeakTimeout )( + ISpVoice * This, + /* [out] */ ULONG *pmsTimeout); + + /* [local] */ HANDLE ( STDMETHODCALLTYPE *SpeakCompleteEvent )( + ISpVoice * This); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *IsUISupported )( + ISpVoice * This, + /* [in] */ const WCHAR *pszTypeOfUI, + /* [in] */ void *pvExtraData, + /* [in] */ ULONG cbExtraData, + /* [out] */ BOOL *pfSupported); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *DisplayUI )( + ISpVoice * This, + /* [in] */ HWND hwndParent, + /* [in] */ const WCHAR *pszTitle, + /* [in] */ const WCHAR *pszTypeOfUI, + /* [in] */ void *pvExtraData, + /* [in] */ ULONG cbExtraData); + + END_INTERFACE + } ISpVoiceVtbl; + + interface ISpVoice + { + CONST_VTBL struct ISpVoiceVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpVoice_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpVoice_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpVoice_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpVoice_SetNotifySink(This,pNotifySink) \ + (This)->lpVtbl -> SetNotifySink(This,pNotifySink) + +#define ISpVoice_SetNotifyWindowMessage(This,hWnd,Msg,wParam,lParam) \ + (This)->lpVtbl -> SetNotifyWindowMessage(This,hWnd,Msg,wParam,lParam) + +#define ISpVoice_SetNotifyCallbackFunction(This,pfnCallback,wParam,lParam) \ + (This)->lpVtbl -> SetNotifyCallbackFunction(This,pfnCallback,wParam,lParam) + +#define ISpVoice_SetNotifyCallbackInterface(This,pSpCallback,wParam,lParam) \ + (This)->lpVtbl -> SetNotifyCallbackInterface(This,pSpCallback,wParam,lParam) + +#define ISpVoice_SetNotifyWin32Event(This) \ + (This)->lpVtbl -> SetNotifyWin32Event(This) + +#define ISpVoice_WaitForNotifyEvent(This,dwMilliseconds) \ + (This)->lpVtbl -> WaitForNotifyEvent(This,dwMilliseconds) + +#define ISpVoice_GetNotifyEventHandle(This) \ + (This)->lpVtbl -> GetNotifyEventHandle(This) + + +#define ISpVoice_SetInterest(This,ullEventInterest,ullQueuedInterest) \ + (This)->lpVtbl -> SetInterest(This,ullEventInterest,ullQueuedInterest) + +#define ISpVoice_GetEvents(This,ulCount,pEventArray,pulFetched) \ + (This)->lpVtbl -> GetEvents(This,ulCount,pEventArray,pulFetched) + +#define ISpVoice_GetInfo(This,pInfo) \ + (This)->lpVtbl -> GetInfo(This,pInfo) + + +#define ISpVoice_SetOutput(This,pUnkOutput,fAllowFormatChanges) \ + (This)->lpVtbl -> SetOutput(This,pUnkOutput,fAllowFormatChanges) + +#define ISpVoice_GetOutputObjectToken(This,ppObjectToken) \ + (This)->lpVtbl -> GetOutputObjectToken(This,ppObjectToken) + +#define ISpVoice_GetOutputStream(This,ppStream) \ + (This)->lpVtbl -> GetOutputStream(This,ppStream) + +#define ISpVoice_Pause(This) \ + (This)->lpVtbl -> Pause(This) + +#define ISpVoice_Resume(This) \ + (This)->lpVtbl -> Resume(This) + +#define ISpVoice_SetVoice(This,pToken) \ + (This)->lpVtbl -> SetVoice(This,pToken) + +#define ISpVoice_GetVoice(This,ppToken) \ + (This)->lpVtbl -> GetVoice(This,ppToken) + +#define ISpVoice_Speak(This,pwcs,dwFlags,pulStreamNumber) \ + (This)->lpVtbl -> Speak(This,pwcs,dwFlags,pulStreamNumber) + +#define ISpVoice_SpeakStream(This,pStream,dwFlags,pulStreamNumber) \ + (This)->lpVtbl -> SpeakStream(This,pStream,dwFlags,pulStreamNumber) + +#define ISpVoice_GetStatus(This,pStatus,ppszLastBookmark) \ + (This)->lpVtbl -> GetStatus(This,pStatus,ppszLastBookmark) + +#define ISpVoice_Skip(This,pItemType,lNumItems,pulNumSkipped) \ + (This)->lpVtbl -> Skip(This,pItemType,lNumItems,pulNumSkipped) + +#define ISpVoice_SetPriority(This,ePriority) \ + (This)->lpVtbl -> SetPriority(This,ePriority) + +#define ISpVoice_GetPriority(This,pePriority) \ + (This)->lpVtbl -> GetPriority(This,pePriority) + +#define ISpVoice_SetAlertBoundary(This,eBoundary) \ + (This)->lpVtbl -> SetAlertBoundary(This,eBoundary) + +#define ISpVoice_GetAlertBoundary(This,peBoundary) \ + (This)->lpVtbl -> GetAlertBoundary(This,peBoundary) + +#define ISpVoice_SetRate(This,RateAdjust) \ + (This)->lpVtbl -> SetRate(This,RateAdjust) + +#define ISpVoice_GetRate(This,pRateAdjust) \ + (This)->lpVtbl -> GetRate(This,pRateAdjust) + +#define ISpVoice_SetVolume(This,usVolume) \ + (This)->lpVtbl -> SetVolume(This,usVolume) + +#define ISpVoice_GetVolume(This,pusVolume) \ + (This)->lpVtbl -> GetVolume(This,pusVolume) + +#define ISpVoice_WaitUntilDone(This,msTimeout) \ + (This)->lpVtbl -> WaitUntilDone(This,msTimeout) + +#define ISpVoice_SetSyncSpeakTimeout(This,msTimeout) \ + (This)->lpVtbl -> SetSyncSpeakTimeout(This,msTimeout) + +#define ISpVoice_GetSyncSpeakTimeout(This,pmsTimeout) \ + (This)->lpVtbl -> GetSyncSpeakTimeout(This,pmsTimeout) + +#define ISpVoice_SpeakCompleteEvent(This) \ + (This)->lpVtbl -> SpeakCompleteEvent(This) + +#define ISpVoice_IsUISupported(This,pszTypeOfUI,pvExtraData,cbExtraData,pfSupported) \ + (This)->lpVtbl -> IsUISupported(This,pszTypeOfUI,pvExtraData,cbExtraData,pfSupported) + +#define ISpVoice_DisplayUI(This,hwndParent,pszTitle,pszTypeOfUI,pvExtraData,cbExtraData) \ + (This)->lpVtbl -> DisplayUI(This,hwndParent,pszTitle,pszTypeOfUI,pvExtraData,cbExtraData) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpVoice_SetOutput_Proxy( + ISpVoice * This, + /* [in] */ IUnknown *pUnkOutput, + /* [in] */ BOOL fAllowFormatChanges); + + +void __RPC_STUB ISpVoice_SetOutput_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpVoice_GetOutputObjectToken_Proxy( + ISpVoice * This, + /* [out] */ ISpObjectToken **ppObjectToken); + + +void __RPC_STUB ISpVoice_GetOutputObjectToken_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpVoice_GetOutputStream_Proxy( + ISpVoice * This, + /* [out] */ ISpStreamFormat **ppStream); + + +void __RPC_STUB ISpVoice_GetOutputStream_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpVoice_Pause_Proxy( + ISpVoice * This); + + +void __RPC_STUB ISpVoice_Pause_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpVoice_Resume_Proxy( + ISpVoice * This); + + +void __RPC_STUB ISpVoice_Resume_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpVoice_SetVoice_Proxy( + ISpVoice * This, + /* [in] */ ISpObjectToken *pToken); + + +void __RPC_STUB ISpVoice_SetVoice_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpVoice_GetVoice_Proxy( + ISpVoice * This, + /* [out] */ ISpObjectToken **ppToken); + + +void __RPC_STUB ISpVoice_GetVoice_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpVoice_Speak_Proxy( + ISpVoice * This, + /* [string][in] */ const WCHAR *pwcs, + /* [in] */ DWORD dwFlags, + /* [out] */ ULONG *pulStreamNumber); + + +void __RPC_STUB ISpVoice_Speak_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpVoice_SpeakStream_Proxy( + ISpVoice * This, + /* [in] */ IStream *pStream, + /* [in] */ DWORD dwFlags, + /* [out] */ ULONG *pulStreamNumber); + + +void __RPC_STUB ISpVoice_SpeakStream_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpVoice_GetStatus_Proxy( + ISpVoice * This, + /* [out] */ SPVOICESTATUS *pStatus, + /* [string][out] */ WCHAR **ppszLastBookmark); + + +void __RPC_STUB ISpVoice_GetStatus_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpVoice_Skip_Proxy( + ISpVoice * This, + /* [string][in] */ WCHAR *pItemType, + /* [in] */ long lNumItems, + /* [out] */ ULONG *pulNumSkipped); + + +void __RPC_STUB ISpVoice_Skip_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpVoice_SetPriority_Proxy( + ISpVoice * This, + /* [in] */ SPVPRIORITY ePriority); + + +void __RPC_STUB ISpVoice_SetPriority_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpVoice_GetPriority_Proxy( + ISpVoice * This, + /* [out] */ SPVPRIORITY *pePriority); + + +void __RPC_STUB ISpVoice_GetPriority_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpVoice_SetAlertBoundary_Proxy( + ISpVoice * This, + /* [in] */ SPEVENTENUM eBoundary); + + +void __RPC_STUB ISpVoice_SetAlertBoundary_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpVoice_GetAlertBoundary_Proxy( + ISpVoice * This, + /* [out] */ SPEVENTENUM *peBoundary); + + +void __RPC_STUB ISpVoice_GetAlertBoundary_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpVoice_SetRate_Proxy( + ISpVoice * This, + /* [in] */ long RateAdjust); + + +void __RPC_STUB ISpVoice_SetRate_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpVoice_GetRate_Proxy( + ISpVoice * This, + /* [out] */ long *pRateAdjust); + + +void __RPC_STUB ISpVoice_GetRate_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpVoice_SetVolume_Proxy( + ISpVoice * This, + /* [in] */ USHORT usVolume); + + +void __RPC_STUB ISpVoice_SetVolume_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpVoice_GetVolume_Proxy( + ISpVoice * This, + /* [out] */ USHORT *pusVolume); + + +void __RPC_STUB ISpVoice_GetVolume_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpVoice_WaitUntilDone_Proxy( + ISpVoice * This, + /* [in] */ ULONG msTimeout); + + +void __RPC_STUB ISpVoice_WaitUntilDone_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpVoice_SetSyncSpeakTimeout_Proxy( + ISpVoice * This, + /* [in] */ ULONG msTimeout); + + +void __RPC_STUB ISpVoice_SetSyncSpeakTimeout_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpVoice_GetSyncSpeakTimeout_Proxy( + ISpVoice * This, + /* [out] */ ULONG *pmsTimeout); + + +void __RPC_STUB ISpVoice_GetSyncSpeakTimeout_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [local] */ HANDLE STDMETHODCALLTYPE ISpVoice_SpeakCompleteEvent_Proxy( + ISpVoice * This); + + +void __RPC_STUB ISpVoice_SpeakCompleteEvent_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [local] */ HRESULT STDMETHODCALLTYPE ISpVoice_IsUISupported_Proxy( + ISpVoice * This, + /* [in] */ const WCHAR *pszTypeOfUI, + /* [in] */ void *pvExtraData, + /* [in] */ ULONG cbExtraData, + /* [out] */ BOOL *pfSupported); + + +void __RPC_STUB ISpVoice_IsUISupported_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [local] */ HRESULT STDMETHODCALLTYPE ISpVoice_DisplayUI_Proxy( + ISpVoice * This, + /* [in] */ HWND hwndParent, + /* [in] */ const WCHAR *pszTitle, + /* [in] */ const WCHAR *pszTypeOfUI, + /* [in] */ void *pvExtraData, + /* [in] */ ULONG cbExtraData); + + +void __RPC_STUB ISpVoice_DisplayUI_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpVoice_INTERFACE_DEFINED__ */ + + +#ifndef __ISpPhrase_INTERFACE_DEFINED__ +#define __ISpPhrase_INTERFACE_DEFINED__ + +/* interface ISpPhrase */ +/* [restricted][unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_ISpPhrase; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("1A5C0354-B621-4b5a-8791-D306ED379E53") + ISpPhrase : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetPhrase( + /* [out] */ SPPHRASE **ppCoMemPhrase) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSerializedPhrase( + /* [out] */ SPSERIALIZEDPHRASE **ppCoMemPhrase) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetText( + /* [in] */ ULONG ulStart, + /* [in] */ ULONG ulCount, + /* [in] */ BOOL fUseTextReplacements, + /* [out] */ WCHAR **ppszCoMemText, + /* [out] */ BYTE *pbDisplayAttributes) = 0; + + virtual HRESULT STDMETHODCALLTYPE Discard( + /* [in] */ DWORD dwValueTypes) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpPhraseVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpPhrase * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpPhrase * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpPhrase * This); + + HRESULT ( STDMETHODCALLTYPE *GetPhrase )( + ISpPhrase * This, + /* [out] */ SPPHRASE **ppCoMemPhrase); + + HRESULT ( STDMETHODCALLTYPE *GetSerializedPhrase )( + ISpPhrase * This, + /* [out] */ SPSERIALIZEDPHRASE **ppCoMemPhrase); + + HRESULT ( STDMETHODCALLTYPE *GetText )( + ISpPhrase * This, + /* [in] */ ULONG ulStart, + /* [in] */ ULONG ulCount, + /* [in] */ BOOL fUseTextReplacements, + /* [out] */ WCHAR **ppszCoMemText, + /* [out] */ BYTE *pbDisplayAttributes); + + HRESULT ( STDMETHODCALLTYPE *Discard )( + ISpPhrase * This, + /* [in] */ DWORD dwValueTypes); + + END_INTERFACE + } ISpPhraseVtbl; + + interface ISpPhrase + { + CONST_VTBL struct ISpPhraseVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpPhrase_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpPhrase_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpPhrase_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpPhrase_GetPhrase(This,ppCoMemPhrase) \ + (This)->lpVtbl -> GetPhrase(This,ppCoMemPhrase) + +#define ISpPhrase_GetSerializedPhrase(This,ppCoMemPhrase) \ + (This)->lpVtbl -> GetSerializedPhrase(This,ppCoMemPhrase) + +#define ISpPhrase_GetText(This,ulStart,ulCount,fUseTextReplacements,ppszCoMemText,pbDisplayAttributes) \ + (This)->lpVtbl -> GetText(This,ulStart,ulCount,fUseTextReplacements,ppszCoMemText,pbDisplayAttributes) + +#define ISpPhrase_Discard(This,dwValueTypes) \ + (This)->lpVtbl -> Discard(This,dwValueTypes) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpPhrase_GetPhrase_Proxy( + ISpPhrase * This, + /* [out] */ SPPHRASE **ppCoMemPhrase); + + +void __RPC_STUB ISpPhrase_GetPhrase_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpPhrase_GetSerializedPhrase_Proxy( + ISpPhrase * This, + /* [out] */ SPSERIALIZEDPHRASE **ppCoMemPhrase); + + +void __RPC_STUB ISpPhrase_GetSerializedPhrase_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpPhrase_GetText_Proxy( + ISpPhrase * This, + /* [in] */ ULONG ulStart, + /* [in] */ ULONG ulCount, + /* [in] */ BOOL fUseTextReplacements, + /* [out] */ WCHAR **ppszCoMemText, + /* [out] */ BYTE *pbDisplayAttributes); + + +void __RPC_STUB ISpPhrase_GetText_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpPhrase_Discard_Proxy( + ISpPhrase * This, + /* [in] */ DWORD dwValueTypes); + + +void __RPC_STUB ISpPhrase_Discard_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpPhrase_INTERFACE_DEFINED__ */ + + +#ifndef __ISpPhraseAlt_INTERFACE_DEFINED__ +#define __ISpPhraseAlt_INTERFACE_DEFINED__ + +/* interface ISpPhraseAlt */ +/* [restricted][unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_ISpPhraseAlt; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("8FCEBC98-4E49-4067-9C6C-D86A0E092E3D") + ISpPhraseAlt : public ISpPhrase + { + public: + virtual HRESULT STDMETHODCALLTYPE GetAltInfo( + ISpPhrase **ppParent, + ULONG *pulStartElementInParent, + ULONG *pcElementsInParent, + ULONG *pcElementsInAlt) = 0; + + virtual HRESULT STDMETHODCALLTYPE Commit( void) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpPhraseAltVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpPhraseAlt * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpPhraseAlt * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpPhraseAlt * This); + + HRESULT ( STDMETHODCALLTYPE *GetPhrase )( + ISpPhraseAlt * This, + /* [out] */ SPPHRASE **ppCoMemPhrase); + + HRESULT ( STDMETHODCALLTYPE *GetSerializedPhrase )( + ISpPhraseAlt * This, + /* [out] */ SPSERIALIZEDPHRASE **ppCoMemPhrase); + + HRESULT ( STDMETHODCALLTYPE *GetText )( + ISpPhraseAlt * This, + /* [in] */ ULONG ulStart, + /* [in] */ ULONG ulCount, + /* [in] */ BOOL fUseTextReplacements, + /* [out] */ WCHAR **ppszCoMemText, + /* [out] */ BYTE *pbDisplayAttributes); + + HRESULT ( STDMETHODCALLTYPE *Discard )( + ISpPhraseAlt * This, + /* [in] */ DWORD dwValueTypes); + + HRESULT ( STDMETHODCALLTYPE *GetAltInfo )( + ISpPhraseAlt * This, + ISpPhrase **ppParent, + ULONG *pulStartElementInParent, + ULONG *pcElementsInParent, + ULONG *pcElementsInAlt); + + HRESULT ( STDMETHODCALLTYPE *Commit )( + ISpPhraseAlt * This); + + END_INTERFACE + } ISpPhraseAltVtbl; + + interface ISpPhraseAlt + { + CONST_VTBL struct ISpPhraseAltVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpPhraseAlt_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpPhraseAlt_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpPhraseAlt_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpPhraseAlt_GetPhrase(This,ppCoMemPhrase) \ + (This)->lpVtbl -> GetPhrase(This,ppCoMemPhrase) + +#define ISpPhraseAlt_GetSerializedPhrase(This,ppCoMemPhrase) \ + (This)->lpVtbl -> GetSerializedPhrase(This,ppCoMemPhrase) + +#define ISpPhraseAlt_GetText(This,ulStart,ulCount,fUseTextReplacements,ppszCoMemText,pbDisplayAttributes) \ + (This)->lpVtbl -> GetText(This,ulStart,ulCount,fUseTextReplacements,ppszCoMemText,pbDisplayAttributes) + +#define ISpPhraseAlt_Discard(This,dwValueTypes) \ + (This)->lpVtbl -> Discard(This,dwValueTypes) + + +#define ISpPhraseAlt_GetAltInfo(This,ppParent,pulStartElementInParent,pcElementsInParent,pcElementsInAlt) \ + (This)->lpVtbl -> GetAltInfo(This,ppParent,pulStartElementInParent,pcElementsInParent,pcElementsInAlt) + +#define ISpPhraseAlt_Commit(This) \ + (This)->lpVtbl -> Commit(This) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpPhraseAlt_GetAltInfo_Proxy( + ISpPhraseAlt * This, + ISpPhrase **ppParent, + ULONG *pulStartElementInParent, + ULONG *pcElementsInParent, + ULONG *pcElementsInAlt); + + +void __RPC_STUB ISpPhraseAlt_GetAltInfo_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpPhraseAlt_Commit_Proxy( + ISpPhraseAlt * This); + + +void __RPC_STUB ISpPhraseAlt_Commit_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpPhraseAlt_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_sapi_0276 */ +/* [local] */ + +typedef /* [hidden][restricted] */ struct SPRECORESULTTIMES + { + FILETIME ftStreamTime; + ULONGLONG ullLength; + DWORD dwTickCount; + ULONGLONG ullStart; + } SPRECORESULTTIMES; + +typedef /* [hidden] */ struct SPSERIALIZEDRESULT + { + ULONG ulSerializedSize; + } SPSERIALIZEDRESULT; + + + +extern RPC_IF_HANDLE __MIDL_itf_sapi_0276_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_sapi_0276_v0_0_s_ifspec; + +#ifndef __ISpRecoResult_INTERFACE_DEFINED__ +#define __ISpRecoResult_INTERFACE_DEFINED__ + +/* interface ISpRecoResult */ +/* [restricted][local][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpRecoResult; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("20B053BE-E235-43cd-9A2A-8D17A48B7842") + ISpRecoResult : public ISpPhrase + { + public: + virtual HRESULT STDMETHODCALLTYPE GetResultTimes( + /* [out] */ SPRECORESULTTIMES *pTimes) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAlternates( + /* [in] */ ULONG ulStartElement, + /* [in] */ ULONG cElements, + /* [in] */ ULONG ulRequestCount, + /* [out] */ ISpPhraseAlt **ppPhrases, + /* [out] */ ULONG *pcPhrasesReturned) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAudio( + /* [in] */ ULONG ulStartElement, + /* [in] */ ULONG cElements, + /* [out] */ ISpStreamFormat **ppStream) = 0; + + virtual HRESULT STDMETHODCALLTYPE SpeakAudio( + /* [in] */ ULONG ulStartElement, + /* [in] */ ULONG cElements, + /* [in] */ DWORD dwFlags, + /* [out] */ ULONG *pulStreamNumber) = 0; + + virtual HRESULT STDMETHODCALLTYPE Serialize( + /* [out] */ SPSERIALIZEDRESULT **ppCoMemSerializedResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE ScaleAudio( + /* [in] */ const GUID *pAudioFormatId, + /* [in] */ const WAVEFORMATEX *pWaveFormatEx) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetRecoContext( + /* [out] */ ISpRecoContext **ppRecoContext) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpRecoResultVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpRecoResult * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpRecoResult * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpRecoResult * This); + + HRESULT ( STDMETHODCALLTYPE *GetPhrase )( + ISpRecoResult * This, + /* [out] */ SPPHRASE **ppCoMemPhrase); + + HRESULT ( STDMETHODCALLTYPE *GetSerializedPhrase )( + ISpRecoResult * This, + /* [out] */ SPSERIALIZEDPHRASE **ppCoMemPhrase); + + HRESULT ( STDMETHODCALLTYPE *GetText )( + ISpRecoResult * This, + /* [in] */ ULONG ulStart, + /* [in] */ ULONG ulCount, + /* [in] */ BOOL fUseTextReplacements, + /* [out] */ WCHAR **ppszCoMemText, + /* [out] */ BYTE *pbDisplayAttributes); + + HRESULT ( STDMETHODCALLTYPE *Discard )( + ISpRecoResult * This, + /* [in] */ DWORD dwValueTypes); + + HRESULT ( STDMETHODCALLTYPE *GetResultTimes )( + ISpRecoResult * This, + /* [out] */ SPRECORESULTTIMES *pTimes); + + HRESULT ( STDMETHODCALLTYPE *GetAlternates )( + ISpRecoResult * This, + /* [in] */ ULONG ulStartElement, + /* [in] */ ULONG cElements, + /* [in] */ ULONG ulRequestCount, + /* [out] */ ISpPhraseAlt **ppPhrases, + /* [out] */ ULONG *pcPhrasesReturned); + + HRESULT ( STDMETHODCALLTYPE *GetAudio )( + ISpRecoResult * This, + /* [in] */ ULONG ulStartElement, + /* [in] */ ULONG cElements, + /* [out] */ ISpStreamFormat **ppStream); + + HRESULT ( STDMETHODCALLTYPE *SpeakAudio )( + ISpRecoResult * This, + /* [in] */ ULONG ulStartElement, + /* [in] */ ULONG cElements, + /* [in] */ DWORD dwFlags, + /* [out] */ ULONG *pulStreamNumber); + + HRESULT ( STDMETHODCALLTYPE *Serialize )( + ISpRecoResult * This, + /* [out] */ SPSERIALIZEDRESULT **ppCoMemSerializedResult); + + HRESULT ( STDMETHODCALLTYPE *ScaleAudio )( + ISpRecoResult * This, + /* [in] */ const GUID *pAudioFormatId, + /* [in] */ const WAVEFORMATEX *pWaveFormatEx); + + HRESULT ( STDMETHODCALLTYPE *GetRecoContext )( + ISpRecoResult * This, + /* [out] */ ISpRecoContext **ppRecoContext); + + END_INTERFACE + } ISpRecoResultVtbl; + + interface ISpRecoResult + { + CONST_VTBL struct ISpRecoResultVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpRecoResult_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpRecoResult_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpRecoResult_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpRecoResult_GetPhrase(This,ppCoMemPhrase) \ + (This)->lpVtbl -> GetPhrase(This,ppCoMemPhrase) + +#define ISpRecoResult_GetSerializedPhrase(This,ppCoMemPhrase) \ + (This)->lpVtbl -> GetSerializedPhrase(This,ppCoMemPhrase) + +#define ISpRecoResult_GetText(This,ulStart,ulCount,fUseTextReplacements,ppszCoMemText,pbDisplayAttributes) \ + (This)->lpVtbl -> GetText(This,ulStart,ulCount,fUseTextReplacements,ppszCoMemText,pbDisplayAttributes) + +#define ISpRecoResult_Discard(This,dwValueTypes) \ + (This)->lpVtbl -> Discard(This,dwValueTypes) + + +#define ISpRecoResult_GetResultTimes(This,pTimes) \ + (This)->lpVtbl -> GetResultTimes(This,pTimes) + +#define ISpRecoResult_GetAlternates(This,ulStartElement,cElements,ulRequestCount,ppPhrases,pcPhrasesReturned) \ + (This)->lpVtbl -> GetAlternates(This,ulStartElement,cElements,ulRequestCount,ppPhrases,pcPhrasesReturned) + +#define ISpRecoResult_GetAudio(This,ulStartElement,cElements,ppStream) \ + (This)->lpVtbl -> GetAudio(This,ulStartElement,cElements,ppStream) + +#define ISpRecoResult_SpeakAudio(This,ulStartElement,cElements,dwFlags,pulStreamNumber) \ + (This)->lpVtbl -> SpeakAudio(This,ulStartElement,cElements,dwFlags,pulStreamNumber) + +#define ISpRecoResult_Serialize(This,ppCoMemSerializedResult) \ + (This)->lpVtbl -> Serialize(This,ppCoMemSerializedResult) + +#define ISpRecoResult_ScaleAudio(This,pAudioFormatId,pWaveFormatEx) \ + (This)->lpVtbl -> ScaleAudio(This,pAudioFormatId,pWaveFormatEx) + +#define ISpRecoResult_GetRecoContext(This,ppRecoContext) \ + (This)->lpVtbl -> GetRecoContext(This,ppRecoContext) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpRecoResult_GetResultTimes_Proxy( + ISpRecoResult * This, + /* [out] */ SPRECORESULTTIMES *pTimes); + + +void __RPC_STUB ISpRecoResult_GetResultTimes_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoResult_GetAlternates_Proxy( + ISpRecoResult * This, + /* [in] */ ULONG ulStartElement, + /* [in] */ ULONG cElements, + /* [in] */ ULONG ulRequestCount, + /* [out] */ ISpPhraseAlt **ppPhrases, + /* [out] */ ULONG *pcPhrasesReturned); + + +void __RPC_STUB ISpRecoResult_GetAlternates_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoResult_GetAudio_Proxy( + ISpRecoResult * This, + /* [in] */ ULONG ulStartElement, + /* [in] */ ULONG cElements, + /* [out] */ ISpStreamFormat **ppStream); + + +void __RPC_STUB ISpRecoResult_GetAudio_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoResult_SpeakAudio_Proxy( + ISpRecoResult * This, + /* [in] */ ULONG ulStartElement, + /* [in] */ ULONG cElements, + /* [in] */ DWORD dwFlags, + /* [out] */ ULONG *pulStreamNumber); + + +void __RPC_STUB ISpRecoResult_SpeakAudio_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoResult_Serialize_Proxy( + ISpRecoResult * This, + /* [out] */ SPSERIALIZEDRESULT **ppCoMemSerializedResult); + + +void __RPC_STUB ISpRecoResult_Serialize_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoResult_ScaleAudio_Proxy( + ISpRecoResult * This, + /* [in] */ const GUID *pAudioFormatId, + /* [in] */ const WAVEFORMATEX *pWaveFormatEx); + + +void __RPC_STUB ISpRecoResult_ScaleAudio_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoResult_GetRecoContext_Proxy( + ISpRecoResult * This, + /* [out] */ ISpRecoContext **ppRecoContext); + + +void __RPC_STUB ISpRecoResult_GetRecoContext_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpRecoResult_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_sapi_0277 */ +/* [local] */ + +typedef /* [hidden] */ struct tagSPTEXTSELECTIONINFO + { + ULONG ulStartActiveOffset; + ULONG cchActiveChars; + ULONG ulStartSelection; + ULONG cchSelection; + } SPTEXTSELECTIONINFO; + +typedef /* [hidden] */ +enum SPWORDPRONOUNCEABLE + { SPWP_UNKNOWN_WORD_UNPRONOUNCEABLE = 0, + SPWP_UNKNOWN_WORD_PRONOUNCEABLE = 1, + SPWP_KNOWN_WORD_PRONOUNCEABLE = 2 + } SPWORDPRONOUNCEABLE; + +typedef /* [hidden] */ +enum SPGRAMMARSTATE + { SPGS_DISABLED = 0, + SPGS_ENABLED = 1, + SPGS_EXCLUSIVE = 3 + } SPGRAMMARSTATE; + +typedef /* [hidden] */ +enum SPCONTEXTSTATE + { SPCS_DISABLED = 0, + SPCS_ENABLED = 1 + } SPCONTEXTSTATE; + +typedef /* [hidden] */ +enum SPRULESTATE + { SPRS_INACTIVE = 0, + SPRS_ACTIVE = 1, + SPRS_ACTIVE_WITH_AUTO_PAUSE = 3 + } SPRULESTATE; + +#define SP_STREAMPOS_ASAP ( 0 ) + +#define SP_STREAMPOS_REALTIME ( -1 ) + +#define SPRULETRANS_TEXTBUFFER (SPSTATEHANDLE)(-1) +#define SPRULETRANS_WILDCARD (SPSTATEHANDLE)(-2) +#define SPRULETRANS_DICTATION (SPSTATEHANDLE)(-3) +typedef /* [hidden] */ +enum SPGRAMMARWORDTYPE + { SPWT_DISPLAY = 0, + SPWT_LEXICAL = SPWT_DISPLAY + 1, + SPWT_PRONUNCIATION = SPWT_LEXICAL + 1 + } SPGRAMMARWORDTYPE; + +typedef /* [hidden] */ struct tagSPPROPERTYINFO + { + const WCHAR *pszName; + ULONG ulId; + const WCHAR *pszValue; + VARIANT vValue; + } SPPROPERTYINFO; + +typedef /* [hidden] */ +enum SPCFGRULEATTRIBUTES + { SPRAF_TopLevel = 1 << 0, + SPRAF_Active = 1 << 1, + SPRAF_Export = 1 << 2, + SPRAF_Import = 1 << 3, + SPRAF_Interpreter = 1 << 4, + SPRAF_Dynamic = 1 << 5, + SPRAF_AutoPause = 1 << 16 + } SPCFGRULEATTRIBUTES; + + + +extern RPC_IF_HANDLE __MIDL_itf_sapi_0277_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_sapi_0277_v0_0_s_ifspec; + +#ifndef __ISpGrammarBuilder_INTERFACE_DEFINED__ +#define __ISpGrammarBuilder_INTERFACE_DEFINED__ + +/* interface ISpGrammarBuilder */ +/* [local][restricted][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpGrammarBuilder; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("8137828F-591A-4A42-BE58-49EA7EBAAC68") + ISpGrammarBuilder : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE ResetGrammar( + /* [in] */ WORD NewLanguage) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetRule( + /* [in] */ const WCHAR *pszRuleName, + /* [in] */ DWORD dwRuleId, + /* [in] */ DWORD dwAttributes, + /* [in] */ BOOL fCreateIfNotExist, + /* [out] */ SPSTATEHANDLE *phInitialState) = 0; + + virtual HRESULT STDMETHODCALLTYPE ClearRule( + SPSTATEHANDLE hState) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateNewState( + SPSTATEHANDLE hState, + SPSTATEHANDLE *phState) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddWordTransition( + SPSTATEHANDLE hFromState, + SPSTATEHANDLE hToState, + const WCHAR *psz, + const WCHAR *pszSeparators, + SPGRAMMARWORDTYPE eWordType, + float Weight, + const SPPROPERTYINFO *pPropInfo) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddRuleTransition( + SPSTATEHANDLE hFromState, + SPSTATEHANDLE hToState, + SPSTATEHANDLE hRule, + float Weight, + const SPPROPERTYINFO *pPropInfo) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddResource( + /* [in] */ SPSTATEHANDLE hRuleState, + /* [in] */ const WCHAR *pszResourceName, + /* [in] */ const WCHAR *pszResourceValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE Commit( + DWORD dwReserved) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpGrammarBuilderVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpGrammarBuilder * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpGrammarBuilder * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpGrammarBuilder * This); + + HRESULT ( STDMETHODCALLTYPE *ResetGrammar )( + ISpGrammarBuilder * This, + /* [in] */ WORD NewLanguage); + + HRESULT ( STDMETHODCALLTYPE *GetRule )( + ISpGrammarBuilder * This, + /* [in] */ const WCHAR *pszRuleName, + /* [in] */ DWORD dwRuleId, + /* [in] */ DWORD dwAttributes, + /* [in] */ BOOL fCreateIfNotExist, + /* [out] */ SPSTATEHANDLE *phInitialState); + + HRESULT ( STDMETHODCALLTYPE *ClearRule )( + ISpGrammarBuilder * This, + SPSTATEHANDLE hState); + + HRESULT ( STDMETHODCALLTYPE *CreateNewState )( + ISpGrammarBuilder * This, + SPSTATEHANDLE hState, + SPSTATEHANDLE *phState); + + HRESULT ( STDMETHODCALLTYPE *AddWordTransition )( + ISpGrammarBuilder * This, + SPSTATEHANDLE hFromState, + SPSTATEHANDLE hToState, + const WCHAR *psz, + const WCHAR *pszSeparators, + SPGRAMMARWORDTYPE eWordType, + float Weight, + const SPPROPERTYINFO *pPropInfo); + + HRESULT ( STDMETHODCALLTYPE *AddRuleTransition )( + ISpGrammarBuilder * This, + SPSTATEHANDLE hFromState, + SPSTATEHANDLE hToState, + SPSTATEHANDLE hRule, + float Weight, + const SPPROPERTYINFO *pPropInfo); + + HRESULT ( STDMETHODCALLTYPE *AddResource )( + ISpGrammarBuilder * This, + /* [in] */ SPSTATEHANDLE hRuleState, + /* [in] */ const WCHAR *pszResourceName, + /* [in] */ const WCHAR *pszResourceValue); + + HRESULT ( STDMETHODCALLTYPE *Commit )( + ISpGrammarBuilder * This, + DWORD dwReserved); + + END_INTERFACE + } ISpGrammarBuilderVtbl; + + interface ISpGrammarBuilder + { + CONST_VTBL struct ISpGrammarBuilderVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpGrammarBuilder_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpGrammarBuilder_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpGrammarBuilder_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpGrammarBuilder_ResetGrammar(This,NewLanguage) \ + (This)->lpVtbl -> ResetGrammar(This,NewLanguage) + +#define ISpGrammarBuilder_GetRule(This,pszRuleName,dwRuleId,dwAttributes,fCreateIfNotExist,phInitialState) \ + (This)->lpVtbl -> GetRule(This,pszRuleName,dwRuleId,dwAttributes,fCreateIfNotExist,phInitialState) + +#define ISpGrammarBuilder_ClearRule(This,hState) \ + (This)->lpVtbl -> ClearRule(This,hState) + +#define ISpGrammarBuilder_CreateNewState(This,hState,phState) \ + (This)->lpVtbl -> CreateNewState(This,hState,phState) + +#define ISpGrammarBuilder_AddWordTransition(This,hFromState,hToState,psz,pszSeparators,eWordType,Weight,pPropInfo) \ + (This)->lpVtbl -> AddWordTransition(This,hFromState,hToState,psz,pszSeparators,eWordType,Weight,pPropInfo) + +#define ISpGrammarBuilder_AddRuleTransition(This,hFromState,hToState,hRule,Weight,pPropInfo) \ + (This)->lpVtbl -> AddRuleTransition(This,hFromState,hToState,hRule,Weight,pPropInfo) + +#define ISpGrammarBuilder_AddResource(This,hRuleState,pszResourceName,pszResourceValue) \ + (This)->lpVtbl -> AddResource(This,hRuleState,pszResourceName,pszResourceValue) + +#define ISpGrammarBuilder_Commit(This,dwReserved) \ + (This)->lpVtbl -> Commit(This,dwReserved) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpGrammarBuilder_ResetGrammar_Proxy( + ISpGrammarBuilder * This, + /* [in] */ WORD NewLanguage); + + +void __RPC_STUB ISpGrammarBuilder_ResetGrammar_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpGrammarBuilder_GetRule_Proxy( + ISpGrammarBuilder * This, + /* [in] */ const WCHAR *pszRuleName, + /* [in] */ DWORD dwRuleId, + /* [in] */ DWORD dwAttributes, + /* [in] */ BOOL fCreateIfNotExist, + /* [out] */ SPSTATEHANDLE *phInitialState); + + +void __RPC_STUB ISpGrammarBuilder_GetRule_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpGrammarBuilder_ClearRule_Proxy( + ISpGrammarBuilder * This, + SPSTATEHANDLE hState); + + +void __RPC_STUB ISpGrammarBuilder_ClearRule_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpGrammarBuilder_CreateNewState_Proxy( + ISpGrammarBuilder * This, + SPSTATEHANDLE hState, + SPSTATEHANDLE *phState); + + +void __RPC_STUB ISpGrammarBuilder_CreateNewState_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpGrammarBuilder_AddWordTransition_Proxy( + ISpGrammarBuilder * This, + SPSTATEHANDLE hFromState, + SPSTATEHANDLE hToState, + const WCHAR *psz, + const WCHAR *pszSeparators, + SPGRAMMARWORDTYPE eWordType, + float Weight, + const SPPROPERTYINFO *pPropInfo); + + +void __RPC_STUB ISpGrammarBuilder_AddWordTransition_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpGrammarBuilder_AddRuleTransition_Proxy( + ISpGrammarBuilder * This, + SPSTATEHANDLE hFromState, + SPSTATEHANDLE hToState, + SPSTATEHANDLE hRule, + float Weight, + const SPPROPERTYINFO *pPropInfo); + + +void __RPC_STUB ISpGrammarBuilder_AddRuleTransition_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpGrammarBuilder_AddResource_Proxy( + ISpGrammarBuilder * This, + /* [in] */ SPSTATEHANDLE hRuleState, + /* [in] */ const WCHAR *pszResourceName, + /* [in] */ const WCHAR *pszResourceValue); + + +void __RPC_STUB ISpGrammarBuilder_AddResource_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpGrammarBuilder_Commit_Proxy( + ISpGrammarBuilder * This, + DWORD dwReserved); + + +void __RPC_STUB ISpGrammarBuilder_Commit_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpGrammarBuilder_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_sapi_0278 */ +/* [local] */ + +typedef /* [hidden] */ +enum SPLOADOPTIONS + { SPLO_STATIC = 0, + SPLO_DYNAMIC = 1 + } SPLOADOPTIONS; + + + +extern RPC_IF_HANDLE __MIDL_itf_sapi_0278_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_sapi_0278_v0_0_s_ifspec; + +#ifndef __ISpRecoGrammar_INTERFACE_DEFINED__ +#define __ISpRecoGrammar_INTERFACE_DEFINED__ + +/* interface ISpRecoGrammar */ +/* [local][restricted][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpRecoGrammar; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("2177DB29-7F45-47D0-8554-067E91C80502") + ISpRecoGrammar : public ISpGrammarBuilder + { + public: + virtual HRESULT STDMETHODCALLTYPE GetGrammarId( + /* [out] */ ULONGLONG *pullGrammarId) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetRecoContext( + /* [out] */ ISpRecoContext **ppRecoCtxt) = 0; + + virtual HRESULT STDMETHODCALLTYPE LoadCmdFromFile( + /* [string][in] */ const WCHAR *pszFileName, + /* [in] */ SPLOADOPTIONS Options) = 0; + + virtual HRESULT STDMETHODCALLTYPE LoadCmdFromObject( + /* [in] */ REFCLSID rcid, + /* [string][in] */ const WCHAR *pszGrammarName, + /* [in] */ SPLOADOPTIONS Options) = 0; + + virtual HRESULT STDMETHODCALLTYPE LoadCmdFromResource( + /* [in] */ HMODULE hModule, + /* [string][in] */ const WCHAR *pszResourceName, + /* [string][in] */ const WCHAR *pszResourceType, + /* [in] */ WORD wLanguage, + /* [in] */ SPLOADOPTIONS Options) = 0; + + virtual HRESULT STDMETHODCALLTYPE LoadCmdFromMemory( + /* [in] */ const SPBINARYGRAMMAR *pGrammar, + /* [in] */ SPLOADOPTIONS Options) = 0; + + virtual HRESULT STDMETHODCALLTYPE LoadCmdFromProprietaryGrammar( + /* [in] */ REFGUID rguidParam, + /* [string][in] */ const WCHAR *pszStringParam, + /* [in] */ const void *pvDataPrarm, + /* [in] */ ULONG cbDataSize, + /* [in] */ SPLOADOPTIONS Options) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetRuleState( + /* [string][in] */ const WCHAR *pszName, + void *pReserved, + /* [in] */ SPRULESTATE NewState) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetRuleIdState( + /* [in] */ ULONG ulRuleId, + /* [in] */ SPRULESTATE NewState) = 0; + + virtual HRESULT STDMETHODCALLTYPE LoadDictation( + /* [string][in] */ const WCHAR *pszTopicName, + /* [in] */ SPLOADOPTIONS Options) = 0; + + virtual HRESULT STDMETHODCALLTYPE UnloadDictation( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetDictationState( + /* [in] */ SPRULESTATE NewState) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetWordSequenceData( + /* [in] */ const WCHAR *pText, + /* [in] */ ULONG cchText, + /* [in] */ const SPTEXTSELECTIONINFO *pInfo) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetTextSelection( + /* [in] */ const SPTEXTSELECTIONINFO *pInfo) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsPronounceable( + /* [string][in] */ const WCHAR *pszWord, + /* [out] */ SPWORDPRONOUNCEABLE *pWordPronounceable) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetGrammarState( + /* [in] */ SPGRAMMARSTATE eGrammarState) = 0; + + virtual HRESULT STDMETHODCALLTYPE SaveCmd( + /* [in] */ IStream *pStream, + /* [optional][out] */ WCHAR **ppszCoMemErrorText) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetGrammarState( + /* [out] */ SPGRAMMARSTATE *peGrammarState) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpRecoGrammarVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpRecoGrammar * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpRecoGrammar * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpRecoGrammar * This); + + HRESULT ( STDMETHODCALLTYPE *ResetGrammar )( + ISpRecoGrammar * This, + /* [in] */ WORD NewLanguage); + + HRESULT ( STDMETHODCALLTYPE *GetRule )( + ISpRecoGrammar * This, + /* [in] */ const WCHAR *pszRuleName, + /* [in] */ DWORD dwRuleId, + /* [in] */ DWORD dwAttributes, + /* [in] */ BOOL fCreateIfNotExist, + /* [out] */ SPSTATEHANDLE *phInitialState); + + HRESULT ( STDMETHODCALLTYPE *ClearRule )( + ISpRecoGrammar * This, + SPSTATEHANDLE hState); + + HRESULT ( STDMETHODCALLTYPE *CreateNewState )( + ISpRecoGrammar * This, + SPSTATEHANDLE hState, + SPSTATEHANDLE *phState); + + HRESULT ( STDMETHODCALLTYPE *AddWordTransition )( + ISpRecoGrammar * This, + SPSTATEHANDLE hFromState, + SPSTATEHANDLE hToState, + const WCHAR *psz, + const WCHAR *pszSeparators, + SPGRAMMARWORDTYPE eWordType, + float Weight, + const SPPROPERTYINFO *pPropInfo); + + HRESULT ( STDMETHODCALLTYPE *AddRuleTransition )( + ISpRecoGrammar * This, + SPSTATEHANDLE hFromState, + SPSTATEHANDLE hToState, + SPSTATEHANDLE hRule, + float Weight, + const SPPROPERTYINFO *pPropInfo); + + HRESULT ( STDMETHODCALLTYPE *AddResource )( + ISpRecoGrammar * This, + /* [in] */ SPSTATEHANDLE hRuleState, + /* [in] */ const WCHAR *pszResourceName, + /* [in] */ const WCHAR *pszResourceValue); + + HRESULT ( STDMETHODCALLTYPE *Commit )( + ISpRecoGrammar * This, + DWORD dwReserved); + + HRESULT ( STDMETHODCALLTYPE *GetGrammarId )( + ISpRecoGrammar * This, + /* [out] */ ULONGLONG *pullGrammarId); + + HRESULT ( STDMETHODCALLTYPE *GetRecoContext )( + ISpRecoGrammar * This, + /* [out] */ ISpRecoContext **ppRecoCtxt); + + HRESULT ( STDMETHODCALLTYPE *LoadCmdFromFile )( + ISpRecoGrammar * This, + /* [string][in] */ const WCHAR *pszFileName, + /* [in] */ SPLOADOPTIONS Options); + + HRESULT ( STDMETHODCALLTYPE *LoadCmdFromObject )( + ISpRecoGrammar * This, + /* [in] */ REFCLSID rcid, + /* [string][in] */ const WCHAR *pszGrammarName, + /* [in] */ SPLOADOPTIONS Options); + + HRESULT ( STDMETHODCALLTYPE *LoadCmdFromResource )( + ISpRecoGrammar * This, + /* [in] */ HMODULE hModule, + /* [string][in] */ const WCHAR *pszResourceName, + /* [string][in] */ const WCHAR *pszResourceType, + /* [in] */ WORD wLanguage, + /* [in] */ SPLOADOPTIONS Options); + + HRESULT ( STDMETHODCALLTYPE *LoadCmdFromMemory )( + ISpRecoGrammar * This, + /* [in] */ const SPBINARYGRAMMAR *pGrammar, + /* [in] */ SPLOADOPTIONS Options); + + HRESULT ( STDMETHODCALLTYPE *LoadCmdFromProprietaryGrammar )( + ISpRecoGrammar * This, + /* [in] */ REFGUID rguidParam, + /* [string][in] */ const WCHAR *pszStringParam, + /* [in] */ const void *pvDataPrarm, + /* [in] */ ULONG cbDataSize, + /* [in] */ SPLOADOPTIONS Options); + + HRESULT ( STDMETHODCALLTYPE *SetRuleState )( + ISpRecoGrammar * This, + /* [string][in] */ const WCHAR *pszName, + void *pReserved, + /* [in] */ SPRULESTATE NewState); + + HRESULT ( STDMETHODCALLTYPE *SetRuleIdState )( + ISpRecoGrammar * This, + /* [in] */ ULONG ulRuleId, + /* [in] */ SPRULESTATE NewState); + + HRESULT ( STDMETHODCALLTYPE *LoadDictation )( + ISpRecoGrammar * This, + /* [string][in] */ const WCHAR *pszTopicName, + /* [in] */ SPLOADOPTIONS Options); + + HRESULT ( STDMETHODCALLTYPE *UnloadDictation )( + ISpRecoGrammar * This); + + HRESULT ( STDMETHODCALLTYPE *SetDictationState )( + ISpRecoGrammar * This, + /* [in] */ SPRULESTATE NewState); + + HRESULT ( STDMETHODCALLTYPE *SetWordSequenceData )( + ISpRecoGrammar * This, + /* [in] */ const WCHAR *pText, + /* [in] */ ULONG cchText, + /* [in] */ const SPTEXTSELECTIONINFO *pInfo); + + HRESULT ( STDMETHODCALLTYPE *SetTextSelection )( + ISpRecoGrammar * This, + /* [in] */ const SPTEXTSELECTIONINFO *pInfo); + + HRESULT ( STDMETHODCALLTYPE *IsPronounceable )( + ISpRecoGrammar * This, + /* [string][in] */ const WCHAR *pszWord, + /* [out] */ SPWORDPRONOUNCEABLE *pWordPronounceable); + + HRESULT ( STDMETHODCALLTYPE *SetGrammarState )( + ISpRecoGrammar * This, + /* [in] */ SPGRAMMARSTATE eGrammarState); + + HRESULT ( STDMETHODCALLTYPE *SaveCmd )( + ISpRecoGrammar * This, + /* [in] */ IStream *pStream, + /* [optional][out] */ WCHAR **ppszCoMemErrorText); + + HRESULT ( STDMETHODCALLTYPE *GetGrammarState )( + ISpRecoGrammar * This, + /* [out] */ SPGRAMMARSTATE *peGrammarState); + + END_INTERFACE + } ISpRecoGrammarVtbl; + + interface ISpRecoGrammar + { + CONST_VTBL struct ISpRecoGrammarVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpRecoGrammar_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpRecoGrammar_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpRecoGrammar_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpRecoGrammar_ResetGrammar(This,NewLanguage) \ + (This)->lpVtbl -> ResetGrammar(This,NewLanguage) + +#define ISpRecoGrammar_GetRule(This,pszRuleName,dwRuleId,dwAttributes,fCreateIfNotExist,phInitialState) \ + (This)->lpVtbl -> GetRule(This,pszRuleName,dwRuleId,dwAttributes,fCreateIfNotExist,phInitialState) + +#define ISpRecoGrammar_ClearRule(This,hState) \ + (This)->lpVtbl -> ClearRule(This,hState) + +#define ISpRecoGrammar_CreateNewState(This,hState,phState) \ + (This)->lpVtbl -> CreateNewState(This,hState,phState) + +#define ISpRecoGrammar_AddWordTransition(This,hFromState,hToState,psz,pszSeparators,eWordType,Weight,pPropInfo) \ + (This)->lpVtbl -> AddWordTransition(This,hFromState,hToState,psz,pszSeparators,eWordType,Weight,pPropInfo) + +#define ISpRecoGrammar_AddRuleTransition(This,hFromState,hToState,hRule,Weight,pPropInfo) \ + (This)->lpVtbl -> AddRuleTransition(This,hFromState,hToState,hRule,Weight,pPropInfo) + +#define ISpRecoGrammar_AddResource(This,hRuleState,pszResourceName,pszResourceValue) \ + (This)->lpVtbl -> AddResource(This,hRuleState,pszResourceName,pszResourceValue) + +#define ISpRecoGrammar_Commit(This,dwReserved) \ + (This)->lpVtbl -> Commit(This,dwReserved) + + +#define ISpRecoGrammar_GetGrammarId(This,pullGrammarId) \ + (This)->lpVtbl -> GetGrammarId(This,pullGrammarId) + +#define ISpRecoGrammar_GetRecoContext(This,ppRecoCtxt) \ + (This)->lpVtbl -> GetRecoContext(This,ppRecoCtxt) + +#define ISpRecoGrammar_LoadCmdFromFile(This,pszFileName,Options) \ + (This)->lpVtbl -> LoadCmdFromFile(This,pszFileName,Options) + +#define ISpRecoGrammar_LoadCmdFromObject(This,rcid,pszGrammarName,Options) \ + (This)->lpVtbl -> LoadCmdFromObject(This,rcid,pszGrammarName,Options) + +#define ISpRecoGrammar_LoadCmdFromResource(This,hModule,pszResourceName,pszResourceType,wLanguage,Options) \ + (This)->lpVtbl -> LoadCmdFromResource(This,hModule,pszResourceName,pszResourceType,wLanguage,Options) + +#define ISpRecoGrammar_LoadCmdFromMemory(This,pGrammar,Options) \ + (This)->lpVtbl -> LoadCmdFromMemory(This,pGrammar,Options) + +#define ISpRecoGrammar_LoadCmdFromProprietaryGrammar(This,rguidParam,pszStringParam,pvDataPrarm,cbDataSize,Options) \ + (This)->lpVtbl -> LoadCmdFromProprietaryGrammar(This,rguidParam,pszStringParam,pvDataPrarm,cbDataSize,Options) + +#define ISpRecoGrammar_SetRuleState(This,pszName,pReserved,NewState) \ + (This)->lpVtbl -> SetRuleState(This,pszName,pReserved,NewState) + +#define ISpRecoGrammar_SetRuleIdState(This,ulRuleId,NewState) \ + (This)->lpVtbl -> SetRuleIdState(This,ulRuleId,NewState) + +#define ISpRecoGrammar_LoadDictation(This,pszTopicName,Options) \ + (This)->lpVtbl -> LoadDictation(This,pszTopicName,Options) + +#define ISpRecoGrammar_UnloadDictation(This) \ + (This)->lpVtbl -> UnloadDictation(This) + +#define ISpRecoGrammar_SetDictationState(This,NewState) \ + (This)->lpVtbl -> SetDictationState(This,NewState) + +#define ISpRecoGrammar_SetWordSequenceData(This,pText,cchText,pInfo) \ + (This)->lpVtbl -> SetWordSequenceData(This,pText,cchText,pInfo) + +#define ISpRecoGrammar_SetTextSelection(This,pInfo) \ + (This)->lpVtbl -> SetTextSelection(This,pInfo) + +#define ISpRecoGrammar_IsPronounceable(This,pszWord,pWordPronounceable) \ + (This)->lpVtbl -> IsPronounceable(This,pszWord,pWordPronounceable) + +#define ISpRecoGrammar_SetGrammarState(This,eGrammarState) \ + (This)->lpVtbl -> SetGrammarState(This,eGrammarState) + +#define ISpRecoGrammar_SaveCmd(This,pStream,ppszCoMemErrorText) \ + (This)->lpVtbl -> SaveCmd(This,pStream,ppszCoMemErrorText) + +#define ISpRecoGrammar_GetGrammarState(This,peGrammarState) \ + (This)->lpVtbl -> GetGrammarState(This,peGrammarState) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpRecoGrammar_GetGrammarId_Proxy( + ISpRecoGrammar * This, + /* [out] */ ULONGLONG *pullGrammarId); + + +void __RPC_STUB ISpRecoGrammar_GetGrammarId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoGrammar_GetRecoContext_Proxy( + ISpRecoGrammar * This, + /* [out] */ ISpRecoContext **ppRecoCtxt); + + +void __RPC_STUB ISpRecoGrammar_GetRecoContext_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoGrammar_LoadCmdFromFile_Proxy( + ISpRecoGrammar * This, + /* [string][in] */ const WCHAR *pszFileName, + /* [in] */ SPLOADOPTIONS Options); + + +void __RPC_STUB ISpRecoGrammar_LoadCmdFromFile_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoGrammar_LoadCmdFromObject_Proxy( + ISpRecoGrammar * This, + /* [in] */ REFCLSID rcid, + /* [string][in] */ const WCHAR *pszGrammarName, + /* [in] */ SPLOADOPTIONS Options); + + +void __RPC_STUB ISpRecoGrammar_LoadCmdFromObject_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoGrammar_LoadCmdFromResource_Proxy( + ISpRecoGrammar * This, + /* [in] */ HMODULE hModule, + /* [string][in] */ const WCHAR *pszResourceName, + /* [string][in] */ const WCHAR *pszResourceType, + /* [in] */ WORD wLanguage, + /* [in] */ SPLOADOPTIONS Options); + + +void __RPC_STUB ISpRecoGrammar_LoadCmdFromResource_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoGrammar_LoadCmdFromMemory_Proxy( + ISpRecoGrammar * This, + /* [in] */ const SPBINARYGRAMMAR *pGrammar, + /* [in] */ SPLOADOPTIONS Options); + + +void __RPC_STUB ISpRecoGrammar_LoadCmdFromMemory_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoGrammar_LoadCmdFromProprietaryGrammar_Proxy( + ISpRecoGrammar * This, + /* [in] */ REFGUID rguidParam, + /* [string][in] */ const WCHAR *pszStringParam, + /* [in] */ const void *pvDataPrarm, + /* [in] */ ULONG cbDataSize, + /* [in] */ SPLOADOPTIONS Options); + + +void __RPC_STUB ISpRecoGrammar_LoadCmdFromProprietaryGrammar_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoGrammar_SetRuleState_Proxy( + ISpRecoGrammar * This, + /* [string][in] */ const WCHAR *pszName, + void *pReserved, + /* [in] */ SPRULESTATE NewState); + + +void __RPC_STUB ISpRecoGrammar_SetRuleState_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoGrammar_SetRuleIdState_Proxy( + ISpRecoGrammar * This, + /* [in] */ ULONG ulRuleId, + /* [in] */ SPRULESTATE NewState); + + +void __RPC_STUB ISpRecoGrammar_SetRuleIdState_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoGrammar_LoadDictation_Proxy( + ISpRecoGrammar * This, + /* [string][in] */ const WCHAR *pszTopicName, + /* [in] */ SPLOADOPTIONS Options); + + +void __RPC_STUB ISpRecoGrammar_LoadDictation_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoGrammar_UnloadDictation_Proxy( + ISpRecoGrammar * This); + + +void __RPC_STUB ISpRecoGrammar_UnloadDictation_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoGrammar_SetDictationState_Proxy( + ISpRecoGrammar * This, + /* [in] */ SPRULESTATE NewState); + + +void __RPC_STUB ISpRecoGrammar_SetDictationState_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoGrammar_SetWordSequenceData_Proxy( + ISpRecoGrammar * This, + /* [in] */ const WCHAR *pText, + /* [in] */ ULONG cchText, + /* [in] */ const SPTEXTSELECTIONINFO *pInfo); + + +void __RPC_STUB ISpRecoGrammar_SetWordSequenceData_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoGrammar_SetTextSelection_Proxy( + ISpRecoGrammar * This, + /* [in] */ const SPTEXTSELECTIONINFO *pInfo); + + +void __RPC_STUB ISpRecoGrammar_SetTextSelection_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoGrammar_IsPronounceable_Proxy( + ISpRecoGrammar * This, + /* [string][in] */ const WCHAR *pszWord, + /* [out] */ SPWORDPRONOUNCEABLE *pWordPronounceable); + + +void __RPC_STUB ISpRecoGrammar_IsPronounceable_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoGrammar_SetGrammarState_Proxy( + ISpRecoGrammar * This, + /* [in] */ SPGRAMMARSTATE eGrammarState); + + +void __RPC_STUB ISpRecoGrammar_SetGrammarState_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoGrammar_SaveCmd_Proxy( + ISpRecoGrammar * This, + /* [in] */ IStream *pStream, + /* [optional][out] */ WCHAR **ppszCoMemErrorText); + + +void __RPC_STUB ISpRecoGrammar_SaveCmd_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoGrammar_GetGrammarState_Proxy( + ISpRecoGrammar * This, + /* [out] */ SPGRAMMARSTATE *peGrammarState); + + +void __RPC_STUB ISpRecoGrammar_GetGrammarState_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpRecoGrammar_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_sapi_0279 */ +/* [local] */ + +typedef /* [hidden][restricted] */ struct SPRECOCONTEXTSTATUS + { + SPINTERFERENCE eInterference; + WCHAR szRequestTypeOfUI[ 255 ]; + DWORD dwReserved1; + DWORD dwReserved2; + } SPRECOCONTEXTSTATUS; + +typedef /* [hidden] */ +enum SPBOOKMARKOPTIONS + { SPBO_NONE = 0, + SPBO_PAUSE = 1 + } SPBOOKMARKOPTIONS; + +typedef /* [hidden] */ +enum SPAUDIOOPTIONS + { SPAO_NONE = 0, + SPAO_RETAIN_AUDIO = 1 << 0 + } SPAUDIOOPTIONS; + + + +extern RPC_IF_HANDLE __MIDL_itf_sapi_0279_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_sapi_0279_v0_0_s_ifspec; + +#ifndef __ISpRecoContext_INTERFACE_DEFINED__ +#define __ISpRecoContext_INTERFACE_DEFINED__ + +/* interface ISpRecoContext */ +/* [restricted][local][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpRecoContext; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("F740A62F-7C15-489E-8234-940A33D9272D") + ISpRecoContext : public ISpEventSource + { + public: + virtual HRESULT STDMETHODCALLTYPE GetRecognizer( + /* [out] */ ISpRecognizer **ppRecognizer) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateGrammar( + /* [in] */ ULONGLONG ullGrammarId, + /* [out] */ ISpRecoGrammar **ppGrammar) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStatus( + /* [out] */ SPRECOCONTEXTSTATUS *pStatus) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMaxAlternates( + /* [in] */ ULONG *pcAlternates) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetMaxAlternates( + /* [in] */ ULONG cAlternates) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetAudioOptions( + /* [in] */ SPAUDIOOPTIONS Options, + /* [in] */ const GUID *pAudioFormatId, + /* [in] */ const WAVEFORMATEX *pWaveFormatEx) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAudioOptions( + /* [in] */ SPAUDIOOPTIONS *pOptions, + /* [out] */ GUID *pAudioFormatId, + /* [out] */ WAVEFORMATEX **ppCoMemWFEX) = 0; + + virtual HRESULT STDMETHODCALLTYPE DeserializeResult( + /* [in] */ const SPSERIALIZEDRESULT *pSerializedResult, + /* [out] */ ISpRecoResult **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE Bookmark( + /* [in] */ SPBOOKMARKOPTIONS Options, + /* [in] */ ULONGLONG ullStreamPosition, + /* [in] */ LPARAM lparamEvent) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetAdaptationData( + /* [string][in] */ const WCHAR *pAdaptationData, + /* [in] */ const ULONG cch) = 0; + + virtual HRESULT STDMETHODCALLTYPE Pause( + DWORD dwReserved) = 0; + + virtual HRESULT STDMETHODCALLTYPE Resume( + DWORD dwReserved) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetVoice( + /* [in] */ ISpVoice *pVoice, + /* [in] */ BOOL fAllowFormatChanges) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetVoice( + /* [out] */ ISpVoice **ppVoice) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetVoicePurgeEvent( + /* [in] */ ULONGLONG ullEventInterest) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetVoicePurgeEvent( + /* [out] */ ULONGLONG *pullEventInterest) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetContextState( + /* [in] */ SPCONTEXTSTATE eContextState) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetContextState( + /* [in] */ SPCONTEXTSTATE *peContextState) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpRecoContextVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpRecoContext * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpRecoContext * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpRecoContext * This); + + HRESULT ( STDMETHODCALLTYPE *SetNotifySink )( + ISpRecoContext * This, + /* [in] */ ISpNotifySink *pNotifySink); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *SetNotifyWindowMessage )( + ISpRecoContext * This, + /* [in] */ HWND hWnd, + /* [in] */ UINT Msg, + /* [in] */ WPARAM wParam, + /* [in] */ LPARAM lParam); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *SetNotifyCallbackFunction )( + ISpRecoContext * This, + /* [in] */ SPNOTIFYCALLBACK *pfnCallback, + /* [in] */ WPARAM wParam, + /* [in] */ LPARAM lParam); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *SetNotifyCallbackInterface )( + ISpRecoContext * This, + /* [in] */ ISpNotifyCallback *pSpCallback, + /* [in] */ WPARAM wParam, + /* [in] */ LPARAM lParam); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *SetNotifyWin32Event )( + ISpRecoContext * This); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *WaitForNotifyEvent )( + ISpRecoContext * This, + /* [in] */ DWORD dwMilliseconds); + + /* [local] */ HANDLE ( STDMETHODCALLTYPE *GetNotifyEventHandle )( + ISpRecoContext * This); + + HRESULT ( STDMETHODCALLTYPE *SetInterest )( + ISpRecoContext * This, + /* [in] */ ULONGLONG ullEventInterest, + /* [in] */ ULONGLONG ullQueuedInterest); + + HRESULT ( STDMETHODCALLTYPE *GetEvents )( + ISpRecoContext * This, + /* [in] */ ULONG ulCount, + /* [size_is][out] */ SPEVENT *pEventArray, + /* [out] */ ULONG *pulFetched); + + HRESULT ( STDMETHODCALLTYPE *GetInfo )( + ISpRecoContext * This, + /* [out] */ SPEVENTSOURCEINFO *pInfo); + + HRESULT ( STDMETHODCALLTYPE *GetRecognizer )( + ISpRecoContext * This, + /* [out] */ ISpRecognizer **ppRecognizer); + + HRESULT ( STDMETHODCALLTYPE *CreateGrammar )( + ISpRecoContext * This, + /* [in] */ ULONGLONG ullGrammarId, + /* [out] */ ISpRecoGrammar **ppGrammar); + + HRESULT ( STDMETHODCALLTYPE *GetStatus )( + ISpRecoContext * This, + /* [out] */ SPRECOCONTEXTSTATUS *pStatus); + + HRESULT ( STDMETHODCALLTYPE *GetMaxAlternates )( + ISpRecoContext * This, + /* [in] */ ULONG *pcAlternates); + + HRESULT ( STDMETHODCALLTYPE *SetMaxAlternates )( + ISpRecoContext * This, + /* [in] */ ULONG cAlternates); + + HRESULT ( STDMETHODCALLTYPE *SetAudioOptions )( + ISpRecoContext * This, + /* [in] */ SPAUDIOOPTIONS Options, + /* [in] */ const GUID *pAudioFormatId, + /* [in] */ const WAVEFORMATEX *pWaveFormatEx); + + HRESULT ( STDMETHODCALLTYPE *GetAudioOptions )( + ISpRecoContext * This, + /* [in] */ SPAUDIOOPTIONS *pOptions, + /* [out] */ GUID *pAudioFormatId, + /* [out] */ WAVEFORMATEX **ppCoMemWFEX); + + HRESULT ( STDMETHODCALLTYPE *DeserializeResult )( + ISpRecoContext * This, + /* [in] */ const SPSERIALIZEDRESULT *pSerializedResult, + /* [out] */ ISpRecoResult **ppResult); + + HRESULT ( STDMETHODCALLTYPE *Bookmark )( + ISpRecoContext * This, + /* [in] */ SPBOOKMARKOPTIONS Options, + /* [in] */ ULONGLONG ullStreamPosition, + /* [in] */ LPARAM lparamEvent); + + HRESULT ( STDMETHODCALLTYPE *SetAdaptationData )( + ISpRecoContext * This, + /* [string][in] */ const WCHAR *pAdaptationData, + /* [in] */ const ULONG cch); + + HRESULT ( STDMETHODCALLTYPE *Pause )( + ISpRecoContext * This, + DWORD dwReserved); + + HRESULT ( STDMETHODCALLTYPE *Resume )( + ISpRecoContext * This, + DWORD dwReserved); + + HRESULT ( STDMETHODCALLTYPE *SetVoice )( + ISpRecoContext * This, + /* [in] */ ISpVoice *pVoice, + /* [in] */ BOOL fAllowFormatChanges); + + HRESULT ( STDMETHODCALLTYPE *GetVoice )( + ISpRecoContext * This, + /* [out] */ ISpVoice **ppVoice); + + HRESULT ( STDMETHODCALLTYPE *SetVoicePurgeEvent )( + ISpRecoContext * This, + /* [in] */ ULONGLONG ullEventInterest); + + HRESULT ( STDMETHODCALLTYPE *GetVoicePurgeEvent )( + ISpRecoContext * This, + /* [out] */ ULONGLONG *pullEventInterest); + + HRESULT ( STDMETHODCALLTYPE *SetContextState )( + ISpRecoContext * This, + /* [in] */ SPCONTEXTSTATE eContextState); + + HRESULT ( STDMETHODCALLTYPE *GetContextState )( + ISpRecoContext * This, + /* [in] */ SPCONTEXTSTATE *peContextState); + + END_INTERFACE + } ISpRecoContextVtbl; + + interface ISpRecoContext + { + CONST_VTBL struct ISpRecoContextVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpRecoContext_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpRecoContext_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpRecoContext_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpRecoContext_SetNotifySink(This,pNotifySink) \ + (This)->lpVtbl -> SetNotifySink(This,pNotifySink) + +#define ISpRecoContext_SetNotifyWindowMessage(This,hWnd,Msg,wParam,lParam) \ + (This)->lpVtbl -> SetNotifyWindowMessage(This,hWnd,Msg,wParam,lParam) + +#define ISpRecoContext_SetNotifyCallbackFunction(This,pfnCallback,wParam,lParam) \ + (This)->lpVtbl -> SetNotifyCallbackFunction(This,pfnCallback,wParam,lParam) + +#define ISpRecoContext_SetNotifyCallbackInterface(This,pSpCallback,wParam,lParam) \ + (This)->lpVtbl -> SetNotifyCallbackInterface(This,pSpCallback,wParam,lParam) + +#define ISpRecoContext_SetNotifyWin32Event(This) \ + (This)->lpVtbl -> SetNotifyWin32Event(This) + +#define ISpRecoContext_WaitForNotifyEvent(This,dwMilliseconds) \ + (This)->lpVtbl -> WaitForNotifyEvent(This,dwMilliseconds) + +#define ISpRecoContext_GetNotifyEventHandle(This) \ + (This)->lpVtbl -> GetNotifyEventHandle(This) + + +#define ISpRecoContext_SetInterest(This,ullEventInterest,ullQueuedInterest) \ + (This)->lpVtbl -> SetInterest(This,ullEventInterest,ullQueuedInterest) + +#define ISpRecoContext_GetEvents(This,ulCount,pEventArray,pulFetched) \ + (This)->lpVtbl -> GetEvents(This,ulCount,pEventArray,pulFetched) + +#define ISpRecoContext_GetInfo(This,pInfo) \ + (This)->lpVtbl -> GetInfo(This,pInfo) + + +#define ISpRecoContext_GetRecognizer(This,ppRecognizer) \ + (This)->lpVtbl -> GetRecognizer(This,ppRecognizer) + +#define ISpRecoContext_CreateGrammar(This,ullGrammarId,ppGrammar) \ + (This)->lpVtbl -> CreateGrammar(This,ullGrammarId,ppGrammar) + +#define ISpRecoContext_GetStatus(This,pStatus) \ + (This)->lpVtbl -> GetStatus(This,pStatus) + +#define ISpRecoContext_GetMaxAlternates(This,pcAlternates) \ + (This)->lpVtbl -> GetMaxAlternates(This,pcAlternates) + +#define ISpRecoContext_SetMaxAlternates(This,cAlternates) \ + (This)->lpVtbl -> SetMaxAlternates(This,cAlternates) + +#define ISpRecoContext_SetAudioOptions(This,Options,pAudioFormatId,pWaveFormatEx) \ + (This)->lpVtbl -> SetAudioOptions(This,Options,pAudioFormatId,pWaveFormatEx) + +#define ISpRecoContext_GetAudioOptions(This,pOptions,pAudioFormatId,ppCoMemWFEX) \ + (This)->lpVtbl -> GetAudioOptions(This,pOptions,pAudioFormatId,ppCoMemWFEX) + +#define ISpRecoContext_DeserializeResult(This,pSerializedResult,ppResult) \ + (This)->lpVtbl -> DeserializeResult(This,pSerializedResult,ppResult) + +#define ISpRecoContext_Bookmark(This,Options,ullStreamPosition,lparamEvent) \ + (This)->lpVtbl -> Bookmark(This,Options,ullStreamPosition,lparamEvent) + +#define ISpRecoContext_SetAdaptationData(This,pAdaptationData,cch) \ + (This)->lpVtbl -> SetAdaptationData(This,pAdaptationData,cch) + +#define ISpRecoContext_Pause(This,dwReserved) \ + (This)->lpVtbl -> Pause(This,dwReserved) + +#define ISpRecoContext_Resume(This,dwReserved) \ + (This)->lpVtbl -> Resume(This,dwReserved) + +#define ISpRecoContext_SetVoice(This,pVoice,fAllowFormatChanges) \ + (This)->lpVtbl -> SetVoice(This,pVoice,fAllowFormatChanges) + +#define ISpRecoContext_GetVoice(This,ppVoice) \ + (This)->lpVtbl -> GetVoice(This,ppVoice) + +#define ISpRecoContext_SetVoicePurgeEvent(This,ullEventInterest) \ + (This)->lpVtbl -> SetVoicePurgeEvent(This,ullEventInterest) + +#define ISpRecoContext_GetVoicePurgeEvent(This,pullEventInterest) \ + (This)->lpVtbl -> GetVoicePurgeEvent(This,pullEventInterest) + +#define ISpRecoContext_SetContextState(This,eContextState) \ + (This)->lpVtbl -> SetContextState(This,eContextState) + +#define ISpRecoContext_GetContextState(This,peContextState) \ + (This)->lpVtbl -> GetContextState(This,peContextState) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpRecoContext_GetRecognizer_Proxy( + ISpRecoContext * This, + /* [out] */ ISpRecognizer **ppRecognizer); + + +void __RPC_STUB ISpRecoContext_GetRecognizer_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoContext_CreateGrammar_Proxy( + ISpRecoContext * This, + /* [in] */ ULONGLONG ullGrammarId, + /* [out] */ ISpRecoGrammar **ppGrammar); + + +void __RPC_STUB ISpRecoContext_CreateGrammar_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoContext_GetStatus_Proxy( + ISpRecoContext * This, + /* [out] */ SPRECOCONTEXTSTATUS *pStatus); + + +void __RPC_STUB ISpRecoContext_GetStatus_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoContext_GetMaxAlternates_Proxy( + ISpRecoContext * This, + /* [in] */ ULONG *pcAlternates); + + +void __RPC_STUB ISpRecoContext_GetMaxAlternates_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoContext_SetMaxAlternates_Proxy( + ISpRecoContext * This, + /* [in] */ ULONG cAlternates); + + +void __RPC_STUB ISpRecoContext_SetMaxAlternates_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoContext_SetAudioOptions_Proxy( + ISpRecoContext * This, + /* [in] */ SPAUDIOOPTIONS Options, + /* [in] */ const GUID *pAudioFormatId, + /* [in] */ const WAVEFORMATEX *pWaveFormatEx); + + +void __RPC_STUB ISpRecoContext_SetAudioOptions_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoContext_GetAudioOptions_Proxy( + ISpRecoContext * This, + /* [in] */ SPAUDIOOPTIONS *pOptions, + /* [out] */ GUID *pAudioFormatId, + /* [out] */ WAVEFORMATEX **ppCoMemWFEX); + + +void __RPC_STUB ISpRecoContext_GetAudioOptions_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoContext_DeserializeResult_Proxy( + ISpRecoContext * This, + /* [in] */ const SPSERIALIZEDRESULT *pSerializedResult, + /* [out] */ ISpRecoResult **ppResult); + + +void __RPC_STUB ISpRecoContext_DeserializeResult_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoContext_Bookmark_Proxy( + ISpRecoContext * This, + /* [in] */ SPBOOKMARKOPTIONS Options, + /* [in] */ ULONGLONG ullStreamPosition, + /* [in] */ LPARAM lparamEvent); + + +void __RPC_STUB ISpRecoContext_Bookmark_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoContext_SetAdaptationData_Proxy( + ISpRecoContext * This, + /* [string][in] */ const WCHAR *pAdaptationData, + /* [in] */ const ULONG cch); + + +void __RPC_STUB ISpRecoContext_SetAdaptationData_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoContext_Pause_Proxy( + ISpRecoContext * This, + DWORD dwReserved); + + +void __RPC_STUB ISpRecoContext_Pause_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoContext_Resume_Proxy( + ISpRecoContext * This, + DWORD dwReserved); + + +void __RPC_STUB ISpRecoContext_Resume_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoContext_SetVoice_Proxy( + ISpRecoContext * This, + /* [in] */ ISpVoice *pVoice, + /* [in] */ BOOL fAllowFormatChanges); + + +void __RPC_STUB ISpRecoContext_SetVoice_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoContext_GetVoice_Proxy( + ISpRecoContext * This, + /* [out] */ ISpVoice **ppVoice); + + +void __RPC_STUB ISpRecoContext_GetVoice_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoContext_SetVoicePurgeEvent_Proxy( + ISpRecoContext * This, + /* [in] */ ULONGLONG ullEventInterest); + + +void __RPC_STUB ISpRecoContext_SetVoicePurgeEvent_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoContext_GetVoicePurgeEvent_Proxy( + ISpRecoContext * This, + /* [out] */ ULONGLONG *pullEventInterest); + + +void __RPC_STUB ISpRecoContext_GetVoicePurgeEvent_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoContext_SetContextState_Proxy( + ISpRecoContext * This, + /* [in] */ SPCONTEXTSTATE eContextState); + + +void __RPC_STUB ISpRecoContext_SetContextState_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecoContext_GetContextState_Proxy( + ISpRecoContext * This, + /* [in] */ SPCONTEXTSTATE *peContextState); + + +void __RPC_STUB ISpRecoContext_GetContextState_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpRecoContext_INTERFACE_DEFINED__ */ + + +#ifndef __ISpProperties_INTERFACE_DEFINED__ +#define __ISpProperties_INTERFACE_DEFINED__ + +/* interface ISpProperties */ +/* [restricted][local][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpProperties; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("5B4FB971-B115-4DE1-AD97-E482E3BF6EE4") + ISpProperties : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetPropertyNum( + /* [in] */ const WCHAR *pName, + /* [in] */ LONG lValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPropertyNum( + /* [in] */ const WCHAR *pName, + /* [out] */ LONG *plValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetPropertyString( + /* [in] */ const WCHAR *pName, + /* [in] */ const WCHAR *pValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPropertyString( + /* [in] */ const WCHAR *pName, + /* [out] */ WCHAR **ppCoMemValue) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpPropertiesVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpProperties * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpProperties * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpProperties * This); + + HRESULT ( STDMETHODCALLTYPE *SetPropertyNum )( + ISpProperties * This, + /* [in] */ const WCHAR *pName, + /* [in] */ LONG lValue); + + HRESULT ( STDMETHODCALLTYPE *GetPropertyNum )( + ISpProperties * This, + /* [in] */ const WCHAR *pName, + /* [out] */ LONG *plValue); + + HRESULT ( STDMETHODCALLTYPE *SetPropertyString )( + ISpProperties * This, + /* [in] */ const WCHAR *pName, + /* [in] */ const WCHAR *pValue); + + HRESULT ( STDMETHODCALLTYPE *GetPropertyString )( + ISpProperties * This, + /* [in] */ const WCHAR *pName, + /* [out] */ WCHAR **ppCoMemValue); + + END_INTERFACE + } ISpPropertiesVtbl; + + interface ISpProperties + { + CONST_VTBL struct ISpPropertiesVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpProperties_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpProperties_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpProperties_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpProperties_SetPropertyNum(This,pName,lValue) \ + (This)->lpVtbl -> SetPropertyNum(This,pName,lValue) + +#define ISpProperties_GetPropertyNum(This,pName,plValue) \ + (This)->lpVtbl -> GetPropertyNum(This,pName,plValue) + +#define ISpProperties_SetPropertyString(This,pName,pValue) \ + (This)->lpVtbl -> SetPropertyString(This,pName,pValue) + +#define ISpProperties_GetPropertyString(This,pName,ppCoMemValue) \ + (This)->lpVtbl -> GetPropertyString(This,pName,ppCoMemValue) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpProperties_SetPropertyNum_Proxy( + ISpProperties * This, + /* [in] */ const WCHAR *pName, + /* [in] */ LONG lValue); + + +void __RPC_STUB ISpProperties_SetPropertyNum_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpProperties_GetPropertyNum_Proxy( + ISpProperties * This, + /* [in] */ const WCHAR *pName, + /* [out] */ LONG *plValue); + + +void __RPC_STUB ISpProperties_GetPropertyNum_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpProperties_SetPropertyString_Proxy( + ISpProperties * This, + /* [in] */ const WCHAR *pName, + /* [in] */ const WCHAR *pValue); + + +void __RPC_STUB ISpProperties_SetPropertyString_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpProperties_GetPropertyString_Proxy( + ISpProperties * This, + /* [in] */ const WCHAR *pName, + /* [out] */ WCHAR **ppCoMemValue); + + +void __RPC_STUB ISpProperties_GetPropertyString_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpProperties_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_sapi_0281 */ +/* [local] */ + +#define SP_MAX_LANGIDS ( 20 ) + +typedef /* [hidden][restricted] */ struct SPRECOGNIZERSTATUS + { + SPAUDIOSTATUS AudioStatus; + ULONGLONG ullRecognitionStreamPos; + ULONG ulStreamNumber; + ULONG ulNumActive; + CLSID clsidEngine; + ULONG cLangIDs; + WORD aLangID[ 20 ]; + DWORD dwReserved1; + DWORD dwReserved2; + } SPRECOGNIZERSTATUS; + +typedef /* [hidden] */ +enum SPWAVEFORMATTYPE + { SPWF_INPUT = 0, + SPWF_SRENGINE = SPWF_INPUT + 1 + } SPSTREAMFORMATTYPE; + +typedef /* [hidden] */ +enum SPRECOSTATE + { SPRST_INACTIVE = 0, + SPRST_ACTIVE = SPRST_INACTIVE + 1, + SPRST_ACTIVE_ALWAYS = SPRST_ACTIVE + 1, + SPRST_INACTIVE_WITH_PURGE = SPRST_ACTIVE_ALWAYS + 1, + SPRST_NUM_STATES = SPRST_INACTIVE_WITH_PURGE + 1 + } SPRECOSTATE; + + + +extern RPC_IF_HANDLE __MIDL_itf_sapi_0281_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_sapi_0281_v0_0_s_ifspec; + +#ifndef __ISpRecognizer_INTERFACE_DEFINED__ +#define __ISpRecognizer_INTERFACE_DEFINED__ + +/* interface ISpRecognizer */ +/* [restricted][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpRecognizer; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("C2B5F241-DAA0-4507-9E16-5A1EAA2B7A5C") + ISpRecognizer : public ISpProperties + { + public: + virtual HRESULT STDMETHODCALLTYPE SetRecognizer( + /* [in] */ ISpObjectToken *pRecognizer) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetRecognizer( + /* [out] */ ISpObjectToken **ppRecognizer) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetInput( + /* [in] */ IUnknown *pUnkInput, + /* [in] */ BOOL fAllowFormatChanges) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInputObjectToken( + /* [out] */ ISpObjectToken **ppToken) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInputStream( + /* [out] */ ISpStreamFormat **ppStream) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateRecoContext( + /* [out] */ ISpRecoContext **ppNewCtxt) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetRecoProfile( + /* [out] */ ISpObjectToken **ppToken) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetRecoProfile( + /* [in] */ ISpObjectToken *pToken) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsSharedInstance( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetRecoState( + /* [out] */ SPRECOSTATE *pState) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetRecoState( + /* [in] */ SPRECOSTATE NewState) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStatus( + /* [out] */ SPRECOGNIZERSTATUS *pStatus) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFormat( + /* [in] */ SPSTREAMFORMATTYPE WaveFormatType, + /* [out] */ GUID *pFormatId, + /* [out] */ WAVEFORMATEX **ppCoMemWFEX) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE IsUISupported( + /* [in] */ const WCHAR *pszTypeOfUI, + /* [in] */ void *pvExtraData, + /* [in] */ ULONG cbExtraData, + /* [out] */ BOOL *pfSupported) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE DisplayUI( + /* [in] */ HWND hwndParent, + /* [in] */ const WCHAR *pszTitle, + /* [in] */ const WCHAR *pszTypeOfUI, + /* [in] */ void *pvExtraData, + /* [in] */ ULONG cbExtraData) = 0; + + virtual HRESULT STDMETHODCALLTYPE EmulateRecognition( + /* [in] */ ISpPhrase *pPhrase) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpRecognizerVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpRecognizer * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpRecognizer * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpRecognizer * This); + + HRESULT ( STDMETHODCALLTYPE *SetPropertyNum )( + ISpRecognizer * This, + /* [in] */ const WCHAR *pName, + /* [in] */ LONG lValue); + + HRESULT ( STDMETHODCALLTYPE *GetPropertyNum )( + ISpRecognizer * This, + /* [in] */ const WCHAR *pName, + /* [out] */ LONG *plValue); + + HRESULT ( STDMETHODCALLTYPE *SetPropertyString )( + ISpRecognizer * This, + /* [in] */ const WCHAR *pName, + /* [in] */ const WCHAR *pValue); + + HRESULT ( STDMETHODCALLTYPE *GetPropertyString )( + ISpRecognizer * This, + /* [in] */ const WCHAR *pName, + /* [out] */ WCHAR **ppCoMemValue); + + HRESULT ( STDMETHODCALLTYPE *SetRecognizer )( + ISpRecognizer * This, + /* [in] */ ISpObjectToken *pRecognizer); + + HRESULT ( STDMETHODCALLTYPE *GetRecognizer )( + ISpRecognizer * This, + /* [out] */ ISpObjectToken **ppRecognizer); + + HRESULT ( STDMETHODCALLTYPE *SetInput )( + ISpRecognizer * This, + /* [in] */ IUnknown *pUnkInput, + /* [in] */ BOOL fAllowFormatChanges); + + HRESULT ( STDMETHODCALLTYPE *GetInputObjectToken )( + ISpRecognizer * This, + /* [out] */ ISpObjectToken **ppToken); + + HRESULT ( STDMETHODCALLTYPE *GetInputStream )( + ISpRecognizer * This, + /* [out] */ ISpStreamFormat **ppStream); + + HRESULT ( STDMETHODCALLTYPE *CreateRecoContext )( + ISpRecognizer * This, + /* [out] */ ISpRecoContext **ppNewCtxt); + + HRESULT ( STDMETHODCALLTYPE *GetRecoProfile )( + ISpRecognizer * This, + /* [out] */ ISpObjectToken **ppToken); + + HRESULT ( STDMETHODCALLTYPE *SetRecoProfile )( + ISpRecognizer * This, + /* [in] */ ISpObjectToken *pToken); + + HRESULT ( STDMETHODCALLTYPE *IsSharedInstance )( + ISpRecognizer * This); + + HRESULT ( STDMETHODCALLTYPE *GetRecoState )( + ISpRecognizer * This, + /* [out] */ SPRECOSTATE *pState); + + HRESULT ( STDMETHODCALLTYPE *SetRecoState )( + ISpRecognizer * This, + /* [in] */ SPRECOSTATE NewState); + + HRESULT ( STDMETHODCALLTYPE *GetStatus )( + ISpRecognizer * This, + /* [out] */ SPRECOGNIZERSTATUS *pStatus); + + HRESULT ( STDMETHODCALLTYPE *GetFormat )( + ISpRecognizer * This, + /* [in] */ SPSTREAMFORMATTYPE WaveFormatType, + /* [out] */ GUID *pFormatId, + /* [out] */ WAVEFORMATEX **ppCoMemWFEX); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *IsUISupported )( + ISpRecognizer * This, + /* [in] */ const WCHAR *pszTypeOfUI, + /* [in] */ void *pvExtraData, + /* [in] */ ULONG cbExtraData, + /* [out] */ BOOL *pfSupported); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *DisplayUI )( + ISpRecognizer * This, + /* [in] */ HWND hwndParent, + /* [in] */ const WCHAR *pszTitle, + /* [in] */ const WCHAR *pszTypeOfUI, + /* [in] */ void *pvExtraData, + /* [in] */ ULONG cbExtraData); + + HRESULT ( STDMETHODCALLTYPE *EmulateRecognition )( + ISpRecognizer * This, + /* [in] */ ISpPhrase *pPhrase); + + END_INTERFACE + } ISpRecognizerVtbl; + + interface ISpRecognizer + { + CONST_VTBL struct ISpRecognizerVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpRecognizer_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpRecognizer_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpRecognizer_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpRecognizer_SetPropertyNum(This,pName,lValue) \ + (This)->lpVtbl -> SetPropertyNum(This,pName,lValue) + +#define ISpRecognizer_GetPropertyNum(This,pName,plValue) \ + (This)->lpVtbl -> GetPropertyNum(This,pName,plValue) + +#define ISpRecognizer_SetPropertyString(This,pName,pValue) \ + (This)->lpVtbl -> SetPropertyString(This,pName,pValue) + +#define ISpRecognizer_GetPropertyString(This,pName,ppCoMemValue) \ + (This)->lpVtbl -> GetPropertyString(This,pName,ppCoMemValue) + + +#define ISpRecognizer_SetRecognizer(This,pRecognizer) \ + (This)->lpVtbl -> SetRecognizer(This,pRecognizer) + +#define ISpRecognizer_GetRecognizer(This,ppRecognizer) \ + (This)->lpVtbl -> GetRecognizer(This,ppRecognizer) + +#define ISpRecognizer_SetInput(This,pUnkInput,fAllowFormatChanges) \ + (This)->lpVtbl -> SetInput(This,pUnkInput,fAllowFormatChanges) + +#define ISpRecognizer_GetInputObjectToken(This,ppToken) \ + (This)->lpVtbl -> GetInputObjectToken(This,ppToken) + +#define ISpRecognizer_GetInputStream(This,ppStream) \ + (This)->lpVtbl -> GetInputStream(This,ppStream) + +#define ISpRecognizer_CreateRecoContext(This,ppNewCtxt) \ + (This)->lpVtbl -> CreateRecoContext(This,ppNewCtxt) + +#define ISpRecognizer_GetRecoProfile(This,ppToken) \ + (This)->lpVtbl -> GetRecoProfile(This,ppToken) + +#define ISpRecognizer_SetRecoProfile(This,pToken) \ + (This)->lpVtbl -> SetRecoProfile(This,pToken) + +#define ISpRecognizer_IsSharedInstance(This) \ + (This)->lpVtbl -> IsSharedInstance(This) + +#define ISpRecognizer_GetRecoState(This,pState) \ + (This)->lpVtbl -> GetRecoState(This,pState) + +#define ISpRecognizer_SetRecoState(This,NewState) \ + (This)->lpVtbl -> SetRecoState(This,NewState) + +#define ISpRecognizer_GetStatus(This,pStatus) \ + (This)->lpVtbl -> GetStatus(This,pStatus) + +#define ISpRecognizer_GetFormat(This,WaveFormatType,pFormatId,ppCoMemWFEX) \ + (This)->lpVtbl -> GetFormat(This,WaveFormatType,pFormatId,ppCoMemWFEX) + +#define ISpRecognizer_IsUISupported(This,pszTypeOfUI,pvExtraData,cbExtraData,pfSupported) \ + (This)->lpVtbl -> IsUISupported(This,pszTypeOfUI,pvExtraData,cbExtraData,pfSupported) + +#define ISpRecognizer_DisplayUI(This,hwndParent,pszTitle,pszTypeOfUI,pvExtraData,cbExtraData) \ + (This)->lpVtbl -> DisplayUI(This,hwndParent,pszTitle,pszTypeOfUI,pvExtraData,cbExtraData) + +#define ISpRecognizer_EmulateRecognition(This,pPhrase) \ + (This)->lpVtbl -> EmulateRecognition(This,pPhrase) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpRecognizer_SetRecognizer_Proxy( + ISpRecognizer * This, + /* [in] */ ISpObjectToken *pRecognizer); + + +void __RPC_STUB ISpRecognizer_SetRecognizer_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecognizer_GetRecognizer_Proxy( + ISpRecognizer * This, + /* [out] */ ISpObjectToken **ppRecognizer); + + +void __RPC_STUB ISpRecognizer_GetRecognizer_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecognizer_SetInput_Proxy( + ISpRecognizer * This, + /* [in] */ IUnknown *pUnkInput, + /* [in] */ BOOL fAllowFormatChanges); + + +void __RPC_STUB ISpRecognizer_SetInput_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecognizer_GetInputObjectToken_Proxy( + ISpRecognizer * This, + /* [out] */ ISpObjectToken **ppToken); + + +void __RPC_STUB ISpRecognizer_GetInputObjectToken_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecognizer_GetInputStream_Proxy( + ISpRecognizer * This, + /* [out] */ ISpStreamFormat **ppStream); + + +void __RPC_STUB ISpRecognizer_GetInputStream_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecognizer_CreateRecoContext_Proxy( + ISpRecognizer * This, + /* [out] */ ISpRecoContext **ppNewCtxt); + + +void __RPC_STUB ISpRecognizer_CreateRecoContext_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecognizer_GetRecoProfile_Proxy( + ISpRecognizer * This, + /* [out] */ ISpObjectToken **ppToken); + + +void __RPC_STUB ISpRecognizer_GetRecoProfile_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecognizer_SetRecoProfile_Proxy( + ISpRecognizer * This, + /* [in] */ ISpObjectToken *pToken); + + +void __RPC_STUB ISpRecognizer_SetRecoProfile_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecognizer_IsSharedInstance_Proxy( + ISpRecognizer * This); + + +void __RPC_STUB ISpRecognizer_IsSharedInstance_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecognizer_GetRecoState_Proxy( + ISpRecognizer * This, + /* [out] */ SPRECOSTATE *pState); + + +void __RPC_STUB ISpRecognizer_GetRecoState_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecognizer_SetRecoState_Proxy( + ISpRecognizer * This, + /* [in] */ SPRECOSTATE NewState); + + +void __RPC_STUB ISpRecognizer_SetRecoState_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecognizer_GetStatus_Proxy( + ISpRecognizer * This, + /* [out] */ SPRECOGNIZERSTATUS *pStatus); + + +void __RPC_STUB ISpRecognizer_GetStatus_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecognizer_GetFormat_Proxy( + ISpRecognizer * This, + /* [in] */ SPSTREAMFORMATTYPE WaveFormatType, + /* [out] */ GUID *pFormatId, + /* [out] */ WAVEFORMATEX **ppCoMemWFEX); + + +void __RPC_STUB ISpRecognizer_GetFormat_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [local] */ HRESULT STDMETHODCALLTYPE ISpRecognizer_IsUISupported_Proxy( + ISpRecognizer * This, + /* [in] */ const WCHAR *pszTypeOfUI, + /* [in] */ void *pvExtraData, + /* [in] */ ULONG cbExtraData, + /* [out] */ BOOL *pfSupported); + + +void __RPC_STUB ISpRecognizer_IsUISupported_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [local] */ HRESULT STDMETHODCALLTYPE ISpRecognizer_DisplayUI_Proxy( + ISpRecognizer * This, + /* [in] */ HWND hwndParent, + /* [in] */ const WCHAR *pszTitle, + /* [in] */ const WCHAR *pszTypeOfUI, + /* [in] */ void *pvExtraData, + /* [in] */ ULONG cbExtraData); + + +void __RPC_STUB ISpRecognizer_DisplayUI_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpRecognizer_EmulateRecognition_Proxy( + ISpRecognizer * This, + /* [in] */ ISpPhrase *pPhrase); + + +void __RPC_STUB ISpRecognizer_EmulateRecognition_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpRecognizer_INTERFACE_DEFINED__ */ + + + +#ifndef __SpeechLib_LIBRARY_DEFINED__ +#define __SpeechLib_LIBRARY_DEFINED__ + +/* library SpeechLib */ +/* [version][uuid][helpstring] */ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +typedef long SpeechLanguageId; + +#define __SpeechStringConstants_MODULE_DEFINED__ +typedef /* [hidden] */ +enum DISPID_SpeechDataKey + { DISPID_SDKSetBinaryValue = 1, + DISPID_SDKGetBinaryValue = DISPID_SDKSetBinaryValue + 1, + DISPID_SDKSetStringValue = DISPID_SDKGetBinaryValue + 1, + DISPID_SDKGetStringValue = DISPID_SDKSetStringValue + 1, + DISPID_SDKSetLongValue = DISPID_SDKGetStringValue + 1, + DISPID_SDKGetlongValue = DISPID_SDKSetLongValue + 1, + DISPID_SDKOpenKey = DISPID_SDKGetlongValue + 1, + DISPID_SDKCreateKey = DISPID_SDKOpenKey + 1, + DISPID_SDKDeleteKey = DISPID_SDKCreateKey + 1, + DISPID_SDKDeleteValue = DISPID_SDKDeleteKey + 1, + DISPID_SDKEnumKeys = DISPID_SDKDeleteValue + 1, + DISPID_SDKEnumValues = DISPID_SDKEnumKeys + 1 + } DISPID_SpeechDataKey; + +typedef /* [hidden] */ +enum DISPID_SpeechObjectToken + { DISPID_SOTId = 1, + DISPID_SOTDataKey = DISPID_SOTId + 1, + DISPID_SOTCategory = DISPID_SOTDataKey + 1, + DISPID_SOTGetDescription = DISPID_SOTCategory + 1, + DISPID_SOTSetId = DISPID_SOTGetDescription + 1, + DISPID_SOTGetAttribute = DISPID_SOTSetId + 1, + DISPID_SOTCreateInstance = DISPID_SOTGetAttribute + 1, + DISPID_SOTRemove = DISPID_SOTCreateInstance + 1, + DISPID_SOTGetStorageFileName = DISPID_SOTRemove + 1, + DISPID_SOTRemoveStorageFileName = DISPID_SOTGetStorageFileName + 1, + DISPID_SOTIsUISupported = DISPID_SOTRemoveStorageFileName + 1, + DISPID_SOTDisplayUI = DISPID_SOTIsUISupported + 1, + DISPID_SOTMatchesAttributes = DISPID_SOTDisplayUI + 1 + } DISPID_SpeechObjectToken; + +typedef +enum SpeechDataKeyLocation + { SDKLDefaultLocation = SPDKL_DefaultLocation, + SDKLCurrentUser = SPDKL_CurrentUser, + SDKLLocalMachine = SPDKL_LocalMachine, + SDKLCurrentConfig = SPDKL_CurrentConfig + } SpeechDataKeyLocation; + +typedef +enum SpeechTokenContext + { STCInprocServer = CLSCTX_INPROC_SERVER, + STCInprocHandler = CLSCTX_INPROC_HANDLER, + STCLocalServer = CLSCTX_LOCAL_SERVER, + STCRemoteServer = CLSCTX_REMOTE_SERVER, + STCAll = CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER | CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER + } SpeechTokenContext; + +typedef +enum SpeechTokenShellFolder + { STSF_AppData = 0x1a, + STSF_LocalAppData = 0x1c, + STSF_CommonAppData = 0x23, + STSF_FlagCreate = 0x8000 + } SpeechTokenShellFolder; + +typedef /* [hidden] */ +enum DISPID_SpeechObjectTokens + { DISPID_SOTsCount = 1, + DISPID_SOTsItem = DISPID_VALUE, + DISPID_SOTs_NewEnum = DISPID_NEWENUM + } DISPID_SpeechObjectTokens; + +typedef /* [hidden] */ +enum DISPID_SpeechObjectTokenCategory + { DISPID_SOTCId = 1, + DISPID_SOTCDefault = DISPID_SOTCId + 1, + DISPID_SOTCSetId = DISPID_SOTCDefault + 1, + DISPID_SOTCGetDataKey = DISPID_SOTCSetId + 1, + DISPID_SOTCEnumerateTokens = DISPID_SOTCGetDataKey + 1 + } DISPID_SpeechObjectTokenCategory; + +typedef +enum SpeechAudioFormatType + { SAFTDefault = -1, + SAFTNoAssignedFormat = 0, + SAFTText = SAFTNoAssignedFormat + 1, + SAFTNonStandardFormat = SAFTText + 1, + SAFTExtendedAudioFormat = SAFTNonStandardFormat + 1, + SAFT8kHz8BitMono = SAFTExtendedAudioFormat + 1, + SAFT8kHz8BitStereo = SAFT8kHz8BitMono + 1, + SAFT8kHz16BitMono = SAFT8kHz8BitStereo + 1, + SAFT8kHz16BitStereo = SAFT8kHz16BitMono + 1, + SAFT11kHz8BitMono = SAFT8kHz16BitStereo + 1, + SAFT11kHz8BitStereo = SAFT11kHz8BitMono + 1, + SAFT11kHz16BitMono = SAFT11kHz8BitStereo + 1, + SAFT11kHz16BitStereo = SAFT11kHz16BitMono + 1, + SAFT12kHz8BitMono = SAFT11kHz16BitStereo + 1, + SAFT12kHz8BitStereo = SAFT12kHz8BitMono + 1, + SAFT12kHz16BitMono = SAFT12kHz8BitStereo + 1, + SAFT12kHz16BitStereo = SAFT12kHz16BitMono + 1, + SAFT16kHz8BitMono = SAFT12kHz16BitStereo + 1, + SAFT16kHz8BitStereo = SAFT16kHz8BitMono + 1, + SAFT16kHz16BitMono = SAFT16kHz8BitStereo + 1, + SAFT16kHz16BitStereo = SAFT16kHz16BitMono + 1, + SAFT22kHz8BitMono = SAFT16kHz16BitStereo + 1, + SAFT22kHz8BitStereo = SAFT22kHz8BitMono + 1, + SAFT22kHz16BitMono = SAFT22kHz8BitStereo + 1, + SAFT22kHz16BitStereo = SAFT22kHz16BitMono + 1, + SAFT24kHz8BitMono = SAFT22kHz16BitStereo + 1, + SAFT24kHz8BitStereo = SAFT24kHz8BitMono + 1, + SAFT24kHz16BitMono = SAFT24kHz8BitStereo + 1, + SAFT24kHz16BitStereo = SAFT24kHz16BitMono + 1, + SAFT32kHz8BitMono = SAFT24kHz16BitStereo + 1, + SAFT32kHz8BitStereo = SAFT32kHz8BitMono + 1, + SAFT32kHz16BitMono = SAFT32kHz8BitStereo + 1, + SAFT32kHz16BitStereo = SAFT32kHz16BitMono + 1, + SAFT44kHz8BitMono = SAFT32kHz16BitStereo + 1, + SAFT44kHz8BitStereo = SAFT44kHz8BitMono + 1, + SAFT44kHz16BitMono = SAFT44kHz8BitStereo + 1, + SAFT44kHz16BitStereo = SAFT44kHz16BitMono + 1, + SAFT48kHz8BitMono = SAFT44kHz16BitStereo + 1, + SAFT48kHz8BitStereo = SAFT48kHz8BitMono + 1, + SAFT48kHz16BitMono = SAFT48kHz8BitStereo + 1, + SAFT48kHz16BitStereo = SAFT48kHz16BitMono + 1, + SAFTTrueSpeech_8kHz1BitMono = SAFT48kHz16BitStereo + 1, + SAFTCCITT_ALaw_8kHzMono = SAFTTrueSpeech_8kHz1BitMono + 1, + SAFTCCITT_ALaw_8kHzStereo = SAFTCCITT_ALaw_8kHzMono + 1, + SAFTCCITT_ALaw_11kHzMono = SAFTCCITT_ALaw_8kHzStereo + 1, + SAFTCCITT_ALaw_11kHzStereo = SAFTCCITT_ALaw_11kHzMono + 1, + SAFTCCITT_ALaw_22kHzMono = SAFTCCITT_ALaw_11kHzStereo + 1, + SAFTCCITT_ALaw_22kHzStereo = SAFTCCITT_ALaw_22kHzMono + 1, + SAFTCCITT_ALaw_44kHzMono = SAFTCCITT_ALaw_22kHzStereo + 1, + SAFTCCITT_ALaw_44kHzStereo = SAFTCCITT_ALaw_44kHzMono + 1, + SAFTCCITT_uLaw_8kHzMono = SAFTCCITT_ALaw_44kHzStereo + 1, + SAFTCCITT_uLaw_8kHzStereo = SAFTCCITT_uLaw_8kHzMono + 1, + SAFTCCITT_uLaw_11kHzMono = SAFTCCITT_uLaw_8kHzStereo + 1, + SAFTCCITT_uLaw_11kHzStereo = SAFTCCITT_uLaw_11kHzMono + 1, + SAFTCCITT_uLaw_22kHzMono = SAFTCCITT_uLaw_11kHzStereo + 1, + SAFTCCITT_uLaw_22kHzStereo = SAFTCCITT_uLaw_22kHzMono + 1, + SAFTCCITT_uLaw_44kHzMono = SAFTCCITT_uLaw_22kHzStereo + 1, + SAFTCCITT_uLaw_44kHzStereo = SAFTCCITT_uLaw_44kHzMono + 1, + SAFTADPCM_8kHzMono = SAFTCCITT_uLaw_44kHzStereo + 1, + SAFTADPCM_8kHzStereo = SAFTADPCM_8kHzMono + 1, + SAFTADPCM_11kHzMono = SAFTADPCM_8kHzStereo + 1, + SAFTADPCM_11kHzStereo = SAFTADPCM_11kHzMono + 1, + SAFTADPCM_22kHzMono = SAFTADPCM_11kHzStereo + 1, + SAFTADPCM_22kHzStereo = SAFTADPCM_22kHzMono + 1, + SAFTADPCM_44kHzMono = SAFTADPCM_22kHzStereo + 1, + SAFTADPCM_44kHzStereo = SAFTADPCM_44kHzMono + 1, + SAFTGSM610_8kHzMono = SAFTADPCM_44kHzStereo + 1, + SAFTGSM610_11kHzMono = SAFTGSM610_8kHzMono + 1, + SAFTGSM610_22kHzMono = SAFTGSM610_11kHzMono + 1, + SAFTGSM610_44kHzMono = SAFTGSM610_22kHzMono + 1 + } SpeechAudioFormatType; + +typedef /* [hidden] */ +enum DISPID_SpeechAudioFormat + { DISPID_SAFType = 1, + DISPID_SAFGuid = DISPID_SAFType + 1, + DISPID_SAFGetWaveFormatEx = DISPID_SAFGuid + 1, + DISPID_SAFSetWaveFormatEx = DISPID_SAFGetWaveFormatEx + 1 + } DISPID_SpeechAudioFormat; + +typedef /* [hidden] */ +enum DISPID_SpeechBaseStream + { DISPID_SBSFormat = 1, + DISPID_SBSRead = DISPID_SBSFormat + 1, + DISPID_SBSWrite = DISPID_SBSRead + 1, + DISPID_SBSSeek = DISPID_SBSWrite + 1 + } DISPID_SpeechBaseStream; + +typedef +enum SpeechStreamSeekPositionType + { SSSPTRelativeToStart = STREAM_SEEK_SET, + SSSPTRelativeToCurrentPosition = STREAM_SEEK_CUR, + SSSPTRelativeToEnd = STREAM_SEEK_END + } SpeechStreamSeekPositionType; + +typedef /* [hidden] */ +enum DISPID_SpeechAudio + { DISPID_SAStatus = 200, + DISPID_SABufferInfo = DISPID_SAStatus + 1, + DISPID_SADefaultFormat = DISPID_SABufferInfo + 1, + DISPID_SAVolume = DISPID_SADefaultFormat + 1, + DISPID_SABufferNotifySize = DISPID_SAVolume + 1, + DISPID_SAEventHandle = DISPID_SABufferNotifySize + 1, + DISPID_SASetState = DISPID_SAEventHandle + 1 + } DISPID_SpeechAudio; + +typedef +enum SpeechAudioState + { SASClosed = SPAS_CLOSED, + SASStop = SPAS_STOP, + SASPause = SPAS_PAUSE, + SASRun = SPAS_RUN + } SpeechAudioState; + +typedef /* [hidden] */ +enum DISPID_SpeechMMSysAudio + { DISPID_SMSADeviceId = 300, + DISPID_SMSALineId = DISPID_SMSADeviceId + 1, + DISPID_SMSAMMHandle = DISPID_SMSALineId + 1 + } DISPID_SpeechMMSysAudio; + +typedef /* [hidden] */ +enum DISPID_SpeechFileStream + { DISPID_SFSOpen = 100, + DISPID_SFSClose = DISPID_SFSOpen + 1 + } DISPID_SpeechFileStream; + +typedef +enum SpeechStreamFileMode + { SSFMOpenForRead = SPFM_OPEN_READONLY, + SSFMOpenReadWrite = SPFM_OPEN_READWRITE, + SSFMCreate = SPFM_CREATE, + SSFMCreateForWrite = SPFM_CREATE_ALWAYS + } SpeechStreamFileMode; + +typedef /* [hidden] */ +enum DISPID_SpeechCustomStream + { DISPID_SCSBaseStream = 100 + } DISPID_SpeechCustomStream; + +typedef /* [hidden] */ +enum DISPID_SpeechMemoryStream + { DISPID_SMSSetData = 100, + DISPID_SMSGetData = DISPID_SMSSetData + 1 + } DISPID_SpeechMemoryStream; + +typedef /* [hidden] */ +enum DISPID_SpeechAudioStatus + { DISPID_SASFreeBufferSpace = 1, + DISPID_SASNonBlockingIO = DISPID_SASFreeBufferSpace + 1, + DISPID_SASState = DISPID_SASNonBlockingIO + 1, + DISPID_SASCurrentSeekPosition = DISPID_SASState + 1, + DISPID_SASCurrentDevicePosition = DISPID_SASCurrentSeekPosition + 1 + } DISPID_SpeechAudioStatus; + +typedef /* [hidden] */ +enum DISPID_SpeechAudioBufferInfo + { DISPID_SABIMinNotification = 1, + DISPID_SABIBufferSize = DISPID_SABIMinNotification + 1, + DISPID_SABIEventBias = DISPID_SABIBufferSize + 1 + } DISPID_SpeechAudioBufferInfo; + +typedef /* [hidden] */ +enum DISPID_SpeechWaveFormatEx + { DISPID_SWFEFormatTag = 1, + DISPID_SWFEChannels = DISPID_SWFEFormatTag + 1, + DISPID_SWFESamplesPerSec = DISPID_SWFEChannels + 1, + DISPID_SWFEAvgBytesPerSec = DISPID_SWFESamplesPerSec + 1, + DISPID_SWFEBlockAlign = DISPID_SWFEAvgBytesPerSec + 1, + DISPID_SWFEBitsPerSample = DISPID_SWFEBlockAlign + 1, + DISPID_SWFEExtraData = DISPID_SWFEBitsPerSample + 1 + } DISPID_SpeechWaveFormatEx; + +typedef /* [hidden] */ +enum DISPID_SpeechVoice + { DISPID_SVStatus = 1, + DISPID_SVVoice = DISPID_SVStatus + 1, + DISPID_SVAudioOutput = DISPID_SVVoice + 1, + DISPID_SVAudioOutputStream = DISPID_SVAudioOutput + 1, + DISPID_SVRate = DISPID_SVAudioOutputStream + 1, + DISPID_SVVolume = DISPID_SVRate + 1, + DISPID_SVAllowAudioOuputFormatChangesOnNextSet = DISPID_SVVolume + 1, + DISPID_SVEventInterests = DISPID_SVAllowAudioOuputFormatChangesOnNextSet + 1, + DISPID_SVPriority = DISPID_SVEventInterests + 1, + DISPID_SVAlertBoundary = DISPID_SVPriority + 1, + DISPID_SVSyncronousSpeakTimeout = DISPID_SVAlertBoundary + 1, + DISPID_SVSpeak = DISPID_SVSyncronousSpeakTimeout + 1, + DISPID_SVSpeakStream = DISPID_SVSpeak + 1, + DISPID_SVPause = DISPID_SVSpeakStream + 1, + DISPID_SVResume = DISPID_SVPause + 1, + DISPID_SVSkip = DISPID_SVResume + 1, + DISPID_SVGetVoices = DISPID_SVSkip + 1, + DISPID_SVGetAudioOutputs = DISPID_SVGetVoices + 1, + DISPID_SVWaitUntilDone = DISPID_SVGetAudioOutputs + 1, + DISPID_SVSpeakCompleteEvent = DISPID_SVWaitUntilDone + 1, + DISPID_SVIsUISupported = DISPID_SVSpeakCompleteEvent + 1, + DISPID_SVDisplayUI = DISPID_SVIsUISupported + 1 + } DISPID_SpeechVoice; + +typedef +enum SpeechVoicePriority + { SVPNormal = SPVPRI_NORMAL, + SVPAlert = SPVPRI_ALERT, + SVPOver = SPVPRI_OVER + } SpeechVoicePriority; + +typedef +enum SpeechVoiceSpeakFlags + { SVSFDefault = SPF_DEFAULT, + SVSFlagsAsync = SPF_ASYNC, + SVSFPurgeBeforeSpeak = SPF_PURGEBEFORESPEAK, + SVSFIsFilename = SPF_IS_FILENAME, + SVSFIsXML = SPF_IS_XML, + SVSFIsNotXML = SPF_IS_NOT_XML, + SVSFPersistXML = SPF_PERSIST_XML, + SVSFNLPSpeakPunc = SPF_NLP_SPEAK_PUNC, + SVSFNLPMask = SPF_NLP_MASK, + SVSFVoiceMask = SPF_VOICE_MASK, + SVSFUnusedFlags = SPF_UNUSED_FLAGS + } SpeechVoiceSpeakFlags; + +typedef +enum SpeechVoiceEvents + { SVEStartInputStream = 1L << 1, + SVEEndInputStream = 1L << 2, + SVEVoiceChange = 1L << 3, + SVEBookmark = 1L << 4, + SVEWordBoundary = 1L << 5, + SVEPhoneme = 1L << 6, + SVESentenceBoundary = 1L << 7, + SVEViseme = 1L << 8, + SVEAudioLevel = 1L << 9, + SVEPrivate = 1L << 15, + SVEAllEvents = 0x83fe + } SpeechVoiceEvents; + +typedef /* [hidden] */ +enum DISPID_SpeechVoiceStatus + { DISPID_SVSCurrentStreamNumber = 1, + DISPID_SVSLastStreamNumberQueued = DISPID_SVSCurrentStreamNumber + 1, + DISPID_SVSLastResult = DISPID_SVSLastStreamNumberQueued + 1, + DISPID_SVSRunningState = DISPID_SVSLastResult + 1, + DISPID_SVSInputWordPosition = DISPID_SVSRunningState + 1, + DISPID_SVSInputWordLength = DISPID_SVSInputWordPosition + 1, + DISPID_SVSInputSentencePosition = DISPID_SVSInputWordLength + 1, + DISPID_SVSInputSentenceLength = DISPID_SVSInputSentencePosition + 1, + DISPID_SVSLastBookmark = DISPID_SVSInputSentenceLength + 1, + DISPID_SVSLastBookmarkId = DISPID_SVSLastBookmark + 1, + DISPID_SVSPhonemeId = DISPID_SVSLastBookmarkId + 1, + DISPID_SVSVisemeId = DISPID_SVSPhonemeId + 1 + } DISPID_SpeechVoiceStatus; + +typedef +enum SpeechRunState + { SRSEDone = SPRS_DONE, + SRSEIsSpeaking = SPRS_IS_SPEAKING + } SpeechRunState; + +typedef +enum SpeechVisemeType + { SVP_0 = 0, + SVP_1 = SVP_0 + 1, + SVP_2 = SVP_1 + 1, + SVP_3 = SVP_2 + 1, + SVP_4 = SVP_3 + 1, + SVP_5 = SVP_4 + 1, + SVP_6 = SVP_5 + 1, + SVP_7 = SVP_6 + 1, + SVP_8 = SVP_7 + 1, + SVP_9 = SVP_8 + 1, + SVP_10 = SVP_9 + 1, + SVP_11 = SVP_10 + 1, + SVP_12 = SVP_11 + 1, + SVP_13 = SVP_12 + 1, + SVP_14 = SVP_13 + 1, + SVP_15 = SVP_14 + 1, + SVP_16 = SVP_15 + 1, + SVP_17 = SVP_16 + 1, + SVP_18 = SVP_17 + 1, + SVP_19 = SVP_18 + 1, + SVP_20 = SVP_19 + 1, + SVP_21 = SVP_20 + 1 + } SpeechVisemeType; + +typedef +enum SpeechVisemeFeature + { SVF_None = 0, + SVF_Stressed = SPVFEATURE_STRESSED, + SVF_Emphasis = SPVFEATURE_EMPHASIS + } SpeechVisemeFeature; + +typedef /* [hidden] */ +enum DISPID_SpeechVoiceEvent + { DISPID_SVEStreamStart = 1, + DISPID_SVEStreamEnd = DISPID_SVEStreamStart + 1, + DISPID_SVEVoiceChange = DISPID_SVEStreamEnd + 1, + DISPID_SVEBookmark = DISPID_SVEVoiceChange + 1, + DISPID_SVEWord = DISPID_SVEBookmark + 1, + DISPID_SVEPhoneme = DISPID_SVEWord + 1, + DISPID_SVESentenceBoundary = DISPID_SVEPhoneme + 1, + DISPID_SVEViseme = DISPID_SVESentenceBoundary + 1, + DISPID_SVEAudioLevel = DISPID_SVEViseme + 1, + DISPID_SVEEnginePrivate = DISPID_SVEAudioLevel + 1 + } DISPID_SpeechVoiceEvent; + +typedef /* [hidden] */ +enum DISPID_SpeechRecognizer + { DISPID_SRRecognizer = 1, + DISPID_SRAllowAudioInputFormatChangesOnNextSet = DISPID_SRRecognizer + 1, + DISPID_SRAudioInput = DISPID_SRAllowAudioInputFormatChangesOnNextSet + 1, + DISPID_SRAudioInputStream = DISPID_SRAudioInput + 1, + DISPID_SRIsShared = DISPID_SRAudioInputStream + 1, + DISPID_SRState = DISPID_SRIsShared + 1, + DISPID_SRStatus = DISPID_SRState + 1, + DISPID_SRProfile = DISPID_SRStatus + 1, + DISPID_SREmulateRecognition = DISPID_SRProfile + 1, + DISPID_SRCreateRecoContext = DISPID_SREmulateRecognition + 1, + DISPID_SRGetFormat = DISPID_SRCreateRecoContext + 1, + DISPID_SRSetPropertyNumber = DISPID_SRGetFormat + 1, + DISPID_SRGetPropertyNumber = DISPID_SRSetPropertyNumber + 1, + DISPID_SRSetPropertyString = DISPID_SRGetPropertyNumber + 1, + DISPID_SRGetPropertyString = DISPID_SRSetPropertyString + 1, + DISPID_SRIsUISupported = DISPID_SRGetPropertyString + 1, + DISPID_SRDisplayUI = DISPID_SRIsUISupported + 1, + DISPID_SRGetRecognizers = DISPID_SRDisplayUI + 1, + DISPID_SVGetAudioInputs = DISPID_SRGetRecognizers + 1, + DISPID_SVGetProfiles = DISPID_SVGetAudioInputs + 1 + } DISPID_SpeechRecognizer; + +typedef +enum SpeechRecognizerState + { SRSInactive = SPRST_INACTIVE, + SRSActive = SPRST_ACTIVE, + SRSActiveAlways = SPRST_ACTIVE_ALWAYS, + SRSInactiveWithPurge = SPRST_INACTIVE_WITH_PURGE + } SpeechRecognizerState; + +typedef +enum SpeechDisplayAttributes + { SDA_No_Trailing_Space = 0, + SDA_One_Trailing_Space = SPAF_ONE_TRAILING_SPACE, + SDA_Two_Trailing_Spaces = SPAF_TWO_TRAILING_SPACES, + SDA_Consume_Leading_Spaces = SPAF_CONSUME_LEADING_SPACES + } SpeechDisplayAttributes; + +typedef +enum SpeechFormatType + { SFTInput = SPWF_INPUT, + SFTSREngine = SPWF_SRENGINE + } SpeechFormatType; + +typedef /* [hidden] */ +enum DISPID_SpeechRecognizerStatus + { DISPID_SRSAudioStatus = 1, + DISPID_SRSCurrentStreamPosition = DISPID_SRSAudioStatus + 1, + DISPID_SRSCurrentStreamNumber = DISPID_SRSCurrentStreamPosition + 1, + DISPID_SRSNumberOfActiveRules = DISPID_SRSCurrentStreamNumber + 1, + DISPID_SRSClsidEngine = DISPID_SRSNumberOfActiveRules + 1, + DISPID_SRSSupportedLanguages = DISPID_SRSClsidEngine + 1 + } DISPID_SpeechRecognizerStatus; + +typedef /* [hidden] */ +enum DISPID_SpeechRecoContext + { DISPID_SRCRecognizer = 1, + DISPID_SRCAudioInInterferenceStatus = DISPID_SRCRecognizer + 1, + DISPID_SRCRequestedUIType = DISPID_SRCAudioInInterferenceStatus + 1, + DISPID_SRCVoice = DISPID_SRCRequestedUIType + 1, + DISPID_SRAllowVoiceFormatMatchingOnNextSet = DISPID_SRCVoice + 1, + DISPID_SRCVoicePurgeEvent = DISPID_SRAllowVoiceFormatMatchingOnNextSet + 1, + DISPID_SRCEventInterests = DISPID_SRCVoicePurgeEvent + 1, + DISPID_SRCCmdMaxAlternates = DISPID_SRCEventInterests + 1, + DISPID_SRCState = DISPID_SRCCmdMaxAlternates + 1, + DISPID_SRCRetainedAudio = DISPID_SRCState + 1, + DISPID_SRCRetainedAudioFormat = DISPID_SRCRetainedAudio + 1, + DISPID_SRCPause = DISPID_SRCRetainedAudioFormat + 1, + DISPID_SRCResume = DISPID_SRCPause + 1, + DISPID_SRCCreateGrammar = DISPID_SRCResume + 1, + DISPID_SRCCreateResultFromMemory = DISPID_SRCCreateGrammar + 1, + DISPID_SRCBookmark = DISPID_SRCCreateResultFromMemory + 1, + DISPID_SRCSetAdaptationData = DISPID_SRCBookmark + 1 + } DISPID_SpeechRecoContext; + +typedef +enum SpeechRetainedAudioOptions + { SRAONone = SPAO_NONE, + SRAORetainAudio = SPAO_RETAIN_AUDIO + } SpeechRetainedAudioOptions; + +typedef +enum SpeechBookmarkOptions + { SBONone = SPBO_NONE, + SBOPause = SPBO_PAUSE + } SpeechBookmarkOptions; + +typedef +enum SpeechInterference + { SINone = SPINTERFERENCE_NONE, + SINoise = SPINTERFERENCE_NOISE, + SINoSignal = SPINTERFERENCE_NOSIGNAL, + SITooLoud = SPINTERFERENCE_TOOLOUD, + SITooQuiet = SPINTERFERENCE_TOOQUIET, + SITooFast = SPINTERFERENCE_TOOFAST, + SITooSlow = SPINTERFERENCE_TOOSLOW + } SpeechInterference; + +typedef +enum SpeechRecoEvents + { SREStreamEnd = 1L << 0, + SRESoundStart = 1L << 1, + SRESoundEnd = 1L << 2, + SREPhraseStart = 1L << 3, + SRERecognition = 1L << 4, + SREHypothesis = 1L << 5, + SREBookmark = 1L << 6, + SREPropertyNumChange = 1L << 7, + SREPropertyStringChange = 1L << 8, + SREFalseRecognition = 1L << 9, + SREInterference = 1L << 10, + SRERequestUI = 1L << 11, + SREStateChange = 1L << 12, + SREAdaptation = 1L << 13, + SREStreamStart = 1L << 14, + SRERecoOtherContext = 1L << 15, + SREAudioLevel = 1L << 16, + SREPrivate = 1L << 18, + SREAllEvents = 0x5ffff + } SpeechRecoEvents; + +typedef +enum SpeechRecoContextState + { SRCS_Disabled = SPCS_DISABLED, + SRCS_Enabled = SPCS_ENABLED + } SpeechRecoContextState; + +typedef /* [hidden] */ +enum DISPIDSPRG + { DISPID_SRGId = 1, + DISPID_SRGRecoContext = DISPID_SRGId + 1, + DISPID_SRGState = DISPID_SRGRecoContext + 1, + DISPID_SRGRules = DISPID_SRGState + 1, + DISPID_SRGReset = DISPID_SRGRules + 1, + DISPID_SRGCommit = DISPID_SRGReset + 1, + DISPID_SRGCmdLoadFromFile = DISPID_SRGCommit + 1, + DISPID_SRGCmdLoadFromObject = DISPID_SRGCmdLoadFromFile + 1, + DISPID_SRGCmdLoadFromResource = DISPID_SRGCmdLoadFromObject + 1, + DISPID_SRGCmdLoadFromMemory = DISPID_SRGCmdLoadFromResource + 1, + DISPID_SRGCmdLoadFromProprietaryGrammar = DISPID_SRGCmdLoadFromMemory + 1, + DISPID_SRGCmdSetRuleState = DISPID_SRGCmdLoadFromProprietaryGrammar + 1, + DISPID_SRGCmdSetRuleIdState = DISPID_SRGCmdSetRuleState + 1, + DISPID_SRGDictationLoad = DISPID_SRGCmdSetRuleIdState + 1, + DISPID_SRGDictationUnload = DISPID_SRGDictationLoad + 1, + DISPID_SRGDictationSetState = DISPID_SRGDictationUnload + 1, + DISPID_SRGSetWordSequenceData = DISPID_SRGDictationSetState + 1, + DISPID_SRGSetTextSelection = DISPID_SRGSetWordSequenceData + 1, + DISPID_SRGIsPronounceable = DISPID_SRGSetTextSelection + 1 + } DISPIDSPRG; + +typedef +enum SpeechLoadOption + { SLOStatic = SPLO_STATIC, + SLODynamic = SPLO_DYNAMIC + } SpeechLoadOption; + +typedef +enum SpeechWordPronounceable + { SWPUnknownWordUnpronounceable = SPWP_UNKNOWN_WORD_UNPRONOUNCEABLE, + SWPUnknownWordPronounceable = SPWP_UNKNOWN_WORD_PRONOUNCEABLE, + SWPKnownWordPronounceable = SPWP_KNOWN_WORD_PRONOUNCEABLE + } SpeechWordPronounceable; + +typedef +enum SpeechGrammarState + { SGSEnabled = SPGS_ENABLED, + SGSDisabled = SPGS_DISABLED, + SGSExclusive = SPGS_EXCLUSIVE + } SpeechGrammarState; + +typedef +enum SpeechRuleState + { SGDSInactive = SPRS_INACTIVE, + SGDSActive = SPRS_ACTIVE, + SGDSActiveWithAutoPause = SPRS_ACTIVE_WITH_AUTO_PAUSE + } SpeechRuleState; + +typedef +enum SpeechRuleAttributes + { SRATopLevel = SPRAF_TopLevel, + SRADefaultToActive = SPRAF_Active, + SRAExport = SPRAF_Export, + SRAImport = SPRAF_Import, + SRAInterpreter = SPRAF_Interpreter, + SRADynamic = SPRAF_Dynamic + } SpeechRuleAttributes; + +typedef +enum SpeechGrammarWordType + { SGDisplay = SPWT_DISPLAY, + SGLexical = SPWT_LEXICAL, + SGPronounciation = SPWT_PRONUNCIATION + } SpeechGrammarWordType; + +typedef /* [hidden] */ +enum DISPID_SpeechRecoContextEvents + { DISPID_SRCEStartStream = 1, + DISPID_SRCEEndStream = DISPID_SRCEStartStream + 1, + DISPID_SRCEBookmark = DISPID_SRCEEndStream + 1, + DISPID_SRCESoundStart = DISPID_SRCEBookmark + 1, + DISPID_SRCESoundEnd = DISPID_SRCESoundStart + 1, + DISPID_SRCEPhraseStart = DISPID_SRCESoundEnd + 1, + DISPID_SRCERecognition = DISPID_SRCEPhraseStart + 1, + DISPID_SRCEHypothesis = DISPID_SRCERecognition + 1, + DISPID_SRCEPropertyNumberChange = DISPID_SRCEHypothesis + 1, + DISPID_SRCEPropertyStringChange = DISPID_SRCEPropertyNumberChange + 1, + DISPID_SRCEFalseRecognition = DISPID_SRCEPropertyStringChange + 1, + DISPID_SRCEInterference = DISPID_SRCEFalseRecognition + 1, + DISPID_SRCERequestUI = DISPID_SRCEInterference + 1, + DISPID_SRCERecognizerStateChange = DISPID_SRCERequestUI + 1, + DISPID_SRCEAdaptation = DISPID_SRCERecognizerStateChange + 1, + DISPID_SRCERecognitionForOtherContext = DISPID_SRCEAdaptation + 1, + DISPID_SRCEAudioLevel = DISPID_SRCERecognitionForOtherContext + 1, + DISPID_SRCEEnginePrivate = DISPID_SRCEAudioLevel + 1 + } DISPID_SpeechRecoContextEvents; + +typedef +enum SpeechRecognitionType + { SRTStandard = 0, + SRTAutopause = SPREF_AutoPause, + SRTEmulated = SPREF_Emulated + } SpeechRecognitionType; + +typedef /* [hidden] */ +enum DISPID_SpeechGrammarRule + { DISPID_SGRAttributes = 1, + DISPID_SGRInitialState = DISPID_SGRAttributes + 1, + DISPID_SGRName = DISPID_SGRInitialState + 1, + DISPID_SGRId = DISPID_SGRName + 1, + DISPID_SGRClear = DISPID_SGRId + 1, + DISPID_SGRAddResource = DISPID_SGRClear + 1, + DISPID_SGRAddState = DISPID_SGRAddResource + 1 + } DISPID_SpeechGrammarRule; + +typedef /* [hidden] */ +enum DISPID_SpeechGrammarRules + { DISPID_SGRsCount = 1, + DISPID_SGRsDynamic = DISPID_SGRsCount + 1, + DISPID_SGRsAdd = DISPID_SGRsDynamic + 1, + DISPID_SGRsCommit = DISPID_SGRsAdd + 1, + DISPID_SGRsCommitAndSave = DISPID_SGRsCommit + 1, + DISPID_SGRsFindRule = DISPID_SGRsCommitAndSave + 1, + DISPID_SGRsItem = DISPID_VALUE, + DISPID_SGRs_NewEnum = DISPID_NEWENUM + } DISPID_SpeechGrammarRules; + +typedef /* [hidden] */ +enum DISPID_SpeechGrammarRuleState + { DISPID_SGRSRule = 1, + DISPID_SGRSTransitions = DISPID_SGRSRule + 1, + DISPID_SGRSAddWordTransition = DISPID_SGRSTransitions + 1, + DISPID_SGRSAddRuleTransition = DISPID_SGRSAddWordTransition + 1, + DISPID_SGRSAddSpecialTransition = DISPID_SGRSAddRuleTransition + 1 + } DISPID_SpeechGrammarRuleState; + +typedef +enum SpeechSpecialTransitionType + { SSTTWildcard = 1, + SSTTDictation = SSTTWildcard + 1, + SSTTTextBuffer = SSTTDictation + 1 + } SpeechSpecialTransitionType; + +typedef /* [hidden] */ +enum DISPID_SpeechGrammarRuleStateTransitions + { DISPID_SGRSTsCount = 1, + DISPID_SGRSTsItem = DISPID_VALUE, + DISPID_SGRSTs_NewEnum = DISPID_NEWENUM + } DISPID_SpeechGrammarRuleStateTransitions; + +typedef /* [hidden] */ +enum DISPID_SpeechGrammarRuleStateTransition + { DISPID_SGRSTType = 1, + DISPID_SGRSTText = DISPID_SGRSTType + 1, + DISPID_SGRSTRule = DISPID_SGRSTText + 1, + DISPID_SGRSTWeight = DISPID_SGRSTRule + 1, + DISPID_SGRSTPropertyName = DISPID_SGRSTWeight + 1, + DISPID_SGRSTPropertyId = DISPID_SGRSTPropertyName + 1, + DISPID_SGRSTPropertyValue = DISPID_SGRSTPropertyId + 1, + DISPID_SGRSTNextState = DISPID_SGRSTPropertyValue + 1 + } DISPID_SpeechGrammarRuleStateTransition; + +typedef +enum SpeechGrammarRuleStateTransitionType + { SGRSTTEpsilon = 0, + SGRSTTWord = SGRSTTEpsilon + 1, + SGRSTTRule = SGRSTTWord + 1, + SGRSTTDictation = SGRSTTRule + 1, + SGRSTTWildcard = SGRSTTDictation + 1, + SGRSTTTextBuffer = SGRSTTWildcard + 1 + } SpeechGrammarRuleStateTransitionType; + +typedef /* [hidden] */ +enum DISPIDSPTSI + { DISPIDSPTSI_ActiveOffset = 1, + DISPIDSPTSI_ActiveLength = DISPIDSPTSI_ActiveOffset + 1, + DISPIDSPTSI_SelectionOffset = DISPIDSPTSI_ActiveLength + 1, + DISPIDSPTSI_SelectionLength = DISPIDSPTSI_SelectionOffset + 1 + } DISPIDSPTSI; + +typedef /* [hidden] */ +enum DISPID_SpeechRecoResult + { DISPID_SRRRecoContext = 1, + DISPID_SRRTimes = DISPID_SRRRecoContext + 1, + DISPID_SRRAudioFormat = DISPID_SRRTimes + 1, + DISPID_SRRPhraseInfo = DISPID_SRRAudioFormat + 1, + DISPID_SRRAlternates = DISPID_SRRPhraseInfo + 1, + DISPID_SRRAudio = DISPID_SRRAlternates + 1, + DISPID_SRRSpeakAudio = DISPID_SRRAudio + 1, + DISPID_SRRSaveToMemory = DISPID_SRRSpeakAudio + 1, + DISPID_SRRDiscardResultInfo = DISPID_SRRSaveToMemory + 1 + } DISPID_SpeechRecoResult; + +typedef +enum SpeechDiscardType + { SDTProperty = SPDF_PROPERTY, + SDTReplacement = SPDF_REPLACEMENT, + SDTRule = SPDF_RULE, + SDTDisplayText = SPDF_DISPLAYTEXT, + SDTLexicalForm = SPDF_LEXICALFORM, + SDTPronunciation = SPDF_PRONUNCIATION, + SDTAudio = SPDF_AUDIO, + SDTAlternates = SPDF_ALTERNATES, + SDTAll = SPDF_ALL + } SpeechDiscardType; + +typedef /* [hidden] */ +enum DISPID_SpeechPhraseBuilder + { DISPID_SPPBRestorePhraseFromMemory = 1 + } DISPID_SpeechPhraseBuilder; + +typedef /* [hidden] */ +enum DISPID_SpeechRecoResultTimes + { DISPID_SRRTStreamTime = 1, + DISPID_SRRTLength = DISPID_SRRTStreamTime + 1, + DISPID_SRRTTickCount = DISPID_SRRTLength + 1, + DISPID_SRRTOffsetFromStart = DISPID_SRRTTickCount + 1 + } DISPID_SpeechRecoResultTimes; + +typedef /* [hidden] */ +enum DISPID_SpeechPhraseAlternate + { DISPID_SPARecoResult = 1, + DISPID_SPAStartElementInResult = DISPID_SPARecoResult + 1, + DISPID_SPANumberOfElementsInResult = DISPID_SPAStartElementInResult + 1, + DISPID_SPAPhraseInfo = DISPID_SPANumberOfElementsInResult + 1, + DISPID_SPACommit = DISPID_SPAPhraseInfo + 1 + } DISPID_SpeechPhraseAlternate; + +typedef /* [hidden] */ +enum DISPID_SpeechPhraseAlternates + { DISPID_SPAsCount = 1, + DISPID_SPAsItem = DISPID_VALUE, + DISPID_SPAs_NewEnum = DISPID_NEWENUM + } DISPID_SpeechPhraseAlternates; + +typedef /* [hidden] */ +enum DISPID_SpeechPhraseInfo + { DISPID_SPILanguageId = 1, + DISPID_SPIGrammarId = DISPID_SPILanguageId + 1, + DISPID_SPIStartTime = DISPID_SPIGrammarId + 1, + DISPID_SPIAudioStreamPosition = DISPID_SPIStartTime + 1, + DISPID_SPIAudioSizeBytes = DISPID_SPIAudioStreamPosition + 1, + DISPID_SPIRetainedSizeBytes = DISPID_SPIAudioSizeBytes + 1, + DISPID_SPIAudioSizeTime = DISPID_SPIRetainedSizeBytes + 1, + DISPID_SPIRule = DISPID_SPIAudioSizeTime + 1, + DISPID_SPIProperties = DISPID_SPIRule + 1, + DISPID_SPIElements = DISPID_SPIProperties + 1, + DISPID_SPIReplacements = DISPID_SPIElements + 1, + DISPID_SPIEngineId = DISPID_SPIReplacements + 1, + DISPID_SPIEnginePrivateData = DISPID_SPIEngineId + 1, + DISPID_SPISaveToMemory = DISPID_SPIEnginePrivateData + 1, + DISPID_SPIGetText = DISPID_SPISaveToMemory + 1, + DISPID_SPIGetDisplayAttributes = DISPID_SPIGetText + 1 + } DISPID_SpeechPhraseInfo; + +typedef /* [hidden] */ +enum DISPID_SpeechPhraseElement + { DISPID_SPEAudioTimeOffset = 1, + DISPID_SPEAudioSizeTime = DISPID_SPEAudioTimeOffset + 1, + DISPID_SPEAudioStreamOffset = DISPID_SPEAudioSizeTime + 1, + DISPID_SPEAudioSizeBytes = DISPID_SPEAudioStreamOffset + 1, + DISPID_SPERetainedStreamOffset = DISPID_SPEAudioSizeBytes + 1, + DISPID_SPERetainedSizeBytes = DISPID_SPERetainedStreamOffset + 1, + DISPID_SPEDisplayText = DISPID_SPERetainedSizeBytes + 1, + DISPID_SPELexicalForm = DISPID_SPEDisplayText + 1, + DISPID_SPEPronunciation = DISPID_SPELexicalForm + 1, + DISPID_SPEDisplayAttributes = DISPID_SPEPronunciation + 1, + DISPID_SPERequiredConfidence = DISPID_SPEDisplayAttributes + 1, + DISPID_SPEActualConfidence = DISPID_SPERequiredConfidence + 1, + DISPID_SPEEngineConfidence = DISPID_SPEActualConfidence + 1 + } DISPID_SpeechPhraseElement; + +typedef +enum SpeechEngineConfidence + { SECLowConfidence = -1, + SECNormalConfidence = 0, + SECHighConfidence = 1 + } SpeechEngineConfidence; + +typedef /* [hidden] */ +enum DISPID_SpeechPhraseElements + { DISPID_SPEsCount = 1, + DISPID_SPEsItem = DISPID_VALUE, + DISPID_SPEs_NewEnum = DISPID_NEWENUM + } DISPID_SpeechPhraseElements; + +typedef /* [hidden] */ +enum DISPID_SpeechPhraseReplacement + { DISPID_SPRDisplayAttributes = 1, + DISPID_SPRText = DISPID_SPRDisplayAttributes + 1, + DISPID_SPRFirstElement = DISPID_SPRText + 1, + DISPID_SPRNumberOfElements = DISPID_SPRFirstElement + 1 + } DISPID_SpeechPhraseReplacement; + +typedef /* [hidden] */ +enum DISPID_SpeechPhraseReplacements + { DISPID_SPRsCount = 1, + DISPID_SPRsItem = DISPID_VALUE, + DISPID_SPRs_NewEnum = DISPID_NEWENUM + } DISPID_SpeechPhraseReplacements; + +typedef /* [hidden] */ +enum DISPID_SpeechPhraseProperty + { DISPID_SPPName = 1, + DISPID_SPPId = DISPID_SPPName + 1, + DISPID_SPPValue = DISPID_SPPId + 1, + DISPID_SPPFirstElement = DISPID_SPPValue + 1, + DISPID_SPPNumberOfElements = DISPID_SPPFirstElement + 1, + DISPID_SPPEngineConfidence = DISPID_SPPNumberOfElements + 1, + DISPID_SPPConfidence = DISPID_SPPEngineConfidence + 1, + DISPID_SPPParent = DISPID_SPPConfidence + 1, + DISPID_SPPChildren = DISPID_SPPParent + 1 + } DISPID_SpeechPhraseProperty; + +typedef /* [hidden] */ +enum DISPID_SpeechPhraseProperties + { DISPID_SPPsCount = 1, + DISPID_SPPsItem = DISPID_VALUE, + DISPID_SPPs_NewEnum = DISPID_NEWENUM + } DISPID_SpeechPhraseProperties; + +typedef /* [hidden] */ +enum DISPID_SpeechPhraseRule + { DISPID_SPRuleName = 1, + DISPID_SPRuleId = DISPID_SPRuleName + 1, + DISPID_SPRuleFirstElement = DISPID_SPRuleId + 1, + DISPID_SPRuleNumberOfElements = DISPID_SPRuleFirstElement + 1, + DISPID_SPRuleParent = DISPID_SPRuleNumberOfElements + 1, + DISPID_SPRuleChildren = DISPID_SPRuleParent + 1, + DISPID_SPRuleConfidence = DISPID_SPRuleChildren + 1, + DISPID_SPRuleEngineConfidence = DISPID_SPRuleConfidence + 1 + } DISPID_SpeechPhraseRule; + +typedef /* [hidden] */ +enum DISPID_SpeechPhraseRules + { DISPID_SPRulesCount = 1, + DISPID_SPRulesItem = DISPID_VALUE, + DISPID_SPRules_NewEnum = DISPID_NEWENUM + } DISPID_SpeechPhraseRules; + +typedef /* [hidden] */ +enum DISPID_SpeechLexicon + { DISPID_SLGenerationId = 1, + DISPID_SLGetWords = DISPID_SLGenerationId + 1, + DISPID_SLAddPronunciation = DISPID_SLGetWords + 1, + DISPID_SLAddPronunciationByPhoneIds = DISPID_SLAddPronunciation + 1, + DISPID_SLRemovePronunciation = DISPID_SLAddPronunciationByPhoneIds + 1, + DISPID_SLRemovePronunciationByPhoneIds = DISPID_SLRemovePronunciation + 1, + DISPID_SLGetPronunciations = DISPID_SLRemovePronunciationByPhoneIds + 1, + DISPID_SLGetGenerationChange = DISPID_SLGetPronunciations + 1 + } DISPID_SpeechLexicon; + +typedef +enum SpeechLexiconType + { SLTUser = eLEXTYPE_USER, + SLTApp = eLEXTYPE_APP + } SpeechLexiconType; + +typedef +enum SpeechPartOfSpeech + { SPSNotOverriden = SPPS_NotOverriden, + SPSUnknown = SPPS_Unknown, + SPSNoun = SPPS_Noun, + SPSVerb = SPPS_Verb, + SPSModifier = SPPS_Modifier, + SPSFunction = SPPS_Function, + SPSInterjection = SPPS_Interjection + } SpeechPartOfSpeech; + +typedef /* [hidden] */ +enum DISPID_SpeechLexiconWords + { DISPID_SLWsCount = 1, + DISPID_SLWsItem = DISPID_VALUE, + DISPID_SLWs_NewEnum = DISPID_NEWENUM + } DISPID_SpeechLexiconWords; + +typedef +enum SpeechWordType + { SWTAdded = eWORDTYPE_ADDED, + SWTDeleted = eWORDTYPE_DELETED + } SpeechWordType; + +typedef /* [hidden] */ +enum DISPID_SpeechLexiconWord + { DISPID_SLWLangId = 1, + DISPID_SLWType = DISPID_SLWLangId + 1, + DISPID_SLWWord = DISPID_SLWType + 1, + DISPID_SLWPronunciations = DISPID_SLWWord + 1 + } DISPID_SpeechLexiconWord; + +typedef /* [hidden] */ +enum DISPID_SpeechLexiconProns + { DISPID_SLPsCount = 1, + DISPID_SLPsItem = DISPID_VALUE, + DISPID_SLPs_NewEnum = DISPID_NEWENUM + } DISPID_SpeechLexiconProns; + +typedef /* [hidden] */ +enum DISPID_SpeechLexiconPronunciation + { DISPID_SLPType = 1, + DISPID_SLPLangId = DISPID_SLPType + 1, + DISPID_SLPPartOfSpeech = DISPID_SLPLangId + 1, + DISPID_SLPPhoneIds = DISPID_SLPPartOfSpeech + 1, + DISPID_SLPSymbolic = DISPID_SLPPhoneIds + 1 + } DISPID_SpeechLexiconPronunciation; + +typedef /* [hidden] */ +enum DISPID_SpeechPhoneConverter + { DISPID_SPCLangId = 1, + DISPID_SPCPhoneToId = DISPID_SPCLangId + 1, + DISPID_SPCIdToPhone = DISPID_SPCPhoneToId + 1 + } DISPID_SpeechPhoneConverter; + + +EXTERN_C const IID LIBID_SpeechLib; + +#ifndef __ISpeechDataKey_INTERFACE_DEFINED__ +#define __ISpeechDataKey_INTERFACE_DEFINED__ + +/* interface ISpeechDataKey */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechDataKey; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("CE17C09B-4EFA-44d5-A4C9-59D9585AB0CD") + ISpeechDataKey : public IDispatch + { + public: + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE SetBinaryValue( + /* [in] */ const BSTR ValueName, + /* [in] */ VARIANT Value) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE GetBinaryValue( + /* [in] */ const BSTR ValueName, + /* [retval][out] */ VARIANT *Value) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE SetStringValue( + /* [in] */ const BSTR ValueName, + /* [in] */ const BSTR Value) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE GetStringValue( + /* [in] */ const BSTR ValueName, + /* [retval][out] */ BSTR *Value) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE SetLongValue( + /* [in] */ const BSTR ValueName, + /* [in] */ long Value) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE GetLongValue( + /* [in] */ const BSTR ValueName, + /* [retval][out] */ long *Value) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE OpenKey( + /* [in] */ const BSTR SubKeyName, + /* [retval][out] */ ISpeechDataKey **SubKey) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE CreateKey( + /* [in] */ const BSTR SubKeyName, + /* [retval][out] */ ISpeechDataKey **SubKey) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE DeleteKey( + /* [in] */ const BSTR SubKeyName) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE DeleteValue( + /* [in] */ const BSTR ValueName) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE EnumKeys( + /* [in] */ long Index, + /* [retval][out] */ BSTR *SubKeyName) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE EnumValues( + /* [in] */ long Index, + /* [retval][out] */ BSTR *ValueName) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechDataKeyVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechDataKey * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechDataKey * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechDataKey * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechDataKey * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechDataKey * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechDataKey * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechDataKey * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *SetBinaryValue )( + ISpeechDataKey * This, + /* [in] */ const BSTR ValueName, + /* [in] */ VARIANT Value); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetBinaryValue )( + ISpeechDataKey * This, + /* [in] */ const BSTR ValueName, + /* [retval][out] */ VARIANT *Value); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *SetStringValue )( + ISpeechDataKey * This, + /* [in] */ const BSTR ValueName, + /* [in] */ const BSTR Value); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetStringValue )( + ISpeechDataKey * This, + /* [in] */ const BSTR ValueName, + /* [retval][out] */ BSTR *Value); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *SetLongValue )( + ISpeechDataKey * This, + /* [in] */ const BSTR ValueName, + /* [in] */ long Value); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetLongValue )( + ISpeechDataKey * This, + /* [in] */ const BSTR ValueName, + /* [retval][out] */ long *Value); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *OpenKey )( + ISpeechDataKey * This, + /* [in] */ const BSTR SubKeyName, + /* [retval][out] */ ISpeechDataKey **SubKey); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *CreateKey )( + ISpeechDataKey * This, + /* [in] */ const BSTR SubKeyName, + /* [retval][out] */ ISpeechDataKey **SubKey); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *DeleteKey )( + ISpeechDataKey * This, + /* [in] */ const BSTR SubKeyName); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *DeleteValue )( + ISpeechDataKey * This, + /* [in] */ const BSTR ValueName); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *EnumKeys )( + ISpeechDataKey * This, + /* [in] */ long Index, + /* [retval][out] */ BSTR *SubKeyName); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *EnumValues )( + ISpeechDataKey * This, + /* [in] */ long Index, + /* [retval][out] */ BSTR *ValueName); + + END_INTERFACE + } ISpeechDataKeyVtbl; + + interface ISpeechDataKey + { + CONST_VTBL struct ISpeechDataKeyVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechDataKey_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechDataKey_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechDataKey_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechDataKey_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechDataKey_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechDataKey_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechDataKey_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechDataKey_SetBinaryValue(This,ValueName,Value) \ + (This)->lpVtbl -> SetBinaryValue(This,ValueName,Value) + +#define ISpeechDataKey_GetBinaryValue(This,ValueName,Value) \ + (This)->lpVtbl -> GetBinaryValue(This,ValueName,Value) + +#define ISpeechDataKey_SetStringValue(This,ValueName,Value) \ + (This)->lpVtbl -> SetStringValue(This,ValueName,Value) + +#define ISpeechDataKey_GetStringValue(This,ValueName,Value) \ + (This)->lpVtbl -> GetStringValue(This,ValueName,Value) + +#define ISpeechDataKey_SetLongValue(This,ValueName,Value) \ + (This)->lpVtbl -> SetLongValue(This,ValueName,Value) + +#define ISpeechDataKey_GetLongValue(This,ValueName,Value) \ + (This)->lpVtbl -> GetLongValue(This,ValueName,Value) + +#define ISpeechDataKey_OpenKey(This,SubKeyName,SubKey) \ + (This)->lpVtbl -> OpenKey(This,SubKeyName,SubKey) + +#define ISpeechDataKey_CreateKey(This,SubKeyName,SubKey) \ + (This)->lpVtbl -> CreateKey(This,SubKeyName,SubKey) + +#define ISpeechDataKey_DeleteKey(This,SubKeyName) \ + (This)->lpVtbl -> DeleteKey(This,SubKeyName) + +#define ISpeechDataKey_DeleteValue(This,ValueName) \ + (This)->lpVtbl -> DeleteValue(This,ValueName) + +#define ISpeechDataKey_EnumKeys(This,Index,SubKeyName) \ + (This)->lpVtbl -> EnumKeys(This,Index,SubKeyName) + +#define ISpeechDataKey_EnumValues(This,Index,ValueName) \ + (This)->lpVtbl -> EnumValues(This,Index,ValueName) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechDataKey_SetBinaryValue_Proxy( + ISpeechDataKey * This, + /* [in] */ const BSTR ValueName, + /* [in] */ VARIANT Value); + + +void __RPC_STUB ISpeechDataKey_SetBinaryValue_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechDataKey_GetBinaryValue_Proxy( + ISpeechDataKey * This, + /* [in] */ const BSTR ValueName, + /* [retval][out] */ VARIANT *Value); + + +void __RPC_STUB ISpeechDataKey_GetBinaryValue_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechDataKey_SetStringValue_Proxy( + ISpeechDataKey * This, + /* [in] */ const BSTR ValueName, + /* [in] */ const BSTR Value); + + +void __RPC_STUB ISpeechDataKey_SetStringValue_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechDataKey_GetStringValue_Proxy( + ISpeechDataKey * This, + /* [in] */ const BSTR ValueName, + /* [retval][out] */ BSTR *Value); + + +void __RPC_STUB ISpeechDataKey_GetStringValue_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechDataKey_SetLongValue_Proxy( + ISpeechDataKey * This, + /* [in] */ const BSTR ValueName, + /* [in] */ long Value); + + +void __RPC_STUB ISpeechDataKey_SetLongValue_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechDataKey_GetLongValue_Proxy( + ISpeechDataKey * This, + /* [in] */ const BSTR ValueName, + /* [retval][out] */ long *Value); + + +void __RPC_STUB ISpeechDataKey_GetLongValue_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechDataKey_OpenKey_Proxy( + ISpeechDataKey * This, + /* [in] */ const BSTR SubKeyName, + /* [retval][out] */ ISpeechDataKey **SubKey); + + +void __RPC_STUB ISpeechDataKey_OpenKey_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechDataKey_CreateKey_Proxy( + ISpeechDataKey * This, + /* [in] */ const BSTR SubKeyName, + /* [retval][out] */ ISpeechDataKey **SubKey); + + +void __RPC_STUB ISpeechDataKey_CreateKey_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechDataKey_DeleteKey_Proxy( + ISpeechDataKey * This, + /* [in] */ const BSTR SubKeyName); + + +void __RPC_STUB ISpeechDataKey_DeleteKey_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechDataKey_DeleteValue_Proxy( + ISpeechDataKey * This, + /* [in] */ const BSTR ValueName); + + +void __RPC_STUB ISpeechDataKey_DeleteValue_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechDataKey_EnumKeys_Proxy( + ISpeechDataKey * This, + /* [in] */ long Index, + /* [retval][out] */ BSTR *SubKeyName); + + +void __RPC_STUB ISpeechDataKey_EnumKeys_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechDataKey_EnumValues_Proxy( + ISpeechDataKey * This, + /* [in] */ long Index, + /* [retval][out] */ BSTR *ValueName); + + +void __RPC_STUB ISpeechDataKey_EnumValues_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechDataKey_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechObjectToken_INTERFACE_DEFINED__ +#define __ISpeechObjectToken_INTERFACE_DEFINED__ + +/* interface ISpeechObjectToken */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechObjectToken; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("C74A3ADC-B727-4500-A84A-B526721C8B8C") + ISpeechObjectToken : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Id( + /* [retval][out] */ BSTR *ObjectId) = 0; + + virtual /* [hidden][id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_DataKey( + /* [retval][out] */ ISpeechDataKey **DataKey) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Category( + /* [retval][out] */ ISpeechObjectTokenCategory **Category) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE GetDescription( + /* [defaultvalue][in] */ long Locale, + /* [retval][out] */ BSTR *Description) = 0; + + virtual /* [id][hidden][helpstring] */ HRESULT STDMETHODCALLTYPE SetId( + /* [in] */ BSTR Id, + /* [defaultvalue][in] */ BSTR CategoryID = L"", + /* [defaultvalue][in] */ VARIANT_BOOL CreateIfNotExist = 0) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE GetAttribute( + /* [in] */ BSTR AttributeName, + /* [retval][out] */ BSTR *AttributeValue) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE CreateInstance( + /* [defaultvalue][in] */ IUnknown *pUnkOuter, + /* [defaultvalue][in] */ SpeechTokenContext ClsContext, + /* [retval][out] */ IUnknown **Object) = 0; + + virtual /* [id][hidden][helpstring] */ HRESULT STDMETHODCALLTYPE Remove( + /* [in] */ BSTR ObjectStorageCLSID) = 0; + + virtual /* [id][hidden][helpstring] */ HRESULT STDMETHODCALLTYPE GetStorageFileName( + /* [in] */ BSTR ObjectStorageCLSID, + /* [in] */ BSTR KeyName, + /* [in] */ BSTR FileName, + /* [in] */ SpeechTokenShellFolder Folder, + /* [retval][out] */ BSTR *FilePath) = 0; + + virtual /* [id][hidden][helpstring] */ HRESULT STDMETHODCALLTYPE RemoveStorageFileName( + /* [in] */ BSTR ObjectStorageCLSID, + /* [in] */ BSTR KeyName, + /* [in] */ VARIANT_BOOL DeleteFile) = 0; + + virtual /* [id][hidden][helpstring] */ HRESULT STDMETHODCALLTYPE IsUISupported( + /* [in] */ const BSTR TypeOfUI, + /* [defaultvalue][in] */ const VARIANT *ExtraData, + /* [defaultvalue][in] */ IUnknown *Object, + /* [retval][out] */ VARIANT_BOOL *Supported) = 0; + + virtual /* [id][hidden][helpstring] */ HRESULT STDMETHODCALLTYPE DisplayUI( + /* [in] */ long hWnd, + /* [in] */ BSTR Title, + /* [in] */ const BSTR TypeOfUI, + /* [defaultvalue][in] */ const VARIANT *ExtraData = 0, + /* [defaultvalue][in] */ IUnknown *Object = 0) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE MatchesAttributes( + /* [in] */ BSTR Attributes, + /* [retval][out] */ VARIANT_BOOL *Matches) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechObjectTokenVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechObjectToken * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechObjectToken * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechObjectToken * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechObjectToken * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechObjectToken * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechObjectToken * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechObjectToken * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Id )( + ISpeechObjectToken * This, + /* [retval][out] */ BSTR *ObjectId); + + /* [hidden][id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_DataKey )( + ISpeechObjectToken * This, + /* [retval][out] */ ISpeechDataKey **DataKey); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Category )( + ISpeechObjectToken * This, + /* [retval][out] */ ISpeechObjectTokenCategory **Category); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetDescription )( + ISpeechObjectToken * This, + /* [defaultvalue][in] */ long Locale, + /* [retval][out] */ BSTR *Description); + + /* [id][hidden][helpstring] */ HRESULT ( STDMETHODCALLTYPE *SetId )( + ISpeechObjectToken * This, + /* [in] */ BSTR Id, + /* [defaultvalue][in] */ BSTR CategoryID, + /* [defaultvalue][in] */ VARIANT_BOOL CreateIfNotExist); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetAttribute )( + ISpeechObjectToken * This, + /* [in] */ BSTR AttributeName, + /* [retval][out] */ BSTR *AttributeValue); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *CreateInstance )( + ISpeechObjectToken * This, + /* [defaultvalue][in] */ IUnknown *pUnkOuter, + /* [defaultvalue][in] */ SpeechTokenContext ClsContext, + /* [retval][out] */ IUnknown **Object); + + /* [id][hidden][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Remove )( + ISpeechObjectToken * This, + /* [in] */ BSTR ObjectStorageCLSID); + + /* [id][hidden][helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetStorageFileName )( + ISpeechObjectToken * This, + /* [in] */ BSTR ObjectStorageCLSID, + /* [in] */ BSTR KeyName, + /* [in] */ BSTR FileName, + /* [in] */ SpeechTokenShellFolder Folder, + /* [retval][out] */ BSTR *FilePath); + + /* [id][hidden][helpstring] */ HRESULT ( STDMETHODCALLTYPE *RemoveStorageFileName )( + ISpeechObjectToken * This, + /* [in] */ BSTR ObjectStorageCLSID, + /* [in] */ BSTR KeyName, + /* [in] */ VARIANT_BOOL DeleteFile); + + /* [id][hidden][helpstring] */ HRESULT ( STDMETHODCALLTYPE *IsUISupported )( + ISpeechObjectToken * This, + /* [in] */ const BSTR TypeOfUI, + /* [defaultvalue][in] */ const VARIANT *ExtraData, + /* [defaultvalue][in] */ IUnknown *Object, + /* [retval][out] */ VARIANT_BOOL *Supported); + + /* [id][hidden][helpstring] */ HRESULT ( STDMETHODCALLTYPE *DisplayUI )( + ISpeechObjectToken * This, + /* [in] */ long hWnd, + /* [in] */ BSTR Title, + /* [in] */ const BSTR TypeOfUI, + /* [defaultvalue][in] */ const VARIANT *ExtraData, + /* [defaultvalue][in] */ IUnknown *Object); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *MatchesAttributes )( + ISpeechObjectToken * This, + /* [in] */ BSTR Attributes, + /* [retval][out] */ VARIANT_BOOL *Matches); + + END_INTERFACE + } ISpeechObjectTokenVtbl; + + interface ISpeechObjectToken + { + CONST_VTBL struct ISpeechObjectTokenVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechObjectToken_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechObjectToken_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechObjectToken_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechObjectToken_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechObjectToken_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechObjectToken_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechObjectToken_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechObjectToken_get_Id(This,ObjectId) \ + (This)->lpVtbl -> get_Id(This,ObjectId) + +#define ISpeechObjectToken_get_DataKey(This,DataKey) \ + (This)->lpVtbl -> get_DataKey(This,DataKey) + +#define ISpeechObjectToken_get_Category(This,Category) \ + (This)->lpVtbl -> get_Category(This,Category) + +#define ISpeechObjectToken_GetDescription(This,Locale,Description) \ + (This)->lpVtbl -> GetDescription(This,Locale,Description) + +#define ISpeechObjectToken_SetId(This,Id,CategoryID,CreateIfNotExist) \ + (This)->lpVtbl -> SetId(This,Id,CategoryID,CreateIfNotExist) + +#define ISpeechObjectToken_GetAttribute(This,AttributeName,AttributeValue) \ + (This)->lpVtbl -> GetAttribute(This,AttributeName,AttributeValue) + +#define ISpeechObjectToken_CreateInstance(This,pUnkOuter,ClsContext,Object) \ + (This)->lpVtbl -> CreateInstance(This,pUnkOuter,ClsContext,Object) + +#define ISpeechObjectToken_Remove(This,ObjectStorageCLSID) \ + (This)->lpVtbl -> Remove(This,ObjectStorageCLSID) + +#define ISpeechObjectToken_GetStorageFileName(This,ObjectStorageCLSID,KeyName,FileName,Folder,FilePath) \ + (This)->lpVtbl -> GetStorageFileName(This,ObjectStorageCLSID,KeyName,FileName,Folder,FilePath) + +#define ISpeechObjectToken_RemoveStorageFileName(This,ObjectStorageCLSID,KeyName,DeleteFile) \ + (This)->lpVtbl -> RemoveStorageFileName(This,ObjectStorageCLSID,KeyName,DeleteFile) + +#define ISpeechObjectToken_IsUISupported(This,TypeOfUI,ExtraData,Object,Supported) \ + (This)->lpVtbl -> IsUISupported(This,TypeOfUI,ExtraData,Object,Supported) + +#define ISpeechObjectToken_DisplayUI(This,hWnd,Title,TypeOfUI,ExtraData,Object) \ + (This)->lpVtbl -> DisplayUI(This,hWnd,Title,TypeOfUI,ExtraData,Object) + +#define ISpeechObjectToken_MatchesAttributes(This,Attributes,Matches) \ + (This)->lpVtbl -> MatchesAttributes(This,Attributes,Matches) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechObjectToken_get_Id_Proxy( + ISpeechObjectToken * This, + /* [retval][out] */ BSTR *ObjectId); + + +void __RPC_STUB ISpeechObjectToken_get_Id_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [hidden][id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechObjectToken_get_DataKey_Proxy( + ISpeechObjectToken * This, + /* [retval][out] */ ISpeechDataKey **DataKey); + + +void __RPC_STUB ISpeechObjectToken_get_DataKey_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechObjectToken_get_Category_Proxy( + ISpeechObjectToken * This, + /* [retval][out] */ ISpeechObjectTokenCategory **Category); + + +void __RPC_STUB ISpeechObjectToken_get_Category_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechObjectToken_GetDescription_Proxy( + ISpeechObjectToken * This, + /* [defaultvalue][in] */ long Locale, + /* [retval][out] */ BSTR *Description); + + +void __RPC_STUB ISpeechObjectToken_GetDescription_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][hidden][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechObjectToken_SetId_Proxy( + ISpeechObjectToken * This, + /* [in] */ BSTR Id, + /* [defaultvalue][in] */ BSTR CategoryID, + /* [defaultvalue][in] */ VARIANT_BOOL CreateIfNotExist); + + +void __RPC_STUB ISpeechObjectToken_SetId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechObjectToken_GetAttribute_Proxy( + ISpeechObjectToken * This, + /* [in] */ BSTR AttributeName, + /* [retval][out] */ BSTR *AttributeValue); + + +void __RPC_STUB ISpeechObjectToken_GetAttribute_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechObjectToken_CreateInstance_Proxy( + ISpeechObjectToken * This, + /* [defaultvalue][in] */ IUnknown *pUnkOuter, + /* [defaultvalue][in] */ SpeechTokenContext ClsContext, + /* [retval][out] */ IUnknown **Object); + + +void __RPC_STUB ISpeechObjectToken_CreateInstance_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][hidden][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechObjectToken_Remove_Proxy( + ISpeechObjectToken * This, + /* [in] */ BSTR ObjectStorageCLSID); + + +void __RPC_STUB ISpeechObjectToken_Remove_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][hidden][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechObjectToken_GetStorageFileName_Proxy( + ISpeechObjectToken * This, + /* [in] */ BSTR ObjectStorageCLSID, + /* [in] */ BSTR KeyName, + /* [in] */ BSTR FileName, + /* [in] */ SpeechTokenShellFolder Folder, + /* [retval][out] */ BSTR *FilePath); + + +void __RPC_STUB ISpeechObjectToken_GetStorageFileName_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][hidden][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechObjectToken_RemoveStorageFileName_Proxy( + ISpeechObjectToken * This, + /* [in] */ BSTR ObjectStorageCLSID, + /* [in] */ BSTR KeyName, + /* [in] */ VARIANT_BOOL DeleteFile); + + +void __RPC_STUB ISpeechObjectToken_RemoveStorageFileName_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][hidden][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechObjectToken_IsUISupported_Proxy( + ISpeechObjectToken * This, + /* [in] */ const BSTR TypeOfUI, + /* [defaultvalue][in] */ const VARIANT *ExtraData, + /* [defaultvalue][in] */ IUnknown *Object, + /* [retval][out] */ VARIANT_BOOL *Supported); + + +void __RPC_STUB ISpeechObjectToken_IsUISupported_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][hidden][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechObjectToken_DisplayUI_Proxy( + ISpeechObjectToken * This, + /* [in] */ long hWnd, + /* [in] */ BSTR Title, + /* [in] */ const BSTR TypeOfUI, + /* [defaultvalue][in] */ const VARIANT *ExtraData, + /* [defaultvalue][in] */ IUnknown *Object); + + +void __RPC_STUB ISpeechObjectToken_DisplayUI_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechObjectToken_MatchesAttributes_Proxy( + ISpeechObjectToken * This, + /* [in] */ BSTR Attributes, + /* [retval][out] */ VARIANT_BOOL *Matches); + + +void __RPC_STUB ISpeechObjectToken_MatchesAttributes_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechObjectToken_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechObjectTokens_INTERFACE_DEFINED__ +#define __ISpeechObjectTokens_INTERFACE_DEFINED__ + +/* interface ISpeechObjectTokens */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechObjectTokens; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("9285B776-2E7B-4bc0-B53E-580EB6FA967F") + ISpeechObjectTokens : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( + /* [retval][out] */ long *Count) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE Item( + /* [in] */ long Index, + /* [retval][out] */ ISpeechObjectToken **Token) = 0; + + virtual /* [id][restricted][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( + /* [retval][out] */ IUnknown **ppEnumVARIANT) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechObjectTokensVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechObjectTokens * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechObjectTokens * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechObjectTokens * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechObjectTokens * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechObjectTokens * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechObjectTokens * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechObjectTokens * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( + ISpeechObjectTokens * This, + /* [retval][out] */ long *Count); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Item )( + ISpeechObjectTokens * This, + /* [in] */ long Index, + /* [retval][out] */ ISpeechObjectToken **Token); + + /* [id][restricted][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( + ISpeechObjectTokens * This, + /* [retval][out] */ IUnknown **ppEnumVARIANT); + + END_INTERFACE + } ISpeechObjectTokensVtbl; + + interface ISpeechObjectTokens + { + CONST_VTBL struct ISpeechObjectTokensVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechObjectTokens_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechObjectTokens_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechObjectTokens_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechObjectTokens_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechObjectTokens_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechObjectTokens_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechObjectTokens_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechObjectTokens_get_Count(This,Count) \ + (This)->lpVtbl -> get_Count(This,Count) + +#define ISpeechObjectTokens_Item(This,Index,Token) \ + (This)->lpVtbl -> Item(This,Index,Token) + +#define ISpeechObjectTokens_get__NewEnum(This,ppEnumVARIANT) \ + (This)->lpVtbl -> get__NewEnum(This,ppEnumVARIANT) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechObjectTokens_get_Count_Proxy( + ISpeechObjectTokens * This, + /* [retval][out] */ long *Count); + + +void __RPC_STUB ISpeechObjectTokens_get_Count_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechObjectTokens_Item_Proxy( + ISpeechObjectTokens * This, + /* [in] */ long Index, + /* [retval][out] */ ISpeechObjectToken **Token); + + +void __RPC_STUB ISpeechObjectTokens_Item_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][restricted][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechObjectTokens_get__NewEnum_Proxy( + ISpeechObjectTokens * This, + /* [retval][out] */ IUnknown **ppEnumVARIANT); + + +void __RPC_STUB ISpeechObjectTokens_get__NewEnum_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechObjectTokens_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechObjectTokenCategory_INTERFACE_DEFINED__ +#define __ISpeechObjectTokenCategory_INTERFACE_DEFINED__ + +/* interface ISpeechObjectTokenCategory */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechObjectTokenCategory; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("CA7EAC50-2D01-4145-86D4-5AE7D70F4469") + ISpeechObjectTokenCategory : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Id( + /* [retval][out] */ BSTR *Id) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_Default( + /* [in] */ const BSTR TokenId) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Default( + /* [retval][out] */ BSTR *TokenId) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE SetId( + /* [in] */ const BSTR Id, + /* [defaultvalue][in] */ VARIANT_BOOL CreateIfNotExist = 0) = 0; + + virtual /* [id][hidden][helpstring] */ HRESULT STDMETHODCALLTYPE GetDataKey( + /* [defaultvalue][in] */ SpeechDataKeyLocation Location, + /* [retval][out] */ ISpeechDataKey **DataKey) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE EnumerateTokens( + /* [defaultvalue][in] */ BSTR RequiredAttributes, + /* [defaultvalue][in] */ BSTR OptionalAttributes, + /* [retval][out] */ ISpeechObjectTokens **Tokens) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechObjectTokenCategoryVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechObjectTokenCategory * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechObjectTokenCategory * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechObjectTokenCategory * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechObjectTokenCategory * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechObjectTokenCategory * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechObjectTokenCategory * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechObjectTokenCategory * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Id )( + ISpeechObjectTokenCategory * This, + /* [retval][out] */ BSTR *Id); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_Default )( + ISpeechObjectTokenCategory * This, + /* [in] */ const BSTR TokenId); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Default )( + ISpeechObjectTokenCategory * This, + /* [retval][out] */ BSTR *TokenId); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *SetId )( + ISpeechObjectTokenCategory * This, + /* [in] */ const BSTR Id, + /* [defaultvalue][in] */ VARIANT_BOOL CreateIfNotExist); + + /* [id][hidden][helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetDataKey )( + ISpeechObjectTokenCategory * This, + /* [defaultvalue][in] */ SpeechDataKeyLocation Location, + /* [retval][out] */ ISpeechDataKey **DataKey); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *EnumerateTokens )( + ISpeechObjectTokenCategory * This, + /* [defaultvalue][in] */ BSTR RequiredAttributes, + /* [defaultvalue][in] */ BSTR OptionalAttributes, + /* [retval][out] */ ISpeechObjectTokens **Tokens); + + END_INTERFACE + } ISpeechObjectTokenCategoryVtbl; + + interface ISpeechObjectTokenCategory + { + CONST_VTBL struct ISpeechObjectTokenCategoryVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechObjectTokenCategory_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechObjectTokenCategory_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechObjectTokenCategory_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechObjectTokenCategory_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechObjectTokenCategory_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechObjectTokenCategory_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechObjectTokenCategory_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechObjectTokenCategory_get_Id(This,Id) \ + (This)->lpVtbl -> get_Id(This,Id) + +#define ISpeechObjectTokenCategory_put_Default(This,TokenId) \ + (This)->lpVtbl -> put_Default(This,TokenId) + +#define ISpeechObjectTokenCategory_get_Default(This,TokenId) \ + (This)->lpVtbl -> get_Default(This,TokenId) + +#define ISpeechObjectTokenCategory_SetId(This,Id,CreateIfNotExist) \ + (This)->lpVtbl -> SetId(This,Id,CreateIfNotExist) + +#define ISpeechObjectTokenCategory_GetDataKey(This,Location,DataKey) \ + (This)->lpVtbl -> GetDataKey(This,Location,DataKey) + +#define ISpeechObjectTokenCategory_EnumerateTokens(This,RequiredAttributes,OptionalAttributes,Tokens) \ + (This)->lpVtbl -> EnumerateTokens(This,RequiredAttributes,OptionalAttributes,Tokens) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechObjectTokenCategory_get_Id_Proxy( + ISpeechObjectTokenCategory * This, + /* [retval][out] */ BSTR *Id); + + +void __RPC_STUB ISpeechObjectTokenCategory_get_Id_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechObjectTokenCategory_put_Default_Proxy( + ISpeechObjectTokenCategory * This, + /* [in] */ const BSTR TokenId); + + +void __RPC_STUB ISpeechObjectTokenCategory_put_Default_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechObjectTokenCategory_get_Default_Proxy( + ISpeechObjectTokenCategory * This, + /* [retval][out] */ BSTR *TokenId); + + +void __RPC_STUB ISpeechObjectTokenCategory_get_Default_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechObjectTokenCategory_SetId_Proxy( + ISpeechObjectTokenCategory * This, + /* [in] */ const BSTR Id, + /* [defaultvalue][in] */ VARIANT_BOOL CreateIfNotExist); + + +void __RPC_STUB ISpeechObjectTokenCategory_SetId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][hidden][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechObjectTokenCategory_GetDataKey_Proxy( + ISpeechObjectTokenCategory * This, + /* [defaultvalue][in] */ SpeechDataKeyLocation Location, + /* [retval][out] */ ISpeechDataKey **DataKey); + + +void __RPC_STUB ISpeechObjectTokenCategory_GetDataKey_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechObjectTokenCategory_EnumerateTokens_Proxy( + ISpeechObjectTokenCategory * This, + /* [defaultvalue][in] */ BSTR RequiredAttributes, + /* [defaultvalue][in] */ BSTR OptionalAttributes, + /* [retval][out] */ ISpeechObjectTokens **Tokens); + + +void __RPC_STUB ISpeechObjectTokenCategory_EnumerateTokens_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechObjectTokenCategory_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechAudioBufferInfo_INTERFACE_DEFINED__ +#define __ISpeechAudioBufferInfo_INTERFACE_DEFINED__ + +/* interface ISpeechAudioBufferInfo */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechAudioBufferInfo; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("11B103D8-1142-4edf-A093-82FB3915F8CC") + ISpeechAudioBufferInfo : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_MinNotification( + /* [retval][out] */ long *MinNotification) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_MinNotification( + /* [in] */ long MinNotification) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_BufferSize( + /* [retval][out] */ long *BufferSize) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_BufferSize( + /* [in] */ long BufferSize) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_EventBias( + /* [retval][out] */ long *EventBias) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_EventBias( + /* [in] */ long EventBias) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechAudioBufferInfoVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechAudioBufferInfo * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechAudioBufferInfo * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechAudioBufferInfo * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechAudioBufferInfo * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechAudioBufferInfo * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechAudioBufferInfo * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechAudioBufferInfo * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_MinNotification )( + ISpeechAudioBufferInfo * This, + /* [retval][out] */ long *MinNotification); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_MinNotification )( + ISpeechAudioBufferInfo * This, + /* [in] */ long MinNotification); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_BufferSize )( + ISpeechAudioBufferInfo * This, + /* [retval][out] */ long *BufferSize); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_BufferSize )( + ISpeechAudioBufferInfo * This, + /* [in] */ long BufferSize); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_EventBias )( + ISpeechAudioBufferInfo * This, + /* [retval][out] */ long *EventBias); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_EventBias )( + ISpeechAudioBufferInfo * This, + /* [in] */ long EventBias); + + END_INTERFACE + } ISpeechAudioBufferInfoVtbl; + + interface ISpeechAudioBufferInfo + { + CONST_VTBL struct ISpeechAudioBufferInfoVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechAudioBufferInfo_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechAudioBufferInfo_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechAudioBufferInfo_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechAudioBufferInfo_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechAudioBufferInfo_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechAudioBufferInfo_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechAudioBufferInfo_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechAudioBufferInfo_get_MinNotification(This,MinNotification) \ + (This)->lpVtbl -> get_MinNotification(This,MinNotification) + +#define ISpeechAudioBufferInfo_put_MinNotification(This,MinNotification) \ + (This)->lpVtbl -> put_MinNotification(This,MinNotification) + +#define ISpeechAudioBufferInfo_get_BufferSize(This,BufferSize) \ + (This)->lpVtbl -> get_BufferSize(This,BufferSize) + +#define ISpeechAudioBufferInfo_put_BufferSize(This,BufferSize) \ + (This)->lpVtbl -> put_BufferSize(This,BufferSize) + +#define ISpeechAudioBufferInfo_get_EventBias(This,EventBias) \ + (This)->lpVtbl -> get_EventBias(This,EventBias) + +#define ISpeechAudioBufferInfo_put_EventBias(This,EventBias) \ + (This)->lpVtbl -> put_EventBias(This,EventBias) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechAudioBufferInfo_get_MinNotification_Proxy( + ISpeechAudioBufferInfo * This, + /* [retval][out] */ long *MinNotification); + + +void __RPC_STUB ISpeechAudioBufferInfo_get_MinNotification_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechAudioBufferInfo_put_MinNotification_Proxy( + ISpeechAudioBufferInfo * This, + /* [in] */ long MinNotification); + + +void __RPC_STUB ISpeechAudioBufferInfo_put_MinNotification_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechAudioBufferInfo_get_BufferSize_Proxy( + ISpeechAudioBufferInfo * This, + /* [retval][out] */ long *BufferSize); + + +void __RPC_STUB ISpeechAudioBufferInfo_get_BufferSize_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechAudioBufferInfo_put_BufferSize_Proxy( + ISpeechAudioBufferInfo * This, + /* [in] */ long BufferSize); + + +void __RPC_STUB ISpeechAudioBufferInfo_put_BufferSize_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechAudioBufferInfo_get_EventBias_Proxy( + ISpeechAudioBufferInfo * This, + /* [retval][out] */ long *EventBias); + + +void __RPC_STUB ISpeechAudioBufferInfo_get_EventBias_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechAudioBufferInfo_put_EventBias_Proxy( + ISpeechAudioBufferInfo * This, + /* [in] */ long EventBias); + + +void __RPC_STUB ISpeechAudioBufferInfo_put_EventBias_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechAudioBufferInfo_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechAudioStatus_INTERFACE_DEFINED__ +#define __ISpeechAudioStatus_INTERFACE_DEFINED__ + +/* interface ISpeechAudioStatus */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechAudioStatus; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("C62D9C91-7458-47f6-862D-1EF86FB0B278") + ISpeechAudioStatus : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_FreeBufferSpace( + /* [retval][out] */ long *FreeBufferSpace) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_NonBlockingIO( + /* [retval][out] */ long *NonBlockingIO) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_State( + /* [retval][out] */ SpeechAudioState *State) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_CurrentSeekPosition( + /* [retval][out] */ VARIANT *CurrentSeekPosition) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_CurrentDevicePosition( + /* [retval][out] */ VARIANT *CurrentDevicePosition) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechAudioStatusVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechAudioStatus * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechAudioStatus * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechAudioStatus * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechAudioStatus * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechAudioStatus * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechAudioStatus * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechAudioStatus * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_FreeBufferSpace )( + ISpeechAudioStatus * This, + /* [retval][out] */ long *FreeBufferSpace); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_NonBlockingIO )( + ISpeechAudioStatus * This, + /* [retval][out] */ long *NonBlockingIO); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_State )( + ISpeechAudioStatus * This, + /* [retval][out] */ SpeechAudioState *State); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_CurrentSeekPosition )( + ISpeechAudioStatus * This, + /* [retval][out] */ VARIANT *CurrentSeekPosition); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_CurrentDevicePosition )( + ISpeechAudioStatus * This, + /* [retval][out] */ VARIANT *CurrentDevicePosition); + + END_INTERFACE + } ISpeechAudioStatusVtbl; + + interface ISpeechAudioStatus + { + CONST_VTBL struct ISpeechAudioStatusVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechAudioStatus_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechAudioStatus_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechAudioStatus_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechAudioStatus_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechAudioStatus_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechAudioStatus_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechAudioStatus_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechAudioStatus_get_FreeBufferSpace(This,FreeBufferSpace) \ + (This)->lpVtbl -> get_FreeBufferSpace(This,FreeBufferSpace) + +#define ISpeechAudioStatus_get_NonBlockingIO(This,NonBlockingIO) \ + (This)->lpVtbl -> get_NonBlockingIO(This,NonBlockingIO) + +#define ISpeechAudioStatus_get_State(This,State) \ + (This)->lpVtbl -> get_State(This,State) + +#define ISpeechAudioStatus_get_CurrentSeekPosition(This,CurrentSeekPosition) \ + (This)->lpVtbl -> get_CurrentSeekPosition(This,CurrentSeekPosition) + +#define ISpeechAudioStatus_get_CurrentDevicePosition(This,CurrentDevicePosition) \ + (This)->lpVtbl -> get_CurrentDevicePosition(This,CurrentDevicePosition) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechAudioStatus_get_FreeBufferSpace_Proxy( + ISpeechAudioStatus * This, + /* [retval][out] */ long *FreeBufferSpace); + + +void __RPC_STUB ISpeechAudioStatus_get_FreeBufferSpace_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechAudioStatus_get_NonBlockingIO_Proxy( + ISpeechAudioStatus * This, + /* [retval][out] */ long *NonBlockingIO); + + +void __RPC_STUB ISpeechAudioStatus_get_NonBlockingIO_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechAudioStatus_get_State_Proxy( + ISpeechAudioStatus * This, + /* [retval][out] */ SpeechAudioState *State); + + +void __RPC_STUB ISpeechAudioStatus_get_State_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechAudioStatus_get_CurrentSeekPosition_Proxy( + ISpeechAudioStatus * This, + /* [retval][out] */ VARIANT *CurrentSeekPosition); + + +void __RPC_STUB ISpeechAudioStatus_get_CurrentSeekPosition_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechAudioStatus_get_CurrentDevicePosition_Proxy( + ISpeechAudioStatus * This, + /* [retval][out] */ VARIANT *CurrentDevicePosition); + + +void __RPC_STUB ISpeechAudioStatus_get_CurrentDevicePosition_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechAudioStatus_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechAudioFormat_INTERFACE_DEFINED__ +#define __ISpeechAudioFormat_INTERFACE_DEFINED__ + +/* interface ISpeechAudioFormat */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechAudioFormat; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("E6E9C590-3E18-40e3-8299-061F98BDE7C7") + ISpeechAudioFormat : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Type( + /* [retval][out] */ SpeechAudioFormatType *AudioFormat) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_Type( + /* [in] */ SpeechAudioFormatType AudioFormat) = 0; + + virtual /* [id][helpstring][hidden][propget] */ HRESULT STDMETHODCALLTYPE get_Guid( + /* [retval][out] */ BSTR *Guid) = 0; + + virtual /* [id][helpstring][hidden][propput] */ HRESULT STDMETHODCALLTYPE put_Guid( + /* [in] */ BSTR Guid) = 0; + + virtual /* [id][helpstring][hidden] */ HRESULT STDMETHODCALLTYPE GetWaveFormatEx( + /* [retval][out] */ ISpeechWaveFormatEx **WaveFormatEx) = 0; + + virtual /* [id][helpstring][hidden] */ HRESULT STDMETHODCALLTYPE SetWaveFormatEx( + /* [in] */ ISpeechWaveFormatEx *WaveFormatEx) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechAudioFormatVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechAudioFormat * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechAudioFormat * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechAudioFormat * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechAudioFormat * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechAudioFormat * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechAudioFormat * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechAudioFormat * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Type )( + ISpeechAudioFormat * This, + /* [retval][out] */ SpeechAudioFormatType *AudioFormat); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_Type )( + ISpeechAudioFormat * This, + /* [in] */ SpeechAudioFormatType AudioFormat); + + /* [id][helpstring][hidden][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Guid )( + ISpeechAudioFormat * This, + /* [retval][out] */ BSTR *Guid); + + /* [id][helpstring][hidden][propput] */ HRESULT ( STDMETHODCALLTYPE *put_Guid )( + ISpeechAudioFormat * This, + /* [in] */ BSTR Guid); + + /* [id][helpstring][hidden] */ HRESULT ( STDMETHODCALLTYPE *GetWaveFormatEx )( + ISpeechAudioFormat * This, + /* [retval][out] */ ISpeechWaveFormatEx **WaveFormatEx); + + /* [id][helpstring][hidden] */ HRESULT ( STDMETHODCALLTYPE *SetWaveFormatEx )( + ISpeechAudioFormat * This, + /* [in] */ ISpeechWaveFormatEx *WaveFormatEx); + + END_INTERFACE + } ISpeechAudioFormatVtbl; + + interface ISpeechAudioFormat + { + CONST_VTBL struct ISpeechAudioFormatVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechAudioFormat_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechAudioFormat_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechAudioFormat_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechAudioFormat_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechAudioFormat_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechAudioFormat_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechAudioFormat_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechAudioFormat_get_Type(This,AudioFormat) \ + (This)->lpVtbl -> get_Type(This,AudioFormat) + +#define ISpeechAudioFormat_put_Type(This,AudioFormat) \ + (This)->lpVtbl -> put_Type(This,AudioFormat) + +#define ISpeechAudioFormat_get_Guid(This,Guid) \ + (This)->lpVtbl -> get_Guid(This,Guid) + +#define ISpeechAudioFormat_put_Guid(This,Guid) \ + (This)->lpVtbl -> put_Guid(This,Guid) + +#define ISpeechAudioFormat_GetWaveFormatEx(This,WaveFormatEx) \ + (This)->lpVtbl -> GetWaveFormatEx(This,WaveFormatEx) + +#define ISpeechAudioFormat_SetWaveFormatEx(This,WaveFormatEx) \ + (This)->lpVtbl -> SetWaveFormatEx(This,WaveFormatEx) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechAudioFormat_get_Type_Proxy( + ISpeechAudioFormat * This, + /* [retval][out] */ SpeechAudioFormatType *AudioFormat); + + +void __RPC_STUB ISpeechAudioFormat_get_Type_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechAudioFormat_put_Type_Proxy( + ISpeechAudioFormat * This, + /* [in] */ SpeechAudioFormatType AudioFormat); + + +void __RPC_STUB ISpeechAudioFormat_put_Type_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][hidden][propget] */ HRESULT STDMETHODCALLTYPE ISpeechAudioFormat_get_Guid_Proxy( + ISpeechAudioFormat * This, + /* [retval][out] */ BSTR *Guid); + + +void __RPC_STUB ISpeechAudioFormat_get_Guid_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][hidden][propput] */ HRESULT STDMETHODCALLTYPE ISpeechAudioFormat_put_Guid_Proxy( + ISpeechAudioFormat * This, + /* [in] */ BSTR Guid); + + +void __RPC_STUB ISpeechAudioFormat_put_Guid_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][hidden] */ HRESULT STDMETHODCALLTYPE ISpeechAudioFormat_GetWaveFormatEx_Proxy( + ISpeechAudioFormat * This, + /* [retval][out] */ ISpeechWaveFormatEx **WaveFormatEx); + + +void __RPC_STUB ISpeechAudioFormat_GetWaveFormatEx_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][hidden] */ HRESULT STDMETHODCALLTYPE ISpeechAudioFormat_SetWaveFormatEx_Proxy( + ISpeechAudioFormat * This, + /* [in] */ ISpeechWaveFormatEx *WaveFormatEx); + + +void __RPC_STUB ISpeechAudioFormat_SetWaveFormatEx_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechAudioFormat_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechWaveFormatEx_INTERFACE_DEFINED__ +#define __ISpeechWaveFormatEx_INTERFACE_DEFINED__ + +/* interface ISpeechWaveFormatEx */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechWaveFormatEx; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("7A1EF0D5-1581-4741-88E4-209A49F11A10") + ISpeechWaveFormatEx : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_FormatTag( + /* [retval][out] */ short *FormatTag) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_FormatTag( + /* [in] */ short FormatTag) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Channels( + /* [retval][out] */ short *Channels) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_Channels( + /* [in] */ short Channels) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_SamplesPerSec( + /* [retval][out] */ long *SamplesPerSec) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_SamplesPerSec( + /* [in] */ long SamplesPerSec) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_AvgBytesPerSec( + /* [retval][out] */ long *AvgBytesPerSec) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_AvgBytesPerSec( + /* [in] */ long AvgBytesPerSec) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_BlockAlign( + /* [retval][out] */ short *BlockAlign) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_BlockAlign( + /* [in] */ short BlockAlign) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_BitsPerSample( + /* [retval][out] */ short *BitsPerSample) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_BitsPerSample( + /* [in] */ short BitsPerSample) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_ExtraData( + /* [retval][out] */ VARIANT *ExtraData) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_ExtraData( + /* [in] */ VARIANT ExtraData) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechWaveFormatExVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechWaveFormatEx * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechWaveFormatEx * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechWaveFormatEx * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechWaveFormatEx * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechWaveFormatEx * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechWaveFormatEx * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechWaveFormatEx * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_FormatTag )( + ISpeechWaveFormatEx * This, + /* [retval][out] */ short *FormatTag); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_FormatTag )( + ISpeechWaveFormatEx * This, + /* [in] */ short FormatTag); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Channels )( + ISpeechWaveFormatEx * This, + /* [retval][out] */ short *Channels); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_Channels )( + ISpeechWaveFormatEx * This, + /* [in] */ short Channels); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_SamplesPerSec )( + ISpeechWaveFormatEx * This, + /* [retval][out] */ long *SamplesPerSec); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_SamplesPerSec )( + ISpeechWaveFormatEx * This, + /* [in] */ long SamplesPerSec); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_AvgBytesPerSec )( + ISpeechWaveFormatEx * This, + /* [retval][out] */ long *AvgBytesPerSec); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_AvgBytesPerSec )( + ISpeechWaveFormatEx * This, + /* [in] */ long AvgBytesPerSec); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_BlockAlign )( + ISpeechWaveFormatEx * This, + /* [retval][out] */ short *BlockAlign); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_BlockAlign )( + ISpeechWaveFormatEx * This, + /* [in] */ short BlockAlign); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_BitsPerSample )( + ISpeechWaveFormatEx * This, + /* [retval][out] */ short *BitsPerSample); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_BitsPerSample )( + ISpeechWaveFormatEx * This, + /* [in] */ short BitsPerSample); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_ExtraData )( + ISpeechWaveFormatEx * This, + /* [retval][out] */ VARIANT *ExtraData); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_ExtraData )( + ISpeechWaveFormatEx * This, + /* [in] */ VARIANT ExtraData); + + END_INTERFACE + } ISpeechWaveFormatExVtbl; + + interface ISpeechWaveFormatEx + { + CONST_VTBL struct ISpeechWaveFormatExVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechWaveFormatEx_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechWaveFormatEx_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechWaveFormatEx_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechWaveFormatEx_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechWaveFormatEx_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechWaveFormatEx_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechWaveFormatEx_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechWaveFormatEx_get_FormatTag(This,FormatTag) \ + (This)->lpVtbl -> get_FormatTag(This,FormatTag) + +#define ISpeechWaveFormatEx_put_FormatTag(This,FormatTag) \ + (This)->lpVtbl -> put_FormatTag(This,FormatTag) + +#define ISpeechWaveFormatEx_get_Channels(This,Channels) \ + (This)->lpVtbl -> get_Channels(This,Channels) + +#define ISpeechWaveFormatEx_put_Channels(This,Channels) \ + (This)->lpVtbl -> put_Channels(This,Channels) + +#define ISpeechWaveFormatEx_get_SamplesPerSec(This,SamplesPerSec) \ + (This)->lpVtbl -> get_SamplesPerSec(This,SamplesPerSec) + +#define ISpeechWaveFormatEx_put_SamplesPerSec(This,SamplesPerSec) \ + (This)->lpVtbl -> put_SamplesPerSec(This,SamplesPerSec) + +#define ISpeechWaveFormatEx_get_AvgBytesPerSec(This,AvgBytesPerSec) \ + (This)->lpVtbl -> get_AvgBytesPerSec(This,AvgBytesPerSec) + +#define ISpeechWaveFormatEx_put_AvgBytesPerSec(This,AvgBytesPerSec) \ + (This)->lpVtbl -> put_AvgBytesPerSec(This,AvgBytesPerSec) + +#define ISpeechWaveFormatEx_get_BlockAlign(This,BlockAlign) \ + (This)->lpVtbl -> get_BlockAlign(This,BlockAlign) + +#define ISpeechWaveFormatEx_put_BlockAlign(This,BlockAlign) \ + (This)->lpVtbl -> put_BlockAlign(This,BlockAlign) + +#define ISpeechWaveFormatEx_get_BitsPerSample(This,BitsPerSample) \ + (This)->lpVtbl -> get_BitsPerSample(This,BitsPerSample) + +#define ISpeechWaveFormatEx_put_BitsPerSample(This,BitsPerSample) \ + (This)->lpVtbl -> put_BitsPerSample(This,BitsPerSample) + +#define ISpeechWaveFormatEx_get_ExtraData(This,ExtraData) \ + (This)->lpVtbl -> get_ExtraData(This,ExtraData) + +#define ISpeechWaveFormatEx_put_ExtraData(This,ExtraData) \ + (This)->lpVtbl -> put_ExtraData(This,ExtraData) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechWaveFormatEx_get_FormatTag_Proxy( + ISpeechWaveFormatEx * This, + /* [retval][out] */ short *FormatTag); + + +void __RPC_STUB ISpeechWaveFormatEx_get_FormatTag_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechWaveFormatEx_put_FormatTag_Proxy( + ISpeechWaveFormatEx * This, + /* [in] */ short FormatTag); + + +void __RPC_STUB ISpeechWaveFormatEx_put_FormatTag_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechWaveFormatEx_get_Channels_Proxy( + ISpeechWaveFormatEx * This, + /* [retval][out] */ short *Channels); + + +void __RPC_STUB ISpeechWaveFormatEx_get_Channels_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechWaveFormatEx_put_Channels_Proxy( + ISpeechWaveFormatEx * This, + /* [in] */ short Channels); + + +void __RPC_STUB ISpeechWaveFormatEx_put_Channels_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechWaveFormatEx_get_SamplesPerSec_Proxy( + ISpeechWaveFormatEx * This, + /* [retval][out] */ long *SamplesPerSec); + + +void __RPC_STUB ISpeechWaveFormatEx_get_SamplesPerSec_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechWaveFormatEx_put_SamplesPerSec_Proxy( + ISpeechWaveFormatEx * This, + /* [in] */ long SamplesPerSec); + + +void __RPC_STUB ISpeechWaveFormatEx_put_SamplesPerSec_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechWaveFormatEx_get_AvgBytesPerSec_Proxy( + ISpeechWaveFormatEx * This, + /* [retval][out] */ long *AvgBytesPerSec); + + +void __RPC_STUB ISpeechWaveFormatEx_get_AvgBytesPerSec_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechWaveFormatEx_put_AvgBytesPerSec_Proxy( + ISpeechWaveFormatEx * This, + /* [in] */ long AvgBytesPerSec); + + +void __RPC_STUB ISpeechWaveFormatEx_put_AvgBytesPerSec_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechWaveFormatEx_get_BlockAlign_Proxy( + ISpeechWaveFormatEx * This, + /* [retval][out] */ short *BlockAlign); + + +void __RPC_STUB ISpeechWaveFormatEx_get_BlockAlign_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechWaveFormatEx_put_BlockAlign_Proxy( + ISpeechWaveFormatEx * This, + /* [in] */ short BlockAlign); + + +void __RPC_STUB ISpeechWaveFormatEx_put_BlockAlign_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechWaveFormatEx_get_BitsPerSample_Proxy( + ISpeechWaveFormatEx * This, + /* [retval][out] */ short *BitsPerSample); + + +void __RPC_STUB ISpeechWaveFormatEx_get_BitsPerSample_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechWaveFormatEx_put_BitsPerSample_Proxy( + ISpeechWaveFormatEx * This, + /* [in] */ short BitsPerSample); + + +void __RPC_STUB ISpeechWaveFormatEx_put_BitsPerSample_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechWaveFormatEx_get_ExtraData_Proxy( + ISpeechWaveFormatEx * This, + /* [retval][out] */ VARIANT *ExtraData); + + +void __RPC_STUB ISpeechWaveFormatEx_get_ExtraData_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechWaveFormatEx_put_ExtraData_Proxy( + ISpeechWaveFormatEx * This, + /* [in] */ VARIANT ExtraData); + + +void __RPC_STUB ISpeechWaveFormatEx_put_ExtraData_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechWaveFormatEx_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechBaseStream_INTERFACE_DEFINED__ +#define __ISpeechBaseStream_INTERFACE_DEFINED__ + +/* interface ISpeechBaseStream */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechBaseStream; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("6450336F-7D49-4ced-8097-49D6DEE37294") + ISpeechBaseStream : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Format( + /* [retval][out] */ ISpeechAudioFormat **AudioFormat) = 0; + + virtual /* [id][helpstring][propputref] */ HRESULT STDMETHODCALLTYPE putref_Format( + /* [in] */ ISpeechAudioFormat *AudioFormat) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE Read( + /* [out] */ VARIANT *Buffer, + /* [in] */ long NumberOfBytes, + /* [retval][out] */ long *BytesRead) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE Write( + /* [in] */ VARIANT Buffer, + /* [retval][out] */ long *BytesWritten) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE Seek( + /* [in] */ VARIANT Position, + /* [defaultvalue][in] */ SpeechStreamSeekPositionType Origin, + /* [retval][out] */ VARIANT *NewPosition) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechBaseStreamVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechBaseStream * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechBaseStream * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechBaseStream * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechBaseStream * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechBaseStream * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechBaseStream * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechBaseStream * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Format )( + ISpeechBaseStream * This, + /* [retval][out] */ ISpeechAudioFormat **AudioFormat); + + /* [id][helpstring][propputref] */ HRESULT ( STDMETHODCALLTYPE *putref_Format )( + ISpeechBaseStream * This, + /* [in] */ ISpeechAudioFormat *AudioFormat); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Read )( + ISpeechBaseStream * This, + /* [out] */ VARIANT *Buffer, + /* [in] */ long NumberOfBytes, + /* [retval][out] */ long *BytesRead); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Write )( + ISpeechBaseStream * This, + /* [in] */ VARIANT Buffer, + /* [retval][out] */ long *BytesWritten); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Seek )( + ISpeechBaseStream * This, + /* [in] */ VARIANT Position, + /* [defaultvalue][in] */ SpeechStreamSeekPositionType Origin, + /* [retval][out] */ VARIANT *NewPosition); + + END_INTERFACE + } ISpeechBaseStreamVtbl; + + interface ISpeechBaseStream + { + CONST_VTBL struct ISpeechBaseStreamVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechBaseStream_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechBaseStream_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechBaseStream_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechBaseStream_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechBaseStream_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechBaseStream_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechBaseStream_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechBaseStream_get_Format(This,AudioFormat) \ + (This)->lpVtbl -> get_Format(This,AudioFormat) + +#define ISpeechBaseStream_putref_Format(This,AudioFormat) \ + (This)->lpVtbl -> putref_Format(This,AudioFormat) + +#define ISpeechBaseStream_Read(This,Buffer,NumberOfBytes,BytesRead) \ + (This)->lpVtbl -> Read(This,Buffer,NumberOfBytes,BytesRead) + +#define ISpeechBaseStream_Write(This,Buffer,BytesWritten) \ + (This)->lpVtbl -> Write(This,Buffer,BytesWritten) + +#define ISpeechBaseStream_Seek(This,Position,Origin,NewPosition) \ + (This)->lpVtbl -> Seek(This,Position,Origin,NewPosition) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechBaseStream_get_Format_Proxy( + ISpeechBaseStream * This, + /* [retval][out] */ ISpeechAudioFormat **AudioFormat); + + +void __RPC_STUB ISpeechBaseStream_get_Format_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propputref] */ HRESULT STDMETHODCALLTYPE ISpeechBaseStream_putref_Format_Proxy( + ISpeechBaseStream * This, + /* [in] */ ISpeechAudioFormat *AudioFormat); + + +void __RPC_STUB ISpeechBaseStream_putref_Format_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechBaseStream_Read_Proxy( + ISpeechBaseStream * This, + /* [out] */ VARIANT *Buffer, + /* [in] */ long NumberOfBytes, + /* [retval][out] */ long *BytesRead); + + +void __RPC_STUB ISpeechBaseStream_Read_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechBaseStream_Write_Proxy( + ISpeechBaseStream * This, + /* [in] */ VARIANT Buffer, + /* [retval][out] */ long *BytesWritten); + + +void __RPC_STUB ISpeechBaseStream_Write_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechBaseStream_Seek_Proxy( + ISpeechBaseStream * This, + /* [in] */ VARIANT Position, + /* [defaultvalue][in] */ SpeechStreamSeekPositionType Origin, + /* [retval][out] */ VARIANT *NewPosition); + + +void __RPC_STUB ISpeechBaseStream_Seek_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechBaseStream_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechFileStream_INTERFACE_DEFINED__ +#define __ISpeechFileStream_INTERFACE_DEFINED__ + +/* interface ISpeechFileStream */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechFileStream; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("AF67F125-AB39-4e93-B4A2-CC2E66E182A7") + ISpeechFileStream : public ISpeechBaseStream + { + public: + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE Open( + /* [in] */ BSTR FileName, + /* [defaultvalue][in] */ SpeechStreamFileMode FileMode = SSFMOpenForRead, + /* [defaultvalue][in] */ VARIANT_BOOL DoEvents = 0) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE Close( void) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechFileStreamVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechFileStream * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechFileStream * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechFileStream * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechFileStream * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechFileStream * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechFileStream * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechFileStream * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Format )( + ISpeechFileStream * This, + /* [retval][out] */ ISpeechAudioFormat **AudioFormat); + + /* [id][helpstring][propputref] */ HRESULT ( STDMETHODCALLTYPE *putref_Format )( + ISpeechFileStream * This, + /* [in] */ ISpeechAudioFormat *AudioFormat); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Read )( + ISpeechFileStream * This, + /* [out] */ VARIANT *Buffer, + /* [in] */ long NumberOfBytes, + /* [retval][out] */ long *BytesRead); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Write )( + ISpeechFileStream * This, + /* [in] */ VARIANT Buffer, + /* [retval][out] */ long *BytesWritten); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Seek )( + ISpeechFileStream * This, + /* [in] */ VARIANT Position, + /* [defaultvalue][in] */ SpeechStreamSeekPositionType Origin, + /* [retval][out] */ VARIANT *NewPosition); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Open )( + ISpeechFileStream * This, + /* [in] */ BSTR FileName, + /* [defaultvalue][in] */ SpeechStreamFileMode FileMode, + /* [defaultvalue][in] */ VARIANT_BOOL DoEvents); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Close )( + ISpeechFileStream * This); + + END_INTERFACE + } ISpeechFileStreamVtbl; + + interface ISpeechFileStream + { + CONST_VTBL struct ISpeechFileStreamVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechFileStream_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechFileStream_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechFileStream_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechFileStream_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechFileStream_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechFileStream_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechFileStream_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechFileStream_get_Format(This,AudioFormat) \ + (This)->lpVtbl -> get_Format(This,AudioFormat) + +#define ISpeechFileStream_putref_Format(This,AudioFormat) \ + (This)->lpVtbl -> putref_Format(This,AudioFormat) + +#define ISpeechFileStream_Read(This,Buffer,NumberOfBytes,BytesRead) \ + (This)->lpVtbl -> Read(This,Buffer,NumberOfBytes,BytesRead) + +#define ISpeechFileStream_Write(This,Buffer,BytesWritten) \ + (This)->lpVtbl -> Write(This,Buffer,BytesWritten) + +#define ISpeechFileStream_Seek(This,Position,Origin,NewPosition) \ + (This)->lpVtbl -> Seek(This,Position,Origin,NewPosition) + + +#define ISpeechFileStream_Open(This,FileName,FileMode,DoEvents) \ + (This)->lpVtbl -> Open(This,FileName,FileMode,DoEvents) + +#define ISpeechFileStream_Close(This) \ + (This)->lpVtbl -> Close(This) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechFileStream_Open_Proxy( + ISpeechFileStream * This, + /* [in] */ BSTR FileName, + /* [defaultvalue][in] */ SpeechStreamFileMode FileMode, + /* [defaultvalue][in] */ VARIANT_BOOL DoEvents); + + +void __RPC_STUB ISpeechFileStream_Open_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechFileStream_Close_Proxy( + ISpeechFileStream * This); + + +void __RPC_STUB ISpeechFileStream_Close_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechFileStream_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechMemoryStream_INTERFACE_DEFINED__ +#define __ISpeechMemoryStream_INTERFACE_DEFINED__ + +/* interface ISpeechMemoryStream */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechMemoryStream; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("EEB14B68-808B-4abe-A5EA-B51DA7588008") + ISpeechMemoryStream : public ISpeechBaseStream + { + public: + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE SetData( + /* [in] */ VARIANT Data) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE GetData( + /* [retval][out] */ VARIANT *pData) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechMemoryStreamVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechMemoryStream * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechMemoryStream * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechMemoryStream * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechMemoryStream * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechMemoryStream * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechMemoryStream * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechMemoryStream * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Format )( + ISpeechMemoryStream * This, + /* [retval][out] */ ISpeechAudioFormat **AudioFormat); + + /* [id][helpstring][propputref] */ HRESULT ( STDMETHODCALLTYPE *putref_Format )( + ISpeechMemoryStream * This, + /* [in] */ ISpeechAudioFormat *AudioFormat); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Read )( + ISpeechMemoryStream * This, + /* [out] */ VARIANT *Buffer, + /* [in] */ long NumberOfBytes, + /* [retval][out] */ long *BytesRead); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Write )( + ISpeechMemoryStream * This, + /* [in] */ VARIANT Buffer, + /* [retval][out] */ long *BytesWritten); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Seek )( + ISpeechMemoryStream * This, + /* [in] */ VARIANT Position, + /* [defaultvalue][in] */ SpeechStreamSeekPositionType Origin, + /* [retval][out] */ VARIANT *NewPosition); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *SetData )( + ISpeechMemoryStream * This, + /* [in] */ VARIANT Data); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetData )( + ISpeechMemoryStream * This, + /* [retval][out] */ VARIANT *pData); + + END_INTERFACE + } ISpeechMemoryStreamVtbl; + + interface ISpeechMemoryStream + { + CONST_VTBL struct ISpeechMemoryStreamVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechMemoryStream_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechMemoryStream_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechMemoryStream_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechMemoryStream_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechMemoryStream_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechMemoryStream_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechMemoryStream_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechMemoryStream_get_Format(This,AudioFormat) \ + (This)->lpVtbl -> get_Format(This,AudioFormat) + +#define ISpeechMemoryStream_putref_Format(This,AudioFormat) \ + (This)->lpVtbl -> putref_Format(This,AudioFormat) + +#define ISpeechMemoryStream_Read(This,Buffer,NumberOfBytes,BytesRead) \ + (This)->lpVtbl -> Read(This,Buffer,NumberOfBytes,BytesRead) + +#define ISpeechMemoryStream_Write(This,Buffer,BytesWritten) \ + (This)->lpVtbl -> Write(This,Buffer,BytesWritten) + +#define ISpeechMemoryStream_Seek(This,Position,Origin,NewPosition) \ + (This)->lpVtbl -> Seek(This,Position,Origin,NewPosition) + + +#define ISpeechMemoryStream_SetData(This,Data) \ + (This)->lpVtbl -> SetData(This,Data) + +#define ISpeechMemoryStream_GetData(This,pData) \ + (This)->lpVtbl -> GetData(This,pData) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechMemoryStream_SetData_Proxy( + ISpeechMemoryStream * This, + /* [in] */ VARIANT Data); + + +void __RPC_STUB ISpeechMemoryStream_SetData_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechMemoryStream_GetData_Proxy( + ISpeechMemoryStream * This, + /* [retval][out] */ VARIANT *pData); + + +void __RPC_STUB ISpeechMemoryStream_GetData_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechMemoryStream_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechCustomStream_INTERFACE_DEFINED__ +#define __ISpeechCustomStream_INTERFACE_DEFINED__ + +/* interface ISpeechCustomStream */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechCustomStream; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("1A9E9F4F-104F-4db8-A115-EFD7FD0C97AE") + ISpeechCustomStream : public ISpeechBaseStream + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_BaseStream( + /* [retval][out] */ IUnknown **ppUnkStream) = 0; + + virtual /* [id][helpstring][propputref] */ HRESULT STDMETHODCALLTYPE putref_BaseStream( + /* [in] */ IUnknown *pUnkStream) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechCustomStreamVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechCustomStream * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechCustomStream * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechCustomStream * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechCustomStream * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechCustomStream * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechCustomStream * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechCustomStream * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Format )( + ISpeechCustomStream * This, + /* [retval][out] */ ISpeechAudioFormat **AudioFormat); + + /* [id][helpstring][propputref] */ HRESULT ( STDMETHODCALLTYPE *putref_Format )( + ISpeechCustomStream * This, + /* [in] */ ISpeechAudioFormat *AudioFormat); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Read )( + ISpeechCustomStream * This, + /* [out] */ VARIANT *Buffer, + /* [in] */ long NumberOfBytes, + /* [retval][out] */ long *BytesRead); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Write )( + ISpeechCustomStream * This, + /* [in] */ VARIANT Buffer, + /* [retval][out] */ long *BytesWritten); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Seek )( + ISpeechCustomStream * This, + /* [in] */ VARIANT Position, + /* [defaultvalue][in] */ SpeechStreamSeekPositionType Origin, + /* [retval][out] */ VARIANT *NewPosition); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_BaseStream )( + ISpeechCustomStream * This, + /* [retval][out] */ IUnknown **ppUnkStream); + + /* [id][helpstring][propputref] */ HRESULT ( STDMETHODCALLTYPE *putref_BaseStream )( + ISpeechCustomStream * This, + /* [in] */ IUnknown *pUnkStream); + + END_INTERFACE + } ISpeechCustomStreamVtbl; + + interface ISpeechCustomStream + { + CONST_VTBL struct ISpeechCustomStreamVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechCustomStream_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechCustomStream_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechCustomStream_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechCustomStream_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechCustomStream_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechCustomStream_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechCustomStream_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechCustomStream_get_Format(This,AudioFormat) \ + (This)->lpVtbl -> get_Format(This,AudioFormat) + +#define ISpeechCustomStream_putref_Format(This,AudioFormat) \ + (This)->lpVtbl -> putref_Format(This,AudioFormat) + +#define ISpeechCustomStream_Read(This,Buffer,NumberOfBytes,BytesRead) \ + (This)->lpVtbl -> Read(This,Buffer,NumberOfBytes,BytesRead) + +#define ISpeechCustomStream_Write(This,Buffer,BytesWritten) \ + (This)->lpVtbl -> Write(This,Buffer,BytesWritten) + +#define ISpeechCustomStream_Seek(This,Position,Origin,NewPosition) \ + (This)->lpVtbl -> Seek(This,Position,Origin,NewPosition) + + +#define ISpeechCustomStream_get_BaseStream(This,ppUnkStream) \ + (This)->lpVtbl -> get_BaseStream(This,ppUnkStream) + +#define ISpeechCustomStream_putref_BaseStream(This,pUnkStream) \ + (This)->lpVtbl -> putref_BaseStream(This,pUnkStream) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechCustomStream_get_BaseStream_Proxy( + ISpeechCustomStream * This, + /* [retval][out] */ IUnknown **ppUnkStream); + + +void __RPC_STUB ISpeechCustomStream_get_BaseStream_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propputref] */ HRESULT STDMETHODCALLTYPE ISpeechCustomStream_putref_BaseStream_Proxy( + ISpeechCustomStream * This, + /* [in] */ IUnknown *pUnkStream); + + +void __RPC_STUB ISpeechCustomStream_putref_BaseStream_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechCustomStream_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechAudio_INTERFACE_DEFINED__ +#define __ISpeechAudio_INTERFACE_DEFINED__ + +/* interface ISpeechAudio */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechAudio; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("CFF8E175-019E-11d3-A08E-00C04F8EF9B5") + ISpeechAudio : public ISpeechBaseStream + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Status( + /* [retval][out] */ ISpeechAudioStatus **Status) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_BufferInfo( + /* [retval][out] */ ISpeechAudioBufferInfo **BufferInfo) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_DefaultFormat( + /* [retval][out] */ ISpeechAudioFormat **StreamFormat) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Volume( + /* [retval][out] */ long *Volume) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_Volume( + /* [in] */ long Volume) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_BufferNotifySize( + /* [retval][out] */ long *BufferNotifySize) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_BufferNotifySize( + /* [in] */ long BufferNotifySize) = 0; + + virtual /* [id][helpstring][hidden][propget] */ HRESULT STDMETHODCALLTYPE get_EventHandle( + /* [retval][out] */ long *EventHandle) = 0; + + virtual /* [hidden][id][helpstring] */ HRESULT STDMETHODCALLTYPE SetState( + /* [in] */ SpeechAudioState State) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechAudioVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechAudio * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechAudio * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechAudio * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechAudio * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechAudio * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechAudio * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechAudio * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Format )( + ISpeechAudio * This, + /* [retval][out] */ ISpeechAudioFormat **AudioFormat); + + /* [id][helpstring][propputref] */ HRESULT ( STDMETHODCALLTYPE *putref_Format )( + ISpeechAudio * This, + /* [in] */ ISpeechAudioFormat *AudioFormat); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Read )( + ISpeechAudio * This, + /* [out] */ VARIANT *Buffer, + /* [in] */ long NumberOfBytes, + /* [retval][out] */ long *BytesRead); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Write )( + ISpeechAudio * This, + /* [in] */ VARIANT Buffer, + /* [retval][out] */ long *BytesWritten); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Seek )( + ISpeechAudio * This, + /* [in] */ VARIANT Position, + /* [defaultvalue][in] */ SpeechStreamSeekPositionType Origin, + /* [retval][out] */ VARIANT *NewPosition); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Status )( + ISpeechAudio * This, + /* [retval][out] */ ISpeechAudioStatus **Status); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_BufferInfo )( + ISpeechAudio * This, + /* [retval][out] */ ISpeechAudioBufferInfo **BufferInfo); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_DefaultFormat )( + ISpeechAudio * This, + /* [retval][out] */ ISpeechAudioFormat **StreamFormat); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Volume )( + ISpeechAudio * This, + /* [retval][out] */ long *Volume); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_Volume )( + ISpeechAudio * This, + /* [in] */ long Volume); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_BufferNotifySize )( + ISpeechAudio * This, + /* [retval][out] */ long *BufferNotifySize); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_BufferNotifySize )( + ISpeechAudio * This, + /* [in] */ long BufferNotifySize); + + /* [id][helpstring][hidden][propget] */ HRESULT ( STDMETHODCALLTYPE *get_EventHandle )( + ISpeechAudio * This, + /* [retval][out] */ long *EventHandle); + + /* [hidden][id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *SetState )( + ISpeechAudio * This, + /* [in] */ SpeechAudioState State); + + END_INTERFACE + } ISpeechAudioVtbl; + + interface ISpeechAudio + { + CONST_VTBL struct ISpeechAudioVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechAudio_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechAudio_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechAudio_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechAudio_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechAudio_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechAudio_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechAudio_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechAudio_get_Format(This,AudioFormat) \ + (This)->lpVtbl -> get_Format(This,AudioFormat) + +#define ISpeechAudio_putref_Format(This,AudioFormat) \ + (This)->lpVtbl -> putref_Format(This,AudioFormat) + +#define ISpeechAudio_Read(This,Buffer,NumberOfBytes,BytesRead) \ + (This)->lpVtbl -> Read(This,Buffer,NumberOfBytes,BytesRead) + +#define ISpeechAudio_Write(This,Buffer,BytesWritten) \ + (This)->lpVtbl -> Write(This,Buffer,BytesWritten) + +#define ISpeechAudio_Seek(This,Position,Origin,NewPosition) \ + (This)->lpVtbl -> Seek(This,Position,Origin,NewPosition) + + +#define ISpeechAudio_get_Status(This,Status) \ + (This)->lpVtbl -> get_Status(This,Status) + +#define ISpeechAudio_get_BufferInfo(This,BufferInfo) \ + (This)->lpVtbl -> get_BufferInfo(This,BufferInfo) + +#define ISpeechAudio_get_DefaultFormat(This,StreamFormat) \ + (This)->lpVtbl -> get_DefaultFormat(This,StreamFormat) + +#define ISpeechAudio_get_Volume(This,Volume) \ + (This)->lpVtbl -> get_Volume(This,Volume) + +#define ISpeechAudio_put_Volume(This,Volume) \ + (This)->lpVtbl -> put_Volume(This,Volume) + +#define ISpeechAudio_get_BufferNotifySize(This,BufferNotifySize) \ + (This)->lpVtbl -> get_BufferNotifySize(This,BufferNotifySize) + +#define ISpeechAudio_put_BufferNotifySize(This,BufferNotifySize) \ + (This)->lpVtbl -> put_BufferNotifySize(This,BufferNotifySize) + +#define ISpeechAudio_get_EventHandle(This,EventHandle) \ + (This)->lpVtbl -> get_EventHandle(This,EventHandle) + +#define ISpeechAudio_SetState(This,State) \ + (This)->lpVtbl -> SetState(This,State) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechAudio_get_Status_Proxy( + ISpeechAudio * This, + /* [retval][out] */ ISpeechAudioStatus **Status); + + +void __RPC_STUB ISpeechAudio_get_Status_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechAudio_get_BufferInfo_Proxy( + ISpeechAudio * This, + /* [retval][out] */ ISpeechAudioBufferInfo **BufferInfo); + + +void __RPC_STUB ISpeechAudio_get_BufferInfo_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechAudio_get_DefaultFormat_Proxy( + ISpeechAudio * This, + /* [retval][out] */ ISpeechAudioFormat **StreamFormat); + + +void __RPC_STUB ISpeechAudio_get_DefaultFormat_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechAudio_get_Volume_Proxy( + ISpeechAudio * This, + /* [retval][out] */ long *Volume); + + +void __RPC_STUB ISpeechAudio_get_Volume_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechAudio_put_Volume_Proxy( + ISpeechAudio * This, + /* [in] */ long Volume); + + +void __RPC_STUB ISpeechAudio_put_Volume_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechAudio_get_BufferNotifySize_Proxy( + ISpeechAudio * This, + /* [retval][out] */ long *BufferNotifySize); + + +void __RPC_STUB ISpeechAudio_get_BufferNotifySize_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechAudio_put_BufferNotifySize_Proxy( + ISpeechAudio * This, + /* [in] */ long BufferNotifySize); + + +void __RPC_STUB ISpeechAudio_put_BufferNotifySize_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][hidden][propget] */ HRESULT STDMETHODCALLTYPE ISpeechAudio_get_EventHandle_Proxy( + ISpeechAudio * This, + /* [retval][out] */ long *EventHandle); + + +void __RPC_STUB ISpeechAudio_get_EventHandle_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [hidden][id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechAudio_SetState_Proxy( + ISpeechAudio * This, + /* [in] */ SpeechAudioState State); + + +void __RPC_STUB ISpeechAudio_SetState_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechAudio_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechMMSysAudio_INTERFACE_DEFINED__ +#define __ISpeechMMSysAudio_INTERFACE_DEFINED__ + +/* interface ISpeechMMSysAudio */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechMMSysAudio; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("3C76AF6D-1FD7-4831-81D1-3B71D5A13C44") + ISpeechMMSysAudio : public ISpeechAudio + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_DeviceId( + /* [retval][out] */ long *DeviceId) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_DeviceId( + /* [in] */ long DeviceId) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_LineId( + /* [retval][out] */ long *LineId) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_LineId( + /* [in] */ long LineId) = 0; + + virtual /* [id][helpstring][hidden][propget] */ HRESULT STDMETHODCALLTYPE get_MMHandle( + /* [retval][out] */ long *Handle) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechMMSysAudioVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechMMSysAudio * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechMMSysAudio * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechMMSysAudio * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechMMSysAudio * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechMMSysAudio * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechMMSysAudio * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechMMSysAudio * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Format )( + ISpeechMMSysAudio * This, + /* [retval][out] */ ISpeechAudioFormat **AudioFormat); + + /* [id][helpstring][propputref] */ HRESULT ( STDMETHODCALLTYPE *putref_Format )( + ISpeechMMSysAudio * This, + /* [in] */ ISpeechAudioFormat *AudioFormat); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Read )( + ISpeechMMSysAudio * This, + /* [out] */ VARIANT *Buffer, + /* [in] */ long NumberOfBytes, + /* [retval][out] */ long *BytesRead); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Write )( + ISpeechMMSysAudio * This, + /* [in] */ VARIANT Buffer, + /* [retval][out] */ long *BytesWritten); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Seek )( + ISpeechMMSysAudio * This, + /* [in] */ VARIANT Position, + /* [defaultvalue][in] */ SpeechStreamSeekPositionType Origin, + /* [retval][out] */ VARIANT *NewPosition); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Status )( + ISpeechMMSysAudio * This, + /* [retval][out] */ ISpeechAudioStatus **Status); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_BufferInfo )( + ISpeechMMSysAudio * This, + /* [retval][out] */ ISpeechAudioBufferInfo **BufferInfo); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_DefaultFormat )( + ISpeechMMSysAudio * This, + /* [retval][out] */ ISpeechAudioFormat **StreamFormat); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Volume )( + ISpeechMMSysAudio * This, + /* [retval][out] */ long *Volume); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_Volume )( + ISpeechMMSysAudio * This, + /* [in] */ long Volume); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_BufferNotifySize )( + ISpeechMMSysAudio * This, + /* [retval][out] */ long *BufferNotifySize); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_BufferNotifySize )( + ISpeechMMSysAudio * This, + /* [in] */ long BufferNotifySize); + + /* [id][helpstring][hidden][propget] */ HRESULT ( STDMETHODCALLTYPE *get_EventHandle )( + ISpeechMMSysAudio * This, + /* [retval][out] */ long *EventHandle); + + /* [hidden][id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *SetState )( + ISpeechMMSysAudio * This, + /* [in] */ SpeechAudioState State); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_DeviceId )( + ISpeechMMSysAudio * This, + /* [retval][out] */ long *DeviceId); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_DeviceId )( + ISpeechMMSysAudio * This, + /* [in] */ long DeviceId); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_LineId )( + ISpeechMMSysAudio * This, + /* [retval][out] */ long *LineId); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_LineId )( + ISpeechMMSysAudio * This, + /* [in] */ long LineId); + + /* [id][helpstring][hidden][propget] */ HRESULT ( STDMETHODCALLTYPE *get_MMHandle )( + ISpeechMMSysAudio * This, + /* [retval][out] */ long *Handle); + + END_INTERFACE + } ISpeechMMSysAudioVtbl; + + interface ISpeechMMSysAudio + { + CONST_VTBL struct ISpeechMMSysAudioVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechMMSysAudio_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechMMSysAudio_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechMMSysAudio_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechMMSysAudio_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechMMSysAudio_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechMMSysAudio_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechMMSysAudio_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechMMSysAudio_get_Format(This,AudioFormat) \ + (This)->lpVtbl -> get_Format(This,AudioFormat) + +#define ISpeechMMSysAudio_putref_Format(This,AudioFormat) \ + (This)->lpVtbl -> putref_Format(This,AudioFormat) + +#define ISpeechMMSysAudio_Read(This,Buffer,NumberOfBytes,BytesRead) \ + (This)->lpVtbl -> Read(This,Buffer,NumberOfBytes,BytesRead) + +#define ISpeechMMSysAudio_Write(This,Buffer,BytesWritten) \ + (This)->lpVtbl -> Write(This,Buffer,BytesWritten) + +#define ISpeechMMSysAudio_Seek(This,Position,Origin,NewPosition) \ + (This)->lpVtbl -> Seek(This,Position,Origin,NewPosition) + + +#define ISpeechMMSysAudio_get_Status(This,Status) \ + (This)->lpVtbl -> get_Status(This,Status) + +#define ISpeechMMSysAudio_get_BufferInfo(This,BufferInfo) \ + (This)->lpVtbl -> get_BufferInfo(This,BufferInfo) + +#define ISpeechMMSysAudio_get_DefaultFormat(This,StreamFormat) \ + (This)->lpVtbl -> get_DefaultFormat(This,StreamFormat) + +#define ISpeechMMSysAudio_get_Volume(This,Volume) \ + (This)->lpVtbl -> get_Volume(This,Volume) + +#define ISpeechMMSysAudio_put_Volume(This,Volume) \ + (This)->lpVtbl -> put_Volume(This,Volume) + +#define ISpeechMMSysAudio_get_BufferNotifySize(This,BufferNotifySize) \ + (This)->lpVtbl -> get_BufferNotifySize(This,BufferNotifySize) + +#define ISpeechMMSysAudio_put_BufferNotifySize(This,BufferNotifySize) \ + (This)->lpVtbl -> put_BufferNotifySize(This,BufferNotifySize) + +#define ISpeechMMSysAudio_get_EventHandle(This,EventHandle) \ + (This)->lpVtbl -> get_EventHandle(This,EventHandle) + +#define ISpeechMMSysAudio_SetState(This,State) \ + (This)->lpVtbl -> SetState(This,State) + + +#define ISpeechMMSysAudio_get_DeviceId(This,DeviceId) \ + (This)->lpVtbl -> get_DeviceId(This,DeviceId) + +#define ISpeechMMSysAudio_put_DeviceId(This,DeviceId) \ + (This)->lpVtbl -> put_DeviceId(This,DeviceId) + +#define ISpeechMMSysAudio_get_LineId(This,LineId) \ + (This)->lpVtbl -> get_LineId(This,LineId) + +#define ISpeechMMSysAudio_put_LineId(This,LineId) \ + (This)->lpVtbl -> put_LineId(This,LineId) + +#define ISpeechMMSysAudio_get_MMHandle(This,Handle) \ + (This)->lpVtbl -> get_MMHandle(This,Handle) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechMMSysAudio_get_DeviceId_Proxy( + ISpeechMMSysAudio * This, + /* [retval][out] */ long *DeviceId); + + +void __RPC_STUB ISpeechMMSysAudio_get_DeviceId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechMMSysAudio_put_DeviceId_Proxy( + ISpeechMMSysAudio * This, + /* [in] */ long DeviceId); + + +void __RPC_STUB ISpeechMMSysAudio_put_DeviceId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechMMSysAudio_get_LineId_Proxy( + ISpeechMMSysAudio * This, + /* [retval][out] */ long *LineId); + + +void __RPC_STUB ISpeechMMSysAudio_get_LineId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechMMSysAudio_put_LineId_Proxy( + ISpeechMMSysAudio * This, + /* [in] */ long LineId); + + +void __RPC_STUB ISpeechMMSysAudio_put_LineId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][hidden][propget] */ HRESULT STDMETHODCALLTYPE ISpeechMMSysAudio_get_MMHandle_Proxy( + ISpeechMMSysAudio * This, + /* [retval][out] */ long *Handle); + + +void __RPC_STUB ISpeechMMSysAudio_get_MMHandle_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechMMSysAudio_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechVoice_INTERFACE_DEFINED__ +#define __ISpeechVoice_INTERFACE_DEFINED__ + +/* interface ISpeechVoice */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechVoice; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("269316D8-57BD-11D2-9EEE-00C04F797396") + ISpeechVoice : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Status( + /* [retval][out] */ ISpeechVoiceStatus **Status) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Voice( + /* [retval][out] */ ISpeechObjectToken **Voice) = 0; + + virtual /* [id][helpstring][propputref] */ HRESULT STDMETHODCALLTYPE putref_Voice( + /* [in] */ ISpeechObjectToken *Voice) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_AudioOutput( + /* [retval][out] */ ISpeechObjectToken **AudioOutput) = 0; + + virtual /* [id][helpstring][propputref] */ HRESULT STDMETHODCALLTYPE putref_AudioOutput( + /* [in] */ ISpeechObjectToken *AudioOutput) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_AudioOutputStream( + /* [retval][out] */ ISpeechBaseStream **AudioOutputStream) = 0; + + virtual /* [id][helpstring][propputref] */ HRESULT STDMETHODCALLTYPE putref_AudioOutputStream( + /* [in] */ ISpeechBaseStream *AudioOutputStream) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Rate( + /* [retval][out] */ long *Rate) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_Rate( + /* [in] */ long Rate) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Volume( + /* [retval][out] */ long *Volume) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_Volume( + /* [in] */ long Volume) = 0; + + virtual /* [id][helpstring][hidden][propput] */ HRESULT STDMETHODCALLTYPE put_AllowAudioOutputFormatChangesOnNextSet( + /* [in] */ VARIANT_BOOL Allow) = 0; + + virtual /* [id][helpstring][hidden][propget] */ HRESULT STDMETHODCALLTYPE get_AllowAudioOutputFormatChangesOnNextSet( + /* [retval][out] */ VARIANT_BOOL *Allow) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_EventInterests( + /* [retval][out] */ SpeechVoiceEvents *EventInterestFlags) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_EventInterests( + /* [in] */ SpeechVoiceEvents EventInterestFlags) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_Priority( + /* [in] */ SpeechVoicePriority Priority) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Priority( + /* [retval][out] */ SpeechVoicePriority *Priority) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_AlertBoundary( + /* [in] */ SpeechVoiceEvents Boundary) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_AlertBoundary( + /* [retval][out] */ SpeechVoiceEvents *Boundary) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_SynchronousSpeakTimeout( + /* [in] */ long msTimeout) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_SynchronousSpeakTimeout( + /* [retval][out] */ long *msTimeout) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE Speak( + /* [in] */ BSTR Text, + /* [defaultvalue][in] */ SpeechVoiceSpeakFlags Flags, + /* [retval][out] */ long *StreamNumber) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE SpeakStream( + /* [in] */ ISpeechBaseStream *Stream, + /* [defaultvalue][in] */ SpeechVoiceSpeakFlags Flags, + /* [retval][out] */ long *StreamNumber) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE Pause( void) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE Resume( void) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE Skip( + /* [in] */ const BSTR Type, + /* [in] */ long NumItems, + /* [retval][out] */ long *NumSkipped) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE GetVoices( + /* [defaultvalue][in] */ BSTR RequiredAttributes, + /* [defaultvalue][in] */ BSTR OptionalAttributes, + /* [retval][out] */ ISpeechObjectTokens **ObjectTokens) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE GetAudioOutputs( + /* [defaultvalue][in] */ BSTR RequiredAttributes, + /* [defaultvalue][in] */ BSTR OptionalAttributes, + /* [retval][out] */ ISpeechObjectTokens **ObjectTokens) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE WaitUntilDone( + /* [in] */ long msTimeout, + /* [retval][out] */ VARIANT_BOOL *Done) = 0; + + virtual /* [id][hidden][helpstring] */ HRESULT STDMETHODCALLTYPE SpeakCompleteEvent( + /* [retval][out] */ long *Handle) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE IsUISupported( + /* [in] */ const BSTR TypeOfUI, + /* [defaultvalue][in] */ const VARIANT *ExtraData, + /* [retval][out] */ VARIANT_BOOL *Supported) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE DisplayUI( + /* [in] */ long hWndParent, + /* [in] */ BSTR Title, + /* [in] */ const BSTR TypeOfUI, + /* [defaultvalue][in] */ const VARIANT *ExtraData = 0) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechVoiceVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechVoice * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechVoice * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechVoice * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechVoice * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechVoice * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechVoice * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechVoice * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Status )( + ISpeechVoice * This, + /* [retval][out] */ ISpeechVoiceStatus **Status); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Voice )( + ISpeechVoice * This, + /* [retval][out] */ ISpeechObjectToken **Voice); + + /* [id][helpstring][propputref] */ HRESULT ( STDMETHODCALLTYPE *putref_Voice )( + ISpeechVoice * This, + /* [in] */ ISpeechObjectToken *Voice); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_AudioOutput )( + ISpeechVoice * This, + /* [retval][out] */ ISpeechObjectToken **AudioOutput); + + /* [id][helpstring][propputref] */ HRESULT ( STDMETHODCALLTYPE *putref_AudioOutput )( + ISpeechVoice * This, + /* [in] */ ISpeechObjectToken *AudioOutput); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_AudioOutputStream )( + ISpeechVoice * This, + /* [retval][out] */ ISpeechBaseStream **AudioOutputStream); + + /* [id][helpstring][propputref] */ HRESULT ( STDMETHODCALLTYPE *putref_AudioOutputStream )( + ISpeechVoice * This, + /* [in] */ ISpeechBaseStream *AudioOutputStream); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Rate )( + ISpeechVoice * This, + /* [retval][out] */ long *Rate); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_Rate )( + ISpeechVoice * This, + /* [in] */ long Rate); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Volume )( + ISpeechVoice * This, + /* [retval][out] */ long *Volume); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_Volume )( + ISpeechVoice * This, + /* [in] */ long Volume); + + /* [id][helpstring][hidden][propput] */ HRESULT ( STDMETHODCALLTYPE *put_AllowAudioOutputFormatChangesOnNextSet )( + ISpeechVoice * This, + /* [in] */ VARIANT_BOOL Allow); + + /* [id][helpstring][hidden][propget] */ HRESULT ( STDMETHODCALLTYPE *get_AllowAudioOutputFormatChangesOnNextSet )( + ISpeechVoice * This, + /* [retval][out] */ VARIANT_BOOL *Allow); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_EventInterests )( + ISpeechVoice * This, + /* [retval][out] */ SpeechVoiceEvents *EventInterestFlags); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_EventInterests )( + ISpeechVoice * This, + /* [in] */ SpeechVoiceEvents EventInterestFlags); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_Priority )( + ISpeechVoice * This, + /* [in] */ SpeechVoicePriority Priority); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Priority )( + ISpeechVoice * This, + /* [retval][out] */ SpeechVoicePriority *Priority); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_AlertBoundary )( + ISpeechVoice * This, + /* [in] */ SpeechVoiceEvents Boundary); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_AlertBoundary )( + ISpeechVoice * This, + /* [retval][out] */ SpeechVoiceEvents *Boundary); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_SynchronousSpeakTimeout )( + ISpeechVoice * This, + /* [in] */ long msTimeout); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_SynchronousSpeakTimeout )( + ISpeechVoice * This, + /* [retval][out] */ long *msTimeout); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Speak )( + ISpeechVoice * This, + /* [in] */ BSTR Text, + /* [defaultvalue][in] */ SpeechVoiceSpeakFlags Flags, + /* [retval][out] */ long *StreamNumber); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *SpeakStream )( + ISpeechVoice * This, + /* [in] */ ISpeechBaseStream *Stream, + /* [defaultvalue][in] */ SpeechVoiceSpeakFlags Flags, + /* [retval][out] */ long *StreamNumber); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Pause )( + ISpeechVoice * This); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Resume )( + ISpeechVoice * This); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Skip )( + ISpeechVoice * This, + /* [in] */ const BSTR Type, + /* [in] */ long NumItems, + /* [retval][out] */ long *NumSkipped); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetVoices )( + ISpeechVoice * This, + /* [defaultvalue][in] */ BSTR RequiredAttributes, + /* [defaultvalue][in] */ BSTR OptionalAttributes, + /* [retval][out] */ ISpeechObjectTokens **ObjectTokens); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetAudioOutputs )( + ISpeechVoice * This, + /* [defaultvalue][in] */ BSTR RequiredAttributes, + /* [defaultvalue][in] */ BSTR OptionalAttributes, + /* [retval][out] */ ISpeechObjectTokens **ObjectTokens); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *WaitUntilDone )( + ISpeechVoice * This, + /* [in] */ long msTimeout, + /* [retval][out] */ VARIANT_BOOL *Done); + + /* [id][hidden][helpstring] */ HRESULT ( STDMETHODCALLTYPE *SpeakCompleteEvent )( + ISpeechVoice * This, + /* [retval][out] */ long *Handle); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *IsUISupported )( + ISpeechVoice * This, + /* [in] */ const BSTR TypeOfUI, + /* [defaultvalue][in] */ const VARIANT *ExtraData, + /* [retval][out] */ VARIANT_BOOL *Supported); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *DisplayUI )( + ISpeechVoice * This, + /* [in] */ long hWndParent, + /* [in] */ BSTR Title, + /* [in] */ const BSTR TypeOfUI, + /* [defaultvalue][in] */ const VARIANT *ExtraData); + + END_INTERFACE + } ISpeechVoiceVtbl; + + interface ISpeechVoice + { + CONST_VTBL struct ISpeechVoiceVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechVoice_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechVoice_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechVoice_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechVoice_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechVoice_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechVoice_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechVoice_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechVoice_get_Status(This,Status) \ + (This)->lpVtbl -> get_Status(This,Status) + +#define ISpeechVoice_get_Voice(This,Voice) \ + (This)->lpVtbl -> get_Voice(This,Voice) + +#define ISpeechVoice_putref_Voice(This,Voice) \ + (This)->lpVtbl -> putref_Voice(This,Voice) + +#define ISpeechVoice_get_AudioOutput(This,AudioOutput) \ + (This)->lpVtbl -> get_AudioOutput(This,AudioOutput) + +#define ISpeechVoice_putref_AudioOutput(This,AudioOutput) \ + (This)->lpVtbl -> putref_AudioOutput(This,AudioOutput) + +#define ISpeechVoice_get_AudioOutputStream(This,AudioOutputStream) \ + (This)->lpVtbl -> get_AudioOutputStream(This,AudioOutputStream) + +#define ISpeechVoice_putref_AudioOutputStream(This,AudioOutputStream) \ + (This)->lpVtbl -> putref_AudioOutputStream(This,AudioOutputStream) + +#define ISpeechVoice_get_Rate(This,Rate) \ + (This)->lpVtbl -> get_Rate(This,Rate) + +#define ISpeechVoice_put_Rate(This,Rate) \ + (This)->lpVtbl -> put_Rate(This,Rate) + +#define ISpeechVoice_get_Volume(This,Volume) \ + (This)->lpVtbl -> get_Volume(This,Volume) + +#define ISpeechVoice_put_Volume(This,Volume) \ + (This)->lpVtbl -> put_Volume(This,Volume) + +#define ISpeechVoice_put_AllowAudioOutputFormatChangesOnNextSet(This,Allow) \ + (This)->lpVtbl -> put_AllowAudioOutputFormatChangesOnNextSet(This,Allow) + +#define ISpeechVoice_get_AllowAudioOutputFormatChangesOnNextSet(This,Allow) \ + (This)->lpVtbl -> get_AllowAudioOutputFormatChangesOnNextSet(This,Allow) + +#define ISpeechVoice_get_EventInterests(This,EventInterestFlags) \ + (This)->lpVtbl -> get_EventInterests(This,EventInterestFlags) + +#define ISpeechVoice_put_EventInterests(This,EventInterestFlags) \ + (This)->lpVtbl -> put_EventInterests(This,EventInterestFlags) + +#define ISpeechVoice_put_Priority(This,Priority) \ + (This)->lpVtbl -> put_Priority(This,Priority) + +#define ISpeechVoice_get_Priority(This,Priority) \ + (This)->lpVtbl -> get_Priority(This,Priority) + +#define ISpeechVoice_put_AlertBoundary(This,Boundary) \ + (This)->lpVtbl -> put_AlertBoundary(This,Boundary) + +#define ISpeechVoice_get_AlertBoundary(This,Boundary) \ + (This)->lpVtbl -> get_AlertBoundary(This,Boundary) + +#define ISpeechVoice_put_SynchronousSpeakTimeout(This,msTimeout) \ + (This)->lpVtbl -> put_SynchronousSpeakTimeout(This,msTimeout) + +#define ISpeechVoice_get_SynchronousSpeakTimeout(This,msTimeout) \ + (This)->lpVtbl -> get_SynchronousSpeakTimeout(This,msTimeout) + +#define ISpeechVoice_Speak(This,Text,Flags,StreamNumber) \ + (This)->lpVtbl -> Speak(This,Text,Flags,StreamNumber) + +#define ISpeechVoice_SpeakStream(This,Stream,Flags,StreamNumber) \ + (This)->lpVtbl -> SpeakStream(This,Stream,Flags,StreamNumber) + +#define ISpeechVoice_Pause(This) \ + (This)->lpVtbl -> Pause(This) + +#define ISpeechVoice_Resume(This) \ + (This)->lpVtbl -> Resume(This) + +#define ISpeechVoice_Skip(This,Type,NumItems,NumSkipped) \ + (This)->lpVtbl -> Skip(This,Type,NumItems,NumSkipped) + +#define ISpeechVoice_GetVoices(This,RequiredAttributes,OptionalAttributes,ObjectTokens) \ + (This)->lpVtbl -> GetVoices(This,RequiredAttributes,OptionalAttributes,ObjectTokens) + +#define ISpeechVoice_GetAudioOutputs(This,RequiredAttributes,OptionalAttributes,ObjectTokens) \ + (This)->lpVtbl -> GetAudioOutputs(This,RequiredAttributes,OptionalAttributes,ObjectTokens) + +#define ISpeechVoice_WaitUntilDone(This,msTimeout,Done) \ + (This)->lpVtbl -> WaitUntilDone(This,msTimeout,Done) + +#define ISpeechVoice_SpeakCompleteEvent(This,Handle) \ + (This)->lpVtbl -> SpeakCompleteEvent(This,Handle) + +#define ISpeechVoice_IsUISupported(This,TypeOfUI,ExtraData,Supported) \ + (This)->lpVtbl -> IsUISupported(This,TypeOfUI,ExtraData,Supported) + +#define ISpeechVoice_DisplayUI(This,hWndParent,Title,TypeOfUI,ExtraData) \ + (This)->lpVtbl -> DisplayUI(This,hWndParent,Title,TypeOfUI,ExtraData) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_get_Status_Proxy( + ISpeechVoice * This, + /* [retval][out] */ ISpeechVoiceStatus **Status); + + +void __RPC_STUB ISpeechVoice_get_Status_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_get_Voice_Proxy( + ISpeechVoice * This, + /* [retval][out] */ ISpeechObjectToken **Voice); + + +void __RPC_STUB ISpeechVoice_get_Voice_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propputref] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_putref_Voice_Proxy( + ISpeechVoice * This, + /* [in] */ ISpeechObjectToken *Voice); + + +void __RPC_STUB ISpeechVoice_putref_Voice_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_get_AudioOutput_Proxy( + ISpeechVoice * This, + /* [retval][out] */ ISpeechObjectToken **AudioOutput); + + +void __RPC_STUB ISpeechVoice_get_AudioOutput_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propputref] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_putref_AudioOutput_Proxy( + ISpeechVoice * This, + /* [in] */ ISpeechObjectToken *AudioOutput); + + +void __RPC_STUB ISpeechVoice_putref_AudioOutput_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_get_AudioOutputStream_Proxy( + ISpeechVoice * This, + /* [retval][out] */ ISpeechBaseStream **AudioOutputStream); + + +void __RPC_STUB ISpeechVoice_get_AudioOutputStream_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propputref] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_putref_AudioOutputStream_Proxy( + ISpeechVoice * This, + /* [in] */ ISpeechBaseStream *AudioOutputStream); + + +void __RPC_STUB ISpeechVoice_putref_AudioOutputStream_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_get_Rate_Proxy( + ISpeechVoice * This, + /* [retval][out] */ long *Rate); + + +void __RPC_STUB ISpeechVoice_get_Rate_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_put_Rate_Proxy( + ISpeechVoice * This, + /* [in] */ long Rate); + + +void __RPC_STUB ISpeechVoice_put_Rate_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_get_Volume_Proxy( + ISpeechVoice * This, + /* [retval][out] */ long *Volume); + + +void __RPC_STUB ISpeechVoice_get_Volume_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_put_Volume_Proxy( + ISpeechVoice * This, + /* [in] */ long Volume); + + +void __RPC_STUB ISpeechVoice_put_Volume_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][hidden][propput] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_put_AllowAudioOutputFormatChangesOnNextSet_Proxy( + ISpeechVoice * This, + /* [in] */ VARIANT_BOOL Allow); + + +void __RPC_STUB ISpeechVoice_put_AllowAudioOutputFormatChangesOnNextSet_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][hidden][propget] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_get_AllowAudioOutputFormatChangesOnNextSet_Proxy( + ISpeechVoice * This, + /* [retval][out] */ VARIANT_BOOL *Allow); + + +void __RPC_STUB ISpeechVoice_get_AllowAudioOutputFormatChangesOnNextSet_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_get_EventInterests_Proxy( + ISpeechVoice * This, + /* [retval][out] */ SpeechVoiceEvents *EventInterestFlags); + + +void __RPC_STUB ISpeechVoice_get_EventInterests_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_put_EventInterests_Proxy( + ISpeechVoice * This, + /* [in] */ SpeechVoiceEvents EventInterestFlags); + + +void __RPC_STUB ISpeechVoice_put_EventInterests_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_put_Priority_Proxy( + ISpeechVoice * This, + /* [in] */ SpeechVoicePriority Priority); + + +void __RPC_STUB ISpeechVoice_put_Priority_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_get_Priority_Proxy( + ISpeechVoice * This, + /* [retval][out] */ SpeechVoicePriority *Priority); + + +void __RPC_STUB ISpeechVoice_get_Priority_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_put_AlertBoundary_Proxy( + ISpeechVoice * This, + /* [in] */ SpeechVoiceEvents Boundary); + + +void __RPC_STUB ISpeechVoice_put_AlertBoundary_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_get_AlertBoundary_Proxy( + ISpeechVoice * This, + /* [retval][out] */ SpeechVoiceEvents *Boundary); + + +void __RPC_STUB ISpeechVoice_get_AlertBoundary_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_put_SynchronousSpeakTimeout_Proxy( + ISpeechVoice * This, + /* [in] */ long msTimeout); + + +void __RPC_STUB ISpeechVoice_put_SynchronousSpeakTimeout_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_get_SynchronousSpeakTimeout_Proxy( + ISpeechVoice * This, + /* [retval][out] */ long *msTimeout); + + +void __RPC_STUB ISpeechVoice_get_SynchronousSpeakTimeout_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_Speak_Proxy( + ISpeechVoice * This, + /* [in] */ BSTR Text, + /* [defaultvalue][in] */ SpeechVoiceSpeakFlags Flags, + /* [retval][out] */ long *StreamNumber); + + +void __RPC_STUB ISpeechVoice_Speak_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_SpeakStream_Proxy( + ISpeechVoice * This, + /* [in] */ ISpeechBaseStream *Stream, + /* [defaultvalue][in] */ SpeechVoiceSpeakFlags Flags, + /* [retval][out] */ long *StreamNumber); + + +void __RPC_STUB ISpeechVoice_SpeakStream_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_Pause_Proxy( + ISpeechVoice * This); + + +void __RPC_STUB ISpeechVoice_Pause_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_Resume_Proxy( + ISpeechVoice * This); + + +void __RPC_STUB ISpeechVoice_Resume_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_Skip_Proxy( + ISpeechVoice * This, + /* [in] */ const BSTR Type, + /* [in] */ long NumItems, + /* [retval][out] */ long *NumSkipped); + + +void __RPC_STUB ISpeechVoice_Skip_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_GetVoices_Proxy( + ISpeechVoice * This, + /* [defaultvalue][in] */ BSTR RequiredAttributes, + /* [defaultvalue][in] */ BSTR OptionalAttributes, + /* [retval][out] */ ISpeechObjectTokens **ObjectTokens); + + +void __RPC_STUB ISpeechVoice_GetVoices_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_GetAudioOutputs_Proxy( + ISpeechVoice * This, + /* [defaultvalue][in] */ BSTR RequiredAttributes, + /* [defaultvalue][in] */ BSTR OptionalAttributes, + /* [retval][out] */ ISpeechObjectTokens **ObjectTokens); + + +void __RPC_STUB ISpeechVoice_GetAudioOutputs_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_WaitUntilDone_Proxy( + ISpeechVoice * This, + /* [in] */ long msTimeout, + /* [retval][out] */ VARIANT_BOOL *Done); + + +void __RPC_STUB ISpeechVoice_WaitUntilDone_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][hidden][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_SpeakCompleteEvent_Proxy( + ISpeechVoice * This, + /* [retval][out] */ long *Handle); + + +void __RPC_STUB ISpeechVoice_SpeakCompleteEvent_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_IsUISupported_Proxy( + ISpeechVoice * This, + /* [in] */ const BSTR TypeOfUI, + /* [defaultvalue][in] */ const VARIANT *ExtraData, + /* [retval][out] */ VARIANT_BOOL *Supported); + + +void __RPC_STUB ISpeechVoice_IsUISupported_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechVoice_DisplayUI_Proxy( + ISpeechVoice * This, + /* [in] */ long hWndParent, + /* [in] */ BSTR Title, + /* [in] */ const BSTR TypeOfUI, + /* [defaultvalue][in] */ const VARIANT *ExtraData); + + +void __RPC_STUB ISpeechVoice_DisplayUI_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechVoice_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechVoiceStatus_INTERFACE_DEFINED__ +#define __ISpeechVoiceStatus_INTERFACE_DEFINED__ + +/* interface ISpeechVoiceStatus */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechVoiceStatus; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("8BE47B07-57F6-11d2-9EEE-00C04F797396") + ISpeechVoiceStatus : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_CurrentStreamNumber( + /* [retval][out] */ long *StreamNumber) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_LastStreamNumberQueued( + /* [retval][out] */ long *StreamNumber) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_LastHResult( + /* [retval][out] */ long *HResult) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_RunningState( + /* [retval][out] */ SpeechRunState *State) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_InputWordPosition( + /* [retval][out] */ long *Position) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_InputWordLength( + /* [retval][out] */ long *Length) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_InputSentencePosition( + /* [retval][out] */ long *Position) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_InputSentenceLength( + /* [retval][out] */ long *Length) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_LastBookmark( + /* [retval][out] */ BSTR *Bookmark) = 0; + + virtual /* [hidden][id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_LastBookmarkId( + /* [retval][out] */ long *BookmarkId) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_PhonemeId( + /* [retval][out] */ short *PhoneId) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_VisemeId( + /* [retval][out] */ short *VisemeId) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechVoiceStatusVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechVoiceStatus * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechVoiceStatus * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechVoiceStatus * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechVoiceStatus * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechVoiceStatus * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechVoiceStatus * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechVoiceStatus * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_CurrentStreamNumber )( + ISpeechVoiceStatus * This, + /* [retval][out] */ long *StreamNumber); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_LastStreamNumberQueued )( + ISpeechVoiceStatus * This, + /* [retval][out] */ long *StreamNumber); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_LastHResult )( + ISpeechVoiceStatus * This, + /* [retval][out] */ long *HResult); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_RunningState )( + ISpeechVoiceStatus * This, + /* [retval][out] */ SpeechRunState *State); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_InputWordPosition )( + ISpeechVoiceStatus * This, + /* [retval][out] */ long *Position); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_InputWordLength )( + ISpeechVoiceStatus * This, + /* [retval][out] */ long *Length); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_InputSentencePosition )( + ISpeechVoiceStatus * This, + /* [retval][out] */ long *Position); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_InputSentenceLength )( + ISpeechVoiceStatus * This, + /* [retval][out] */ long *Length); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_LastBookmark )( + ISpeechVoiceStatus * This, + /* [retval][out] */ BSTR *Bookmark); + + /* [hidden][id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_LastBookmarkId )( + ISpeechVoiceStatus * This, + /* [retval][out] */ long *BookmarkId); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PhonemeId )( + ISpeechVoiceStatus * This, + /* [retval][out] */ short *PhoneId); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_VisemeId )( + ISpeechVoiceStatus * This, + /* [retval][out] */ short *VisemeId); + + END_INTERFACE + } ISpeechVoiceStatusVtbl; + + interface ISpeechVoiceStatus + { + CONST_VTBL struct ISpeechVoiceStatusVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechVoiceStatus_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechVoiceStatus_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechVoiceStatus_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechVoiceStatus_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechVoiceStatus_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechVoiceStatus_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechVoiceStatus_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechVoiceStatus_get_CurrentStreamNumber(This,StreamNumber) \ + (This)->lpVtbl -> get_CurrentStreamNumber(This,StreamNumber) + +#define ISpeechVoiceStatus_get_LastStreamNumberQueued(This,StreamNumber) \ + (This)->lpVtbl -> get_LastStreamNumberQueued(This,StreamNumber) + +#define ISpeechVoiceStatus_get_LastHResult(This,HResult) \ + (This)->lpVtbl -> get_LastHResult(This,HResult) + +#define ISpeechVoiceStatus_get_RunningState(This,State) \ + (This)->lpVtbl -> get_RunningState(This,State) + +#define ISpeechVoiceStatus_get_InputWordPosition(This,Position) \ + (This)->lpVtbl -> get_InputWordPosition(This,Position) + +#define ISpeechVoiceStatus_get_InputWordLength(This,Length) \ + (This)->lpVtbl -> get_InputWordLength(This,Length) + +#define ISpeechVoiceStatus_get_InputSentencePosition(This,Position) \ + (This)->lpVtbl -> get_InputSentencePosition(This,Position) + +#define ISpeechVoiceStatus_get_InputSentenceLength(This,Length) \ + (This)->lpVtbl -> get_InputSentenceLength(This,Length) + +#define ISpeechVoiceStatus_get_LastBookmark(This,Bookmark) \ + (This)->lpVtbl -> get_LastBookmark(This,Bookmark) + +#define ISpeechVoiceStatus_get_LastBookmarkId(This,BookmarkId) \ + (This)->lpVtbl -> get_LastBookmarkId(This,BookmarkId) + +#define ISpeechVoiceStatus_get_PhonemeId(This,PhoneId) \ + (This)->lpVtbl -> get_PhonemeId(This,PhoneId) + +#define ISpeechVoiceStatus_get_VisemeId(This,VisemeId) \ + (This)->lpVtbl -> get_VisemeId(This,VisemeId) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechVoiceStatus_get_CurrentStreamNumber_Proxy( + ISpeechVoiceStatus * This, + /* [retval][out] */ long *StreamNumber); + + +void __RPC_STUB ISpeechVoiceStatus_get_CurrentStreamNumber_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechVoiceStatus_get_LastStreamNumberQueued_Proxy( + ISpeechVoiceStatus * This, + /* [retval][out] */ long *StreamNumber); + + +void __RPC_STUB ISpeechVoiceStatus_get_LastStreamNumberQueued_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechVoiceStatus_get_LastHResult_Proxy( + ISpeechVoiceStatus * This, + /* [retval][out] */ long *HResult); + + +void __RPC_STUB ISpeechVoiceStatus_get_LastHResult_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechVoiceStatus_get_RunningState_Proxy( + ISpeechVoiceStatus * This, + /* [retval][out] */ SpeechRunState *State); + + +void __RPC_STUB ISpeechVoiceStatus_get_RunningState_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechVoiceStatus_get_InputWordPosition_Proxy( + ISpeechVoiceStatus * This, + /* [retval][out] */ long *Position); + + +void __RPC_STUB ISpeechVoiceStatus_get_InputWordPosition_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechVoiceStatus_get_InputWordLength_Proxy( + ISpeechVoiceStatus * This, + /* [retval][out] */ long *Length); + + +void __RPC_STUB ISpeechVoiceStatus_get_InputWordLength_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechVoiceStatus_get_InputSentencePosition_Proxy( + ISpeechVoiceStatus * This, + /* [retval][out] */ long *Position); + + +void __RPC_STUB ISpeechVoiceStatus_get_InputSentencePosition_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechVoiceStatus_get_InputSentenceLength_Proxy( + ISpeechVoiceStatus * This, + /* [retval][out] */ long *Length); + + +void __RPC_STUB ISpeechVoiceStatus_get_InputSentenceLength_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechVoiceStatus_get_LastBookmark_Proxy( + ISpeechVoiceStatus * This, + /* [retval][out] */ BSTR *Bookmark); + + +void __RPC_STUB ISpeechVoiceStatus_get_LastBookmark_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [hidden][id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechVoiceStatus_get_LastBookmarkId_Proxy( + ISpeechVoiceStatus * This, + /* [retval][out] */ long *BookmarkId); + + +void __RPC_STUB ISpeechVoiceStatus_get_LastBookmarkId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechVoiceStatus_get_PhonemeId_Proxy( + ISpeechVoiceStatus * This, + /* [retval][out] */ short *PhoneId); + + +void __RPC_STUB ISpeechVoiceStatus_get_PhonemeId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechVoiceStatus_get_VisemeId_Proxy( + ISpeechVoiceStatus * This, + /* [retval][out] */ short *VisemeId); + + +void __RPC_STUB ISpeechVoiceStatus_get_VisemeId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechVoiceStatus_INTERFACE_DEFINED__ */ + + +#ifndef ___ISpeechVoiceEvents_DISPINTERFACE_DEFINED__ +#define ___ISpeechVoiceEvents_DISPINTERFACE_DEFINED__ + +/* dispinterface _ISpeechVoiceEvents */ +/* [uuid] */ + + +EXTERN_C const IID DIID__ISpeechVoiceEvents; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("A372ACD1-3BEF-4bbd-8FFB-CB3E2B416AF8") + _ISpeechVoiceEvents : public IDispatch + { + }; + +#else /* C style interface */ + + typedef struct _ISpeechVoiceEventsVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + _ISpeechVoiceEvents * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + _ISpeechVoiceEvents * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + _ISpeechVoiceEvents * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + _ISpeechVoiceEvents * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + _ISpeechVoiceEvents * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + _ISpeechVoiceEvents * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + _ISpeechVoiceEvents * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + END_INTERFACE + } _ISpeechVoiceEventsVtbl; + + interface _ISpeechVoiceEvents + { + CONST_VTBL struct _ISpeechVoiceEventsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define _ISpeechVoiceEvents_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define _ISpeechVoiceEvents_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define _ISpeechVoiceEvents_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define _ISpeechVoiceEvents_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define _ISpeechVoiceEvents_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define _ISpeechVoiceEvents_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define _ISpeechVoiceEvents_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + +#endif /* ___ISpeechVoiceEvents_DISPINTERFACE_DEFINED__ */ + + +#ifndef __ISpeechRecognizer_INTERFACE_DEFINED__ +#define __ISpeechRecognizer_INTERFACE_DEFINED__ + +/* interface ISpeechRecognizer */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechRecognizer; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("2D5F1C0C-BD75-4b08-9478-3B11FEA2586C") + ISpeechRecognizer : public IDispatch + { + public: + virtual /* [id][helpstring][propputref] */ HRESULT STDMETHODCALLTYPE putref_Recognizer( + /* [in] */ ISpeechObjectToken *Recognizer) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Recognizer( + /* [retval][out] */ ISpeechObjectToken **Recognizer) = 0; + + virtual /* [id][helpstring][hidden][propput] */ HRESULT STDMETHODCALLTYPE put_AllowAudioInputFormatChangesOnNextSet( + /* [in] */ VARIANT_BOOL Allow) = 0; + + virtual /* [id][helpstring][hidden][propget] */ HRESULT STDMETHODCALLTYPE get_AllowAudioInputFormatChangesOnNextSet( + /* [retval][out] */ VARIANT_BOOL *Allow) = 0; + + virtual /* [id][helpstring][propputref] */ HRESULT STDMETHODCALLTYPE putref_AudioInput( + /* [defaultvalue][in] */ ISpeechObjectToken *AudioInput = 0) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_AudioInput( + /* [retval][out] */ ISpeechObjectToken **AudioInput) = 0; + + virtual /* [id][helpstring][propputref] */ HRESULT STDMETHODCALLTYPE putref_AudioInputStream( + /* [defaultvalue][in] */ ISpeechBaseStream *AudioInputStream = 0) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_AudioInputStream( + /* [retval][out] */ ISpeechBaseStream **AudioInputStream) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_IsShared( + /* [retval][out] */ VARIANT_BOOL *Shared) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_State( + /* [in] */ SpeechRecognizerState State) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_State( + /* [retval][out] */ SpeechRecognizerState *State) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Status( + /* [retval][out] */ ISpeechRecognizerStatus **Status) = 0; + + virtual /* [id][helpstring][propputref] */ HRESULT STDMETHODCALLTYPE putref_Profile( + /* [defaultvalue][in] */ ISpeechObjectToken *Profile = 0) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Profile( + /* [retval][out] */ ISpeechObjectToken **Profile) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE EmulateRecognition( + /* [in] */ VARIANT TextElements, + /* [defaultvalue][in] */ VARIANT *ElementDisplayAttributes = 0, + /* [defaultvalue][in] */ long LanguageId = 0) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE CreateRecoContext( + /* [retval][out] */ ISpeechRecoContext **NewContext) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE GetFormat( + /* [in] */ SpeechFormatType Type, + /* [retval][out] */ ISpeechAudioFormat **Format) = 0; + + virtual /* [id][hidden][helpstring] */ HRESULT STDMETHODCALLTYPE SetPropertyNumber( + /* [in] */ const BSTR Name, + /* [in] */ long Value, + /* [retval][out] */ VARIANT_BOOL *Supported) = 0; + + virtual /* [id][hidden][helpstring] */ HRESULT STDMETHODCALLTYPE GetPropertyNumber( + /* [in] */ const BSTR Name, + /* [out][in] */ long *Value, + /* [retval][out] */ VARIANT_BOOL *Supported) = 0; + + virtual /* [id][hidden][helpstring] */ HRESULT STDMETHODCALLTYPE SetPropertyString( + /* [in] */ const BSTR Name, + /* [in] */ const BSTR Value, + /* [retval][out] */ VARIANT_BOOL *Supported) = 0; + + virtual /* [id][hidden][helpstring] */ HRESULT STDMETHODCALLTYPE GetPropertyString( + /* [in] */ const BSTR Name, + /* [out][in] */ BSTR *Value, + /* [retval][out] */ VARIANT_BOOL *Supported) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE IsUISupported( + /* [in] */ const BSTR TypeOfUI, + /* [defaultvalue][in] */ const VARIANT *ExtraData, + /* [retval][out] */ VARIANT_BOOL *Supported) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE DisplayUI( + /* [in] */ long hWndParent, + /* [in] */ BSTR Title, + /* [in] */ const BSTR TypeOfUI, + /* [defaultvalue][in] */ const VARIANT *ExtraData = 0) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE GetRecognizers( + /* [defaultvalue][in] */ BSTR RequiredAttributes, + /* [defaultvalue][in] */ BSTR OptionalAttributes, + /* [retval][out] */ ISpeechObjectTokens **ObjectTokens) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE GetAudioInputs( + /* [defaultvalue][in] */ BSTR RequiredAttributes, + /* [defaultvalue][in] */ BSTR OptionalAttributes, + /* [retval][out] */ ISpeechObjectTokens **ObjectTokens) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE GetProfiles( + /* [defaultvalue][in] */ BSTR RequiredAttributes, + /* [defaultvalue][in] */ BSTR OptionalAttributes, + /* [retval][out] */ ISpeechObjectTokens **ObjectTokens) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechRecognizerVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechRecognizer * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechRecognizer * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechRecognizer * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechRecognizer * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechRecognizer * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechRecognizer * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechRecognizer * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propputref] */ HRESULT ( STDMETHODCALLTYPE *putref_Recognizer )( + ISpeechRecognizer * This, + /* [in] */ ISpeechObjectToken *Recognizer); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Recognizer )( + ISpeechRecognizer * This, + /* [retval][out] */ ISpeechObjectToken **Recognizer); + + /* [id][helpstring][hidden][propput] */ HRESULT ( STDMETHODCALLTYPE *put_AllowAudioInputFormatChangesOnNextSet )( + ISpeechRecognizer * This, + /* [in] */ VARIANT_BOOL Allow); + + /* [id][helpstring][hidden][propget] */ HRESULT ( STDMETHODCALLTYPE *get_AllowAudioInputFormatChangesOnNextSet )( + ISpeechRecognizer * This, + /* [retval][out] */ VARIANT_BOOL *Allow); + + /* [id][helpstring][propputref] */ HRESULT ( STDMETHODCALLTYPE *putref_AudioInput )( + ISpeechRecognizer * This, + /* [defaultvalue][in] */ ISpeechObjectToken *AudioInput); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_AudioInput )( + ISpeechRecognizer * This, + /* [retval][out] */ ISpeechObjectToken **AudioInput); + + /* [id][helpstring][propputref] */ HRESULT ( STDMETHODCALLTYPE *putref_AudioInputStream )( + ISpeechRecognizer * This, + /* [defaultvalue][in] */ ISpeechBaseStream *AudioInputStream); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_AudioInputStream )( + ISpeechRecognizer * This, + /* [retval][out] */ ISpeechBaseStream **AudioInputStream); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_IsShared )( + ISpeechRecognizer * This, + /* [retval][out] */ VARIANT_BOOL *Shared); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_State )( + ISpeechRecognizer * This, + /* [in] */ SpeechRecognizerState State); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_State )( + ISpeechRecognizer * This, + /* [retval][out] */ SpeechRecognizerState *State); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Status )( + ISpeechRecognizer * This, + /* [retval][out] */ ISpeechRecognizerStatus **Status); + + /* [id][helpstring][propputref] */ HRESULT ( STDMETHODCALLTYPE *putref_Profile )( + ISpeechRecognizer * This, + /* [defaultvalue][in] */ ISpeechObjectToken *Profile); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Profile )( + ISpeechRecognizer * This, + /* [retval][out] */ ISpeechObjectToken **Profile); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *EmulateRecognition )( + ISpeechRecognizer * This, + /* [in] */ VARIANT TextElements, + /* [defaultvalue][in] */ VARIANT *ElementDisplayAttributes, + /* [defaultvalue][in] */ long LanguageId); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *CreateRecoContext )( + ISpeechRecognizer * This, + /* [retval][out] */ ISpeechRecoContext **NewContext); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetFormat )( + ISpeechRecognizer * This, + /* [in] */ SpeechFormatType Type, + /* [retval][out] */ ISpeechAudioFormat **Format); + + /* [id][hidden][helpstring] */ HRESULT ( STDMETHODCALLTYPE *SetPropertyNumber )( + ISpeechRecognizer * This, + /* [in] */ const BSTR Name, + /* [in] */ long Value, + /* [retval][out] */ VARIANT_BOOL *Supported); + + /* [id][hidden][helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetPropertyNumber )( + ISpeechRecognizer * This, + /* [in] */ const BSTR Name, + /* [out][in] */ long *Value, + /* [retval][out] */ VARIANT_BOOL *Supported); + + /* [id][hidden][helpstring] */ HRESULT ( STDMETHODCALLTYPE *SetPropertyString )( + ISpeechRecognizer * This, + /* [in] */ const BSTR Name, + /* [in] */ const BSTR Value, + /* [retval][out] */ VARIANT_BOOL *Supported); + + /* [id][hidden][helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetPropertyString )( + ISpeechRecognizer * This, + /* [in] */ const BSTR Name, + /* [out][in] */ BSTR *Value, + /* [retval][out] */ VARIANT_BOOL *Supported); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *IsUISupported )( + ISpeechRecognizer * This, + /* [in] */ const BSTR TypeOfUI, + /* [defaultvalue][in] */ const VARIANT *ExtraData, + /* [retval][out] */ VARIANT_BOOL *Supported); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *DisplayUI )( + ISpeechRecognizer * This, + /* [in] */ long hWndParent, + /* [in] */ BSTR Title, + /* [in] */ const BSTR TypeOfUI, + /* [defaultvalue][in] */ const VARIANT *ExtraData); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetRecognizers )( + ISpeechRecognizer * This, + /* [defaultvalue][in] */ BSTR RequiredAttributes, + /* [defaultvalue][in] */ BSTR OptionalAttributes, + /* [retval][out] */ ISpeechObjectTokens **ObjectTokens); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetAudioInputs )( + ISpeechRecognizer * This, + /* [defaultvalue][in] */ BSTR RequiredAttributes, + /* [defaultvalue][in] */ BSTR OptionalAttributes, + /* [retval][out] */ ISpeechObjectTokens **ObjectTokens); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetProfiles )( + ISpeechRecognizer * This, + /* [defaultvalue][in] */ BSTR RequiredAttributes, + /* [defaultvalue][in] */ BSTR OptionalAttributes, + /* [retval][out] */ ISpeechObjectTokens **ObjectTokens); + + END_INTERFACE + } ISpeechRecognizerVtbl; + + interface ISpeechRecognizer + { + CONST_VTBL struct ISpeechRecognizerVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechRecognizer_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechRecognizer_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechRecognizer_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechRecognizer_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechRecognizer_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechRecognizer_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechRecognizer_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechRecognizer_putref_Recognizer(This,Recognizer) \ + (This)->lpVtbl -> putref_Recognizer(This,Recognizer) + +#define ISpeechRecognizer_get_Recognizer(This,Recognizer) \ + (This)->lpVtbl -> get_Recognizer(This,Recognizer) + +#define ISpeechRecognizer_put_AllowAudioInputFormatChangesOnNextSet(This,Allow) \ + (This)->lpVtbl -> put_AllowAudioInputFormatChangesOnNextSet(This,Allow) + +#define ISpeechRecognizer_get_AllowAudioInputFormatChangesOnNextSet(This,Allow) \ + (This)->lpVtbl -> get_AllowAudioInputFormatChangesOnNextSet(This,Allow) + +#define ISpeechRecognizer_putref_AudioInput(This,AudioInput) \ + (This)->lpVtbl -> putref_AudioInput(This,AudioInput) + +#define ISpeechRecognizer_get_AudioInput(This,AudioInput) \ + (This)->lpVtbl -> get_AudioInput(This,AudioInput) + +#define ISpeechRecognizer_putref_AudioInputStream(This,AudioInputStream) \ + (This)->lpVtbl -> putref_AudioInputStream(This,AudioInputStream) + +#define ISpeechRecognizer_get_AudioInputStream(This,AudioInputStream) \ + (This)->lpVtbl -> get_AudioInputStream(This,AudioInputStream) + +#define ISpeechRecognizer_get_IsShared(This,Shared) \ + (This)->lpVtbl -> get_IsShared(This,Shared) + +#define ISpeechRecognizer_put_State(This,State) \ + (This)->lpVtbl -> put_State(This,State) + +#define ISpeechRecognizer_get_State(This,State) \ + (This)->lpVtbl -> get_State(This,State) + +#define ISpeechRecognizer_get_Status(This,Status) \ + (This)->lpVtbl -> get_Status(This,Status) + +#define ISpeechRecognizer_putref_Profile(This,Profile) \ + (This)->lpVtbl -> putref_Profile(This,Profile) + +#define ISpeechRecognizer_get_Profile(This,Profile) \ + (This)->lpVtbl -> get_Profile(This,Profile) + +#define ISpeechRecognizer_EmulateRecognition(This,TextElements,ElementDisplayAttributes,LanguageId) \ + (This)->lpVtbl -> EmulateRecognition(This,TextElements,ElementDisplayAttributes,LanguageId) + +#define ISpeechRecognizer_CreateRecoContext(This,NewContext) \ + (This)->lpVtbl -> CreateRecoContext(This,NewContext) + +#define ISpeechRecognizer_GetFormat(This,Type,Format) \ + (This)->lpVtbl -> GetFormat(This,Type,Format) + +#define ISpeechRecognizer_SetPropertyNumber(This,Name,Value,Supported) \ + (This)->lpVtbl -> SetPropertyNumber(This,Name,Value,Supported) + +#define ISpeechRecognizer_GetPropertyNumber(This,Name,Value,Supported) \ + (This)->lpVtbl -> GetPropertyNumber(This,Name,Value,Supported) + +#define ISpeechRecognizer_SetPropertyString(This,Name,Value,Supported) \ + (This)->lpVtbl -> SetPropertyString(This,Name,Value,Supported) + +#define ISpeechRecognizer_GetPropertyString(This,Name,Value,Supported) \ + (This)->lpVtbl -> GetPropertyString(This,Name,Value,Supported) + +#define ISpeechRecognizer_IsUISupported(This,TypeOfUI,ExtraData,Supported) \ + (This)->lpVtbl -> IsUISupported(This,TypeOfUI,ExtraData,Supported) + +#define ISpeechRecognizer_DisplayUI(This,hWndParent,Title,TypeOfUI,ExtraData) \ + (This)->lpVtbl -> DisplayUI(This,hWndParent,Title,TypeOfUI,ExtraData) + +#define ISpeechRecognizer_GetRecognizers(This,RequiredAttributes,OptionalAttributes,ObjectTokens) \ + (This)->lpVtbl -> GetRecognizers(This,RequiredAttributes,OptionalAttributes,ObjectTokens) + +#define ISpeechRecognizer_GetAudioInputs(This,RequiredAttributes,OptionalAttributes,ObjectTokens) \ + (This)->lpVtbl -> GetAudioInputs(This,RequiredAttributes,OptionalAttributes,ObjectTokens) + +#define ISpeechRecognizer_GetProfiles(This,RequiredAttributes,OptionalAttributes,ObjectTokens) \ + (This)->lpVtbl -> GetProfiles(This,RequiredAttributes,OptionalAttributes,ObjectTokens) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propputref] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizer_putref_Recognizer_Proxy( + ISpeechRecognizer * This, + /* [in] */ ISpeechObjectToken *Recognizer); + + +void __RPC_STUB ISpeechRecognizer_putref_Recognizer_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizer_get_Recognizer_Proxy( + ISpeechRecognizer * This, + /* [retval][out] */ ISpeechObjectToken **Recognizer); + + +void __RPC_STUB ISpeechRecognizer_get_Recognizer_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][hidden][propput] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizer_put_AllowAudioInputFormatChangesOnNextSet_Proxy( + ISpeechRecognizer * This, + /* [in] */ VARIANT_BOOL Allow); + + +void __RPC_STUB ISpeechRecognizer_put_AllowAudioInputFormatChangesOnNextSet_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][hidden][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizer_get_AllowAudioInputFormatChangesOnNextSet_Proxy( + ISpeechRecognizer * This, + /* [retval][out] */ VARIANT_BOOL *Allow); + + +void __RPC_STUB ISpeechRecognizer_get_AllowAudioInputFormatChangesOnNextSet_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propputref] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizer_putref_AudioInput_Proxy( + ISpeechRecognizer * This, + /* [defaultvalue][in] */ ISpeechObjectToken *AudioInput); + + +void __RPC_STUB ISpeechRecognizer_putref_AudioInput_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizer_get_AudioInput_Proxy( + ISpeechRecognizer * This, + /* [retval][out] */ ISpeechObjectToken **AudioInput); + + +void __RPC_STUB ISpeechRecognizer_get_AudioInput_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propputref] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizer_putref_AudioInputStream_Proxy( + ISpeechRecognizer * This, + /* [defaultvalue][in] */ ISpeechBaseStream *AudioInputStream); + + +void __RPC_STUB ISpeechRecognizer_putref_AudioInputStream_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizer_get_AudioInputStream_Proxy( + ISpeechRecognizer * This, + /* [retval][out] */ ISpeechBaseStream **AudioInputStream); + + +void __RPC_STUB ISpeechRecognizer_get_AudioInputStream_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizer_get_IsShared_Proxy( + ISpeechRecognizer * This, + /* [retval][out] */ VARIANT_BOOL *Shared); + + +void __RPC_STUB ISpeechRecognizer_get_IsShared_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizer_put_State_Proxy( + ISpeechRecognizer * This, + /* [in] */ SpeechRecognizerState State); + + +void __RPC_STUB ISpeechRecognizer_put_State_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizer_get_State_Proxy( + ISpeechRecognizer * This, + /* [retval][out] */ SpeechRecognizerState *State); + + +void __RPC_STUB ISpeechRecognizer_get_State_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizer_get_Status_Proxy( + ISpeechRecognizer * This, + /* [retval][out] */ ISpeechRecognizerStatus **Status); + + +void __RPC_STUB ISpeechRecognizer_get_Status_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propputref] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizer_putref_Profile_Proxy( + ISpeechRecognizer * This, + /* [defaultvalue][in] */ ISpeechObjectToken *Profile); + + +void __RPC_STUB ISpeechRecognizer_putref_Profile_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizer_get_Profile_Proxy( + ISpeechRecognizer * This, + /* [retval][out] */ ISpeechObjectToken **Profile); + + +void __RPC_STUB ISpeechRecognizer_get_Profile_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizer_EmulateRecognition_Proxy( + ISpeechRecognizer * This, + /* [in] */ VARIANT TextElements, + /* [defaultvalue][in] */ VARIANT *ElementDisplayAttributes, + /* [defaultvalue][in] */ long LanguageId); + + +void __RPC_STUB ISpeechRecognizer_EmulateRecognition_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizer_CreateRecoContext_Proxy( + ISpeechRecognizer * This, + /* [retval][out] */ ISpeechRecoContext **NewContext); + + +void __RPC_STUB ISpeechRecognizer_CreateRecoContext_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizer_GetFormat_Proxy( + ISpeechRecognizer * This, + /* [in] */ SpeechFormatType Type, + /* [retval][out] */ ISpeechAudioFormat **Format); + + +void __RPC_STUB ISpeechRecognizer_GetFormat_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][hidden][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizer_SetPropertyNumber_Proxy( + ISpeechRecognizer * This, + /* [in] */ const BSTR Name, + /* [in] */ long Value, + /* [retval][out] */ VARIANT_BOOL *Supported); + + +void __RPC_STUB ISpeechRecognizer_SetPropertyNumber_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][hidden][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizer_GetPropertyNumber_Proxy( + ISpeechRecognizer * This, + /* [in] */ const BSTR Name, + /* [out][in] */ long *Value, + /* [retval][out] */ VARIANT_BOOL *Supported); + + +void __RPC_STUB ISpeechRecognizer_GetPropertyNumber_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][hidden][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizer_SetPropertyString_Proxy( + ISpeechRecognizer * This, + /* [in] */ const BSTR Name, + /* [in] */ const BSTR Value, + /* [retval][out] */ VARIANT_BOOL *Supported); + + +void __RPC_STUB ISpeechRecognizer_SetPropertyString_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][hidden][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizer_GetPropertyString_Proxy( + ISpeechRecognizer * This, + /* [in] */ const BSTR Name, + /* [out][in] */ BSTR *Value, + /* [retval][out] */ VARIANT_BOOL *Supported); + + +void __RPC_STUB ISpeechRecognizer_GetPropertyString_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizer_IsUISupported_Proxy( + ISpeechRecognizer * This, + /* [in] */ const BSTR TypeOfUI, + /* [defaultvalue][in] */ const VARIANT *ExtraData, + /* [retval][out] */ VARIANT_BOOL *Supported); + + +void __RPC_STUB ISpeechRecognizer_IsUISupported_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizer_DisplayUI_Proxy( + ISpeechRecognizer * This, + /* [in] */ long hWndParent, + /* [in] */ BSTR Title, + /* [in] */ const BSTR TypeOfUI, + /* [defaultvalue][in] */ const VARIANT *ExtraData); + + +void __RPC_STUB ISpeechRecognizer_DisplayUI_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizer_GetRecognizers_Proxy( + ISpeechRecognizer * This, + /* [defaultvalue][in] */ BSTR RequiredAttributes, + /* [defaultvalue][in] */ BSTR OptionalAttributes, + /* [retval][out] */ ISpeechObjectTokens **ObjectTokens); + + +void __RPC_STUB ISpeechRecognizer_GetRecognizers_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizer_GetAudioInputs_Proxy( + ISpeechRecognizer * This, + /* [defaultvalue][in] */ BSTR RequiredAttributes, + /* [defaultvalue][in] */ BSTR OptionalAttributes, + /* [retval][out] */ ISpeechObjectTokens **ObjectTokens); + + +void __RPC_STUB ISpeechRecognizer_GetAudioInputs_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizer_GetProfiles_Proxy( + ISpeechRecognizer * This, + /* [defaultvalue][in] */ BSTR RequiredAttributes, + /* [defaultvalue][in] */ BSTR OptionalAttributes, + /* [retval][out] */ ISpeechObjectTokens **ObjectTokens); + + +void __RPC_STUB ISpeechRecognizer_GetProfiles_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechRecognizer_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechRecognizerStatus_INTERFACE_DEFINED__ +#define __ISpeechRecognizerStatus_INTERFACE_DEFINED__ + +/* interface ISpeechRecognizerStatus */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechRecognizerStatus; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("BFF9E781-53EC-484e-BB8A-0E1B5551E35C") + ISpeechRecognizerStatus : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_AudioStatus( + /* [retval][out] */ ISpeechAudioStatus **AudioStatus) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_CurrentStreamPosition( + /* [retval][out] */ VARIANT *pCurrentStreamPos) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_CurrentStreamNumber( + /* [retval][out] */ long *StreamNumber) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_NumberOfActiveRules( + /* [retval][out] */ long *NumberOfActiveRules) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_ClsidEngine( + /* [retval][out] */ BSTR *ClsidEngine) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_SupportedLanguages( + /* [retval][out] */ VARIANT *SupportedLanguages) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechRecognizerStatusVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechRecognizerStatus * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechRecognizerStatus * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechRecognizerStatus * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechRecognizerStatus * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechRecognizerStatus * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechRecognizerStatus * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechRecognizerStatus * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_AudioStatus )( + ISpeechRecognizerStatus * This, + /* [retval][out] */ ISpeechAudioStatus **AudioStatus); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_CurrentStreamPosition )( + ISpeechRecognizerStatus * This, + /* [retval][out] */ VARIANT *pCurrentStreamPos); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_CurrentStreamNumber )( + ISpeechRecognizerStatus * This, + /* [retval][out] */ long *StreamNumber); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_NumberOfActiveRules )( + ISpeechRecognizerStatus * This, + /* [retval][out] */ long *NumberOfActiveRules); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_ClsidEngine )( + ISpeechRecognizerStatus * This, + /* [retval][out] */ BSTR *ClsidEngine); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_SupportedLanguages )( + ISpeechRecognizerStatus * This, + /* [retval][out] */ VARIANT *SupportedLanguages); + + END_INTERFACE + } ISpeechRecognizerStatusVtbl; + + interface ISpeechRecognizerStatus + { + CONST_VTBL struct ISpeechRecognizerStatusVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechRecognizerStatus_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechRecognizerStatus_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechRecognizerStatus_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechRecognizerStatus_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechRecognizerStatus_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechRecognizerStatus_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechRecognizerStatus_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechRecognizerStatus_get_AudioStatus(This,AudioStatus) \ + (This)->lpVtbl -> get_AudioStatus(This,AudioStatus) + +#define ISpeechRecognizerStatus_get_CurrentStreamPosition(This,pCurrentStreamPos) \ + (This)->lpVtbl -> get_CurrentStreamPosition(This,pCurrentStreamPos) + +#define ISpeechRecognizerStatus_get_CurrentStreamNumber(This,StreamNumber) \ + (This)->lpVtbl -> get_CurrentStreamNumber(This,StreamNumber) + +#define ISpeechRecognizerStatus_get_NumberOfActiveRules(This,NumberOfActiveRules) \ + (This)->lpVtbl -> get_NumberOfActiveRules(This,NumberOfActiveRules) + +#define ISpeechRecognizerStatus_get_ClsidEngine(This,ClsidEngine) \ + (This)->lpVtbl -> get_ClsidEngine(This,ClsidEngine) + +#define ISpeechRecognizerStatus_get_SupportedLanguages(This,SupportedLanguages) \ + (This)->lpVtbl -> get_SupportedLanguages(This,SupportedLanguages) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizerStatus_get_AudioStatus_Proxy( + ISpeechRecognizerStatus * This, + /* [retval][out] */ ISpeechAudioStatus **AudioStatus); + + +void __RPC_STUB ISpeechRecognizerStatus_get_AudioStatus_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizerStatus_get_CurrentStreamPosition_Proxy( + ISpeechRecognizerStatus * This, + /* [retval][out] */ VARIANT *pCurrentStreamPos); + + +void __RPC_STUB ISpeechRecognizerStatus_get_CurrentStreamPosition_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizerStatus_get_CurrentStreamNumber_Proxy( + ISpeechRecognizerStatus * This, + /* [retval][out] */ long *StreamNumber); + + +void __RPC_STUB ISpeechRecognizerStatus_get_CurrentStreamNumber_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizerStatus_get_NumberOfActiveRules_Proxy( + ISpeechRecognizerStatus * This, + /* [retval][out] */ long *NumberOfActiveRules); + + +void __RPC_STUB ISpeechRecognizerStatus_get_NumberOfActiveRules_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizerStatus_get_ClsidEngine_Proxy( + ISpeechRecognizerStatus * This, + /* [retval][out] */ BSTR *ClsidEngine); + + +void __RPC_STUB ISpeechRecognizerStatus_get_ClsidEngine_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecognizerStatus_get_SupportedLanguages_Proxy( + ISpeechRecognizerStatus * This, + /* [retval][out] */ VARIANT *SupportedLanguages); + + +void __RPC_STUB ISpeechRecognizerStatus_get_SupportedLanguages_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechRecognizerStatus_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechRecoContext_INTERFACE_DEFINED__ +#define __ISpeechRecoContext_INTERFACE_DEFINED__ + +/* interface ISpeechRecoContext */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechRecoContext; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("580AA49D-7E1E-4809-B8E2-57DA806104B8") + ISpeechRecoContext : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Recognizer( + /* [retval][out] */ ISpeechRecognizer **Recognizer) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_AudioInputInterferenceStatus( + /* [retval][out] */ SpeechInterference *Interference) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_RequestedUIType( + /* [retval][out] */ BSTR *UIType) = 0; + + virtual /* [id][helpstring][propputref] */ HRESULT STDMETHODCALLTYPE putref_Voice( + /* [in] */ ISpeechVoice *Voice) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Voice( + /* [retval][out] */ ISpeechVoice **Voice) = 0; + + virtual /* [id][helpstring][hidden][propput] */ HRESULT STDMETHODCALLTYPE put_AllowVoiceFormatMatchingOnNextSet( + /* [in] */ VARIANT_BOOL Allow) = 0; + + virtual /* [id][helpstring][hidden][propget] */ HRESULT STDMETHODCALLTYPE get_AllowVoiceFormatMatchingOnNextSet( + /* [retval][out] */ VARIANT_BOOL *pAllow) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_VoicePurgeEvent( + /* [in] */ SpeechRecoEvents EventInterest) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_VoicePurgeEvent( + /* [retval][out] */ SpeechRecoEvents *EventInterest) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_EventInterests( + /* [in] */ SpeechRecoEvents EventInterest) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_EventInterests( + /* [retval][out] */ SpeechRecoEvents *EventInterest) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_CmdMaxAlternates( + /* [in] */ long MaxAlternates) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_CmdMaxAlternates( + /* [retval][out] */ long *MaxAlternates) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_State( + /* [in] */ SpeechRecoContextState State) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_State( + /* [retval][out] */ SpeechRecoContextState *State) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_RetainedAudio( + /* [in] */ SpeechRetainedAudioOptions Option) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_RetainedAudio( + /* [retval][out] */ SpeechRetainedAudioOptions *Option) = 0; + + virtual /* [id][helpstring][propputref] */ HRESULT STDMETHODCALLTYPE putref_RetainedAudioFormat( + /* [in] */ ISpeechAudioFormat *Format) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_RetainedAudioFormat( + /* [retval][out] */ ISpeechAudioFormat **Format) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE Pause( void) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE Resume( void) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE CreateGrammar( + /* [defaultvalue][in] */ VARIANT GrammarId, + /* [retval][out] */ ISpeechRecoGrammar **Grammar) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE CreateResultFromMemory( + /* [in] */ VARIANT *ResultBlock, + /* [retval][out] */ ISpeechRecoResult **Result) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE Bookmark( + /* [in] */ SpeechBookmarkOptions Options, + /* [in] */ VARIANT StreamPos, + /* [in] */ VARIANT BookmarkId) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE SetAdaptationData( + /* [in] */ BSTR AdaptationString) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechRecoContextVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechRecoContext * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechRecoContext * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechRecoContext * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechRecoContext * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechRecoContext * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechRecoContext * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechRecoContext * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Recognizer )( + ISpeechRecoContext * This, + /* [retval][out] */ ISpeechRecognizer **Recognizer); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_AudioInputInterferenceStatus )( + ISpeechRecoContext * This, + /* [retval][out] */ SpeechInterference *Interference); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_RequestedUIType )( + ISpeechRecoContext * This, + /* [retval][out] */ BSTR *UIType); + + /* [id][helpstring][propputref] */ HRESULT ( STDMETHODCALLTYPE *putref_Voice )( + ISpeechRecoContext * This, + /* [in] */ ISpeechVoice *Voice); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Voice )( + ISpeechRecoContext * This, + /* [retval][out] */ ISpeechVoice **Voice); + + /* [id][helpstring][hidden][propput] */ HRESULT ( STDMETHODCALLTYPE *put_AllowVoiceFormatMatchingOnNextSet )( + ISpeechRecoContext * This, + /* [in] */ VARIANT_BOOL Allow); + + /* [id][helpstring][hidden][propget] */ HRESULT ( STDMETHODCALLTYPE *get_AllowVoiceFormatMatchingOnNextSet )( + ISpeechRecoContext * This, + /* [retval][out] */ VARIANT_BOOL *pAllow); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_VoicePurgeEvent )( + ISpeechRecoContext * This, + /* [in] */ SpeechRecoEvents EventInterest); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_VoicePurgeEvent )( + ISpeechRecoContext * This, + /* [retval][out] */ SpeechRecoEvents *EventInterest); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_EventInterests )( + ISpeechRecoContext * This, + /* [in] */ SpeechRecoEvents EventInterest); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_EventInterests )( + ISpeechRecoContext * This, + /* [retval][out] */ SpeechRecoEvents *EventInterest); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_CmdMaxAlternates )( + ISpeechRecoContext * This, + /* [in] */ long MaxAlternates); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_CmdMaxAlternates )( + ISpeechRecoContext * This, + /* [retval][out] */ long *MaxAlternates); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_State )( + ISpeechRecoContext * This, + /* [in] */ SpeechRecoContextState State); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_State )( + ISpeechRecoContext * This, + /* [retval][out] */ SpeechRecoContextState *State); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_RetainedAudio )( + ISpeechRecoContext * This, + /* [in] */ SpeechRetainedAudioOptions Option); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_RetainedAudio )( + ISpeechRecoContext * This, + /* [retval][out] */ SpeechRetainedAudioOptions *Option); + + /* [id][helpstring][propputref] */ HRESULT ( STDMETHODCALLTYPE *putref_RetainedAudioFormat )( + ISpeechRecoContext * This, + /* [in] */ ISpeechAudioFormat *Format); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_RetainedAudioFormat )( + ISpeechRecoContext * This, + /* [retval][out] */ ISpeechAudioFormat **Format); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Pause )( + ISpeechRecoContext * This); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Resume )( + ISpeechRecoContext * This); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *CreateGrammar )( + ISpeechRecoContext * This, + /* [defaultvalue][in] */ VARIANT GrammarId, + /* [retval][out] */ ISpeechRecoGrammar **Grammar); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *CreateResultFromMemory )( + ISpeechRecoContext * This, + /* [in] */ VARIANT *ResultBlock, + /* [retval][out] */ ISpeechRecoResult **Result); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Bookmark )( + ISpeechRecoContext * This, + /* [in] */ SpeechBookmarkOptions Options, + /* [in] */ VARIANT StreamPos, + /* [in] */ VARIANT BookmarkId); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *SetAdaptationData )( + ISpeechRecoContext * This, + /* [in] */ BSTR AdaptationString); + + END_INTERFACE + } ISpeechRecoContextVtbl; + + interface ISpeechRecoContext + { + CONST_VTBL struct ISpeechRecoContextVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechRecoContext_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechRecoContext_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechRecoContext_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechRecoContext_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechRecoContext_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechRecoContext_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechRecoContext_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechRecoContext_get_Recognizer(This,Recognizer) \ + (This)->lpVtbl -> get_Recognizer(This,Recognizer) + +#define ISpeechRecoContext_get_AudioInputInterferenceStatus(This,Interference) \ + (This)->lpVtbl -> get_AudioInputInterferenceStatus(This,Interference) + +#define ISpeechRecoContext_get_RequestedUIType(This,UIType) \ + (This)->lpVtbl -> get_RequestedUIType(This,UIType) + +#define ISpeechRecoContext_putref_Voice(This,Voice) \ + (This)->lpVtbl -> putref_Voice(This,Voice) + +#define ISpeechRecoContext_get_Voice(This,Voice) \ + (This)->lpVtbl -> get_Voice(This,Voice) + +#define ISpeechRecoContext_put_AllowVoiceFormatMatchingOnNextSet(This,Allow) \ + (This)->lpVtbl -> put_AllowVoiceFormatMatchingOnNextSet(This,Allow) + +#define ISpeechRecoContext_get_AllowVoiceFormatMatchingOnNextSet(This,pAllow) \ + (This)->lpVtbl -> get_AllowVoiceFormatMatchingOnNextSet(This,pAllow) + +#define ISpeechRecoContext_put_VoicePurgeEvent(This,EventInterest) \ + (This)->lpVtbl -> put_VoicePurgeEvent(This,EventInterest) + +#define ISpeechRecoContext_get_VoicePurgeEvent(This,EventInterest) \ + (This)->lpVtbl -> get_VoicePurgeEvent(This,EventInterest) + +#define ISpeechRecoContext_put_EventInterests(This,EventInterest) \ + (This)->lpVtbl -> put_EventInterests(This,EventInterest) + +#define ISpeechRecoContext_get_EventInterests(This,EventInterest) \ + (This)->lpVtbl -> get_EventInterests(This,EventInterest) + +#define ISpeechRecoContext_put_CmdMaxAlternates(This,MaxAlternates) \ + (This)->lpVtbl -> put_CmdMaxAlternates(This,MaxAlternates) + +#define ISpeechRecoContext_get_CmdMaxAlternates(This,MaxAlternates) \ + (This)->lpVtbl -> get_CmdMaxAlternates(This,MaxAlternates) + +#define ISpeechRecoContext_put_State(This,State) \ + (This)->lpVtbl -> put_State(This,State) + +#define ISpeechRecoContext_get_State(This,State) \ + (This)->lpVtbl -> get_State(This,State) + +#define ISpeechRecoContext_put_RetainedAudio(This,Option) \ + (This)->lpVtbl -> put_RetainedAudio(This,Option) + +#define ISpeechRecoContext_get_RetainedAudio(This,Option) \ + (This)->lpVtbl -> get_RetainedAudio(This,Option) + +#define ISpeechRecoContext_putref_RetainedAudioFormat(This,Format) \ + (This)->lpVtbl -> putref_RetainedAudioFormat(This,Format) + +#define ISpeechRecoContext_get_RetainedAudioFormat(This,Format) \ + (This)->lpVtbl -> get_RetainedAudioFormat(This,Format) + +#define ISpeechRecoContext_Pause(This) \ + (This)->lpVtbl -> Pause(This) + +#define ISpeechRecoContext_Resume(This) \ + (This)->lpVtbl -> Resume(This) + +#define ISpeechRecoContext_CreateGrammar(This,GrammarId,Grammar) \ + (This)->lpVtbl -> CreateGrammar(This,GrammarId,Grammar) + +#define ISpeechRecoContext_CreateResultFromMemory(This,ResultBlock,Result) \ + (This)->lpVtbl -> CreateResultFromMemory(This,ResultBlock,Result) + +#define ISpeechRecoContext_Bookmark(This,Options,StreamPos,BookmarkId) \ + (This)->lpVtbl -> Bookmark(This,Options,StreamPos,BookmarkId) + +#define ISpeechRecoContext_SetAdaptationData(This,AdaptationString) \ + (This)->lpVtbl -> SetAdaptationData(This,AdaptationString) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecoContext_get_Recognizer_Proxy( + ISpeechRecoContext * This, + /* [retval][out] */ ISpeechRecognizer **Recognizer); + + +void __RPC_STUB ISpeechRecoContext_get_Recognizer_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecoContext_get_AudioInputInterferenceStatus_Proxy( + ISpeechRecoContext * This, + /* [retval][out] */ SpeechInterference *Interference); + + +void __RPC_STUB ISpeechRecoContext_get_AudioInputInterferenceStatus_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecoContext_get_RequestedUIType_Proxy( + ISpeechRecoContext * This, + /* [retval][out] */ BSTR *UIType); + + +void __RPC_STUB ISpeechRecoContext_get_RequestedUIType_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propputref] */ HRESULT STDMETHODCALLTYPE ISpeechRecoContext_putref_Voice_Proxy( + ISpeechRecoContext * This, + /* [in] */ ISpeechVoice *Voice); + + +void __RPC_STUB ISpeechRecoContext_putref_Voice_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecoContext_get_Voice_Proxy( + ISpeechRecoContext * This, + /* [retval][out] */ ISpeechVoice **Voice); + + +void __RPC_STUB ISpeechRecoContext_get_Voice_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][hidden][propput] */ HRESULT STDMETHODCALLTYPE ISpeechRecoContext_put_AllowVoiceFormatMatchingOnNextSet_Proxy( + ISpeechRecoContext * This, + /* [in] */ VARIANT_BOOL Allow); + + +void __RPC_STUB ISpeechRecoContext_put_AllowVoiceFormatMatchingOnNextSet_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][hidden][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecoContext_get_AllowVoiceFormatMatchingOnNextSet_Proxy( + ISpeechRecoContext * This, + /* [retval][out] */ VARIANT_BOOL *pAllow); + + +void __RPC_STUB ISpeechRecoContext_get_AllowVoiceFormatMatchingOnNextSet_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechRecoContext_put_VoicePurgeEvent_Proxy( + ISpeechRecoContext * This, + /* [in] */ SpeechRecoEvents EventInterest); + + +void __RPC_STUB ISpeechRecoContext_put_VoicePurgeEvent_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecoContext_get_VoicePurgeEvent_Proxy( + ISpeechRecoContext * This, + /* [retval][out] */ SpeechRecoEvents *EventInterest); + + +void __RPC_STUB ISpeechRecoContext_get_VoicePurgeEvent_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechRecoContext_put_EventInterests_Proxy( + ISpeechRecoContext * This, + /* [in] */ SpeechRecoEvents EventInterest); + + +void __RPC_STUB ISpeechRecoContext_put_EventInterests_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecoContext_get_EventInterests_Proxy( + ISpeechRecoContext * This, + /* [retval][out] */ SpeechRecoEvents *EventInterest); + + +void __RPC_STUB ISpeechRecoContext_get_EventInterests_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechRecoContext_put_CmdMaxAlternates_Proxy( + ISpeechRecoContext * This, + /* [in] */ long MaxAlternates); + + +void __RPC_STUB ISpeechRecoContext_put_CmdMaxAlternates_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecoContext_get_CmdMaxAlternates_Proxy( + ISpeechRecoContext * This, + /* [retval][out] */ long *MaxAlternates); + + +void __RPC_STUB ISpeechRecoContext_get_CmdMaxAlternates_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechRecoContext_put_State_Proxy( + ISpeechRecoContext * This, + /* [in] */ SpeechRecoContextState State); + + +void __RPC_STUB ISpeechRecoContext_put_State_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecoContext_get_State_Proxy( + ISpeechRecoContext * This, + /* [retval][out] */ SpeechRecoContextState *State); + + +void __RPC_STUB ISpeechRecoContext_get_State_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechRecoContext_put_RetainedAudio_Proxy( + ISpeechRecoContext * This, + /* [in] */ SpeechRetainedAudioOptions Option); + + +void __RPC_STUB ISpeechRecoContext_put_RetainedAudio_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecoContext_get_RetainedAudio_Proxy( + ISpeechRecoContext * This, + /* [retval][out] */ SpeechRetainedAudioOptions *Option); + + +void __RPC_STUB ISpeechRecoContext_get_RetainedAudio_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propputref] */ HRESULT STDMETHODCALLTYPE ISpeechRecoContext_putref_RetainedAudioFormat_Proxy( + ISpeechRecoContext * This, + /* [in] */ ISpeechAudioFormat *Format); + + +void __RPC_STUB ISpeechRecoContext_putref_RetainedAudioFormat_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecoContext_get_RetainedAudioFormat_Proxy( + ISpeechRecoContext * This, + /* [retval][out] */ ISpeechAudioFormat **Format); + + +void __RPC_STUB ISpeechRecoContext_get_RetainedAudioFormat_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecoContext_Pause_Proxy( + ISpeechRecoContext * This); + + +void __RPC_STUB ISpeechRecoContext_Pause_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecoContext_Resume_Proxy( + ISpeechRecoContext * This); + + +void __RPC_STUB ISpeechRecoContext_Resume_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecoContext_CreateGrammar_Proxy( + ISpeechRecoContext * This, + /* [defaultvalue][in] */ VARIANT GrammarId, + /* [retval][out] */ ISpeechRecoGrammar **Grammar); + + +void __RPC_STUB ISpeechRecoContext_CreateGrammar_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecoContext_CreateResultFromMemory_Proxy( + ISpeechRecoContext * This, + /* [in] */ VARIANT *ResultBlock, + /* [retval][out] */ ISpeechRecoResult **Result); + + +void __RPC_STUB ISpeechRecoContext_CreateResultFromMemory_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecoContext_Bookmark_Proxy( + ISpeechRecoContext * This, + /* [in] */ SpeechBookmarkOptions Options, + /* [in] */ VARIANT StreamPos, + /* [in] */ VARIANT BookmarkId); + + +void __RPC_STUB ISpeechRecoContext_Bookmark_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecoContext_SetAdaptationData_Proxy( + ISpeechRecoContext * This, + /* [in] */ BSTR AdaptationString); + + +void __RPC_STUB ISpeechRecoContext_SetAdaptationData_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechRecoContext_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechRecoGrammar_INTERFACE_DEFINED__ +#define __ISpeechRecoGrammar_INTERFACE_DEFINED__ + +/* interface ISpeechRecoGrammar */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechRecoGrammar; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("B6D6F79F-2158-4e50-B5BC-9A9CCD852A09") + ISpeechRecoGrammar : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Id( + /* [retval][out] */ VARIANT *Id) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_RecoContext( + /* [retval][out] */ ISpeechRecoContext **RecoContext) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_State( + /* [in] */ SpeechGrammarState State) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_State( + /* [retval][out] */ SpeechGrammarState *State) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Rules( + /* [retval][out] */ ISpeechGrammarRules **Rules) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE Reset( + /* [defaultvalue][in] */ SpeechLanguageId NewLanguage = 0) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE CmdLoadFromFile( + /* [in] */ const BSTR FileName, + /* [defaultvalue][in] */ SpeechLoadOption LoadOption = SLOStatic) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE CmdLoadFromObject( + /* [in] */ const BSTR ClassId, + /* [in] */ const BSTR GrammarName, + /* [defaultvalue][in] */ SpeechLoadOption LoadOption = SLOStatic) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE CmdLoadFromResource( + /* [in] */ long hModule, + /* [in] */ VARIANT ResourceName, + /* [in] */ VARIANT ResourceType, + /* [in] */ SpeechLanguageId LanguageId, + /* [defaultvalue][in] */ SpeechLoadOption LoadOption = SLOStatic) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE CmdLoadFromMemory( + /* [in] */ VARIANT GrammarData, + /* [defaultvalue][in] */ SpeechLoadOption LoadOption = SLOStatic) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE CmdLoadFromProprietaryGrammar( + /* [in] */ const BSTR ProprietaryGuid, + /* [in] */ const BSTR ProprietaryString, + /* [in] */ VARIANT ProprietaryData, + /* [defaultvalue][in] */ SpeechLoadOption LoadOption = SLOStatic) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE CmdSetRuleState( + /* [in] */ const BSTR Name, + /* [in] */ SpeechRuleState State) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE CmdSetRuleIdState( + /* [in] */ long RuleId, + /* [in] */ SpeechRuleState State) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE DictationLoad( + /* [defaultvalue][in] */ const BSTR TopicName = L"", + /* [defaultvalue][in] */ SpeechLoadOption LoadOption = SLOStatic) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE DictationUnload( void) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE DictationSetState( + /* [in] */ SpeechRuleState State) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE SetWordSequenceData( + /* [in] */ const BSTR Text, + /* [in] */ long TextLength, + /* [in] */ ISpeechTextSelectionInformation *Info) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE SetTextSelection( + /* [in] */ ISpeechTextSelectionInformation *Info) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE IsPronounceable( + /* [in] */ const BSTR Word, + /* [retval][out] */ SpeechWordPronounceable *WordPronounceable) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechRecoGrammarVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechRecoGrammar * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechRecoGrammar * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechRecoGrammar * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechRecoGrammar * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechRecoGrammar * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechRecoGrammar * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechRecoGrammar * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Id )( + ISpeechRecoGrammar * This, + /* [retval][out] */ VARIANT *Id); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_RecoContext )( + ISpeechRecoGrammar * This, + /* [retval][out] */ ISpeechRecoContext **RecoContext); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_State )( + ISpeechRecoGrammar * This, + /* [in] */ SpeechGrammarState State); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_State )( + ISpeechRecoGrammar * This, + /* [retval][out] */ SpeechGrammarState *State); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Rules )( + ISpeechRecoGrammar * This, + /* [retval][out] */ ISpeechGrammarRules **Rules); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Reset )( + ISpeechRecoGrammar * This, + /* [defaultvalue][in] */ SpeechLanguageId NewLanguage); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *CmdLoadFromFile )( + ISpeechRecoGrammar * This, + /* [in] */ const BSTR FileName, + /* [defaultvalue][in] */ SpeechLoadOption LoadOption); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *CmdLoadFromObject )( + ISpeechRecoGrammar * This, + /* [in] */ const BSTR ClassId, + /* [in] */ const BSTR GrammarName, + /* [defaultvalue][in] */ SpeechLoadOption LoadOption); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *CmdLoadFromResource )( + ISpeechRecoGrammar * This, + /* [in] */ long hModule, + /* [in] */ VARIANT ResourceName, + /* [in] */ VARIANT ResourceType, + /* [in] */ SpeechLanguageId LanguageId, + /* [defaultvalue][in] */ SpeechLoadOption LoadOption); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *CmdLoadFromMemory )( + ISpeechRecoGrammar * This, + /* [in] */ VARIANT GrammarData, + /* [defaultvalue][in] */ SpeechLoadOption LoadOption); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *CmdLoadFromProprietaryGrammar )( + ISpeechRecoGrammar * This, + /* [in] */ const BSTR ProprietaryGuid, + /* [in] */ const BSTR ProprietaryString, + /* [in] */ VARIANT ProprietaryData, + /* [defaultvalue][in] */ SpeechLoadOption LoadOption); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *CmdSetRuleState )( + ISpeechRecoGrammar * This, + /* [in] */ const BSTR Name, + /* [in] */ SpeechRuleState State); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *CmdSetRuleIdState )( + ISpeechRecoGrammar * This, + /* [in] */ long RuleId, + /* [in] */ SpeechRuleState State); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *DictationLoad )( + ISpeechRecoGrammar * This, + /* [defaultvalue][in] */ const BSTR TopicName, + /* [defaultvalue][in] */ SpeechLoadOption LoadOption); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *DictationUnload )( + ISpeechRecoGrammar * This); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *DictationSetState )( + ISpeechRecoGrammar * This, + /* [in] */ SpeechRuleState State); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *SetWordSequenceData )( + ISpeechRecoGrammar * This, + /* [in] */ const BSTR Text, + /* [in] */ long TextLength, + /* [in] */ ISpeechTextSelectionInformation *Info); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *SetTextSelection )( + ISpeechRecoGrammar * This, + /* [in] */ ISpeechTextSelectionInformation *Info); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *IsPronounceable )( + ISpeechRecoGrammar * This, + /* [in] */ const BSTR Word, + /* [retval][out] */ SpeechWordPronounceable *WordPronounceable); + + END_INTERFACE + } ISpeechRecoGrammarVtbl; + + interface ISpeechRecoGrammar + { + CONST_VTBL struct ISpeechRecoGrammarVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechRecoGrammar_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechRecoGrammar_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechRecoGrammar_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechRecoGrammar_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechRecoGrammar_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechRecoGrammar_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechRecoGrammar_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechRecoGrammar_get_Id(This,Id) \ + (This)->lpVtbl -> get_Id(This,Id) + +#define ISpeechRecoGrammar_get_RecoContext(This,RecoContext) \ + (This)->lpVtbl -> get_RecoContext(This,RecoContext) + +#define ISpeechRecoGrammar_put_State(This,State) \ + (This)->lpVtbl -> put_State(This,State) + +#define ISpeechRecoGrammar_get_State(This,State) \ + (This)->lpVtbl -> get_State(This,State) + +#define ISpeechRecoGrammar_get_Rules(This,Rules) \ + (This)->lpVtbl -> get_Rules(This,Rules) + +#define ISpeechRecoGrammar_Reset(This,NewLanguage) \ + (This)->lpVtbl -> Reset(This,NewLanguage) + +#define ISpeechRecoGrammar_CmdLoadFromFile(This,FileName,LoadOption) \ + (This)->lpVtbl -> CmdLoadFromFile(This,FileName,LoadOption) + +#define ISpeechRecoGrammar_CmdLoadFromObject(This,ClassId,GrammarName,LoadOption) \ + (This)->lpVtbl -> CmdLoadFromObject(This,ClassId,GrammarName,LoadOption) + +#define ISpeechRecoGrammar_CmdLoadFromResource(This,hModule,ResourceName,ResourceType,LanguageId,LoadOption) \ + (This)->lpVtbl -> CmdLoadFromResource(This,hModule,ResourceName,ResourceType,LanguageId,LoadOption) + +#define ISpeechRecoGrammar_CmdLoadFromMemory(This,GrammarData,LoadOption) \ + (This)->lpVtbl -> CmdLoadFromMemory(This,GrammarData,LoadOption) + +#define ISpeechRecoGrammar_CmdLoadFromProprietaryGrammar(This,ProprietaryGuid,ProprietaryString,ProprietaryData,LoadOption) \ + (This)->lpVtbl -> CmdLoadFromProprietaryGrammar(This,ProprietaryGuid,ProprietaryString,ProprietaryData,LoadOption) + +#define ISpeechRecoGrammar_CmdSetRuleState(This,Name,State) \ + (This)->lpVtbl -> CmdSetRuleState(This,Name,State) + +#define ISpeechRecoGrammar_CmdSetRuleIdState(This,RuleId,State) \ + (This)->lpVtbl -> CmdSetRuleIdState(This,RuleId,State) + +#define ISpeechRecoGrammar_DictationLoad(This,TopicName,LoadOption) \ + (This)->lpVtbl -> DictationLoad(This,TopicName,LoadOption) + +#define ISpeechRecoGrammar_DictationUnload(This) \ + (This)->lpVtbl -> DictationUnload(This) + +#define ISpeechRecoGrammar_DictationSetState(This,State) \ + (This)->lpVtbl -> DictationSetState(This,State) + +#define ISpeechRecoGrammar_SetWordSequenceData(This,Text,TextLength,Info) \ + (This)->lpVtbl -> SetWordSequenceData(This,Text,TextLength,Info) + +#define ISpeechRecoGrammar_SetTextSelection(This,Info) \ + (This)->lpVtbl -> SetTextSelection(This,Info) + +#define ISpeechRecoGrammar_IsPronounceable(This,Word,WordPronounceable) \ + (This)->lpVtbl -> IsPronounceable(This,Word,WordPronounceable) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecoGrammar_get_Id_Proxy( + ISpeechRecoGrammar * This, + /* [retval][out] */ VARIANT *Id); + + +void __RPC_STUB ISpeechRecoGrammar_get_Id_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecoGrammar_get_RecoContext_Proxy( + ISpeechRecoGrammar * This, + /* [retval][out] */ ISpeechRecoContext **RecoContext); + + +void __RPC_STUB ISpeechRecoGrammar_get_RecoContext_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechRecoGrammar_put_State_Proxy( + ISpeechRecoGrammar * This, + /* [in] */ SpeechGrammarState State); + + +void __RPC_STUB ISpeechRecoGrammar_put_State_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecoGrammar_get_State_Proxy( + ISpeechRecoGrammar * This, + /* [retval][out] */ SpeechGrammarState *State); + + +void __RPC_STUB ISpeechRecoGrammar_get_State_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecoGrammar_get_Rules_Proxy( + ISpeechRecoGrammar * This, + /* [retval][out] */ ISpeechGrammarRules **Rules); + + +void __RPC_STUB ISpeechRecoGrammar_get_Rules_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecoGrammar_Reset_Proxy( + ISpeechRecoGrammar * This, + /* [defaultvalue][in] */ SpeechLanguageId NewLanguage); + + +void __RPC_STUB ISpeechRecoGrammar_Reset_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecoGrammar_CmdLoadFromFile_Proxy( + ISpeechRecoGrammar * This, + /* [in] */ const BSTR FileName, + /* [defaultvalue][in] */ SpeechLoadOption LoadOption); + + +void __RPC_STUB ISpeechRecoGrammar_CmdLoadFromFile_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecoGrammar_CmdLoadFromObject_Proxy( + ISpeechRecoGrammar * This, + /* [in] */ const BSTR ClassId, + /* [in] */ const BSTR GrammarName, + /* [defaultvalue][in] */ SpeechLoadOption LoadOption); + + +void __RPC_STUB ISpeechRecoGrammar_CmdLoadFromObject_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecoGrammar_CmdLoadFromResource_Proxy( + ISpeechRecoGrammar * This, + /* [in] */ long hModule, + /* [in] */ VARIANT ResourceName, + /* [in] */ VARIANT ResourceType, + /* [in] */ SpeechLanguageId LanguageId, + /* [defaultvalue][in] */ SpeechLoadOption LoadOption); + + +void __RPC_STUB ISpeechRecoGrammar_CmdLoadFromResource_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecoGrammar_CmdLoadFromMemory_Proxy( + ISpeechRecoGrammar * This, + /* [in] */ VARIANT GrammarData, + /* [defaultvalue][in] */ SpeechLoadOption LoadOption); + + +void __RPC_STUB ISpeechRecoGrammar_CmdLoadFromMemory_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecoGrammar_CmdLoadFromProprietaryGrammar_Proxy( + ISpeechRecoGrammar * This, + /* [in] */ const BSTR ProprietaryGuid, + /* [in] */ const BSTR ProprietaryString, + /* [in] */ VARIANT ProprietaryData, + /* [defaultvalue][in] */ SpeechLoadOption LoadOption); + + +void __RPC_STUB ISpeechRecoGrammar_CmdLoadFromProprietaryGrammar_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecoGrammar_CmdSetRuleState_Proxy( + ISpeechRecoGrammar * This, + /* [in] */ const BSTR Name, + /* [in] */ SpeechRuleState State); + + +void __RPC_STUB ISpeechRecoGrammar_CmdSetRuleState_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecoGrammar_CmdSetRuleIdState_Proxy( + ISpeechRecoGrammar * This, + /* [in] */ long RuleId, + /* [in] */ SpeechRuleState State); + + +void __RPC_STUB ISpeechRecoGrammar_CmdSetRuleIdState_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecoGrammar_DictationLoad_Proxy( + ISpeechRecoGrammar * This, + /* [defaultvalue][in] */ const BSTR TopicName, + /* [defaultvalue][in] */ SpeechLoadOption LoadOption); + + +void __RPC_STUB ISpeechRecoGrammar_DictationLoad_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecoGrammar_DictationUnload_Proxy( + ISpeechRecoGrammar * This); + + +void __RPC_STUB ISpeechRecoGrammar_DictationUnload_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecoGrammar_DictationSetState_Proxy( + ISpeechRecoGrammar * This, + /* [in] */ SpeechRuleState State); + + +void __RPC_STUB ISpeechRecoGrammar_DictationSetState_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecoGrammar_SetWordSequenceData_Proxy( + ISpeechRecoGrammar * This, + /* [in] */ const BSTR Text, + /* [in] */ long TextLength, + /* [in] */ ISpeechTextSelectionInformation *Info); + + +void __RPC_STUB ISpeechRecoGrammar_SetWordSequenceData_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecoGrammar_SetTextSelection_Proxy( + ISpeechRecoGrammar * This, + /* [in] */ ISpeechTextSelectionInformation *Info); + + +void __RPC_STUB ISpeechRecoGrammar_SetTextSelection_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecoGrammar_IsPronounceable_Proxy( + ISpeechRecoGrammar * This, + /* [in] */ const BSTR Word, + /* [retval][out] */ SpeechWordPronounceable *WordPronounceable); + + +void __RPC_STUB ISpeechRecoGrammar_IsPronounceable_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechRecoGrammar_INTERFACE_DEFINED__ */ + + +#ifndef ___ISpeechRecoContextEvents_DISPINTERFACE_DEFINED__ +#define ___ISpeechRecoContextEvents_DISPINTERFACE_DEFINED__ + +/* dispinterface _ISpeechRecoContextEvents */ +/* [uuid] */ + + +EXTERN_C const IID DIID__ISpeechRecoContextEvents; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("7B8FCB42-0E9D-4f00-A048-7B04D6179D3D") + _ISpeechRecoContextEvents : public IDispatch + { + }; + +#else /* C style interface */ + + typedef struct _ISpeechRecoContextEventsVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + _ISpeechRecoContextEvents * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + _ISpeechRecoContextEvents * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + _ISpeechRecoContextEvents * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + _ISpeechRecoContextEvents * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + _ISpeechRecoContextEvents * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + _ISpeechRecoContextEvents * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + _ISpeechRecoContextEvents * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + END_INTERFACE + } _ISpeechRecoContextEventsVtbl; + + interface _ISpeechRecoContextEvents + { + CONST_VTBL struct _ISpeechRecoContextEventsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define _ISpeechRecoContextEvents_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define _ISpeechRecoContextEvents_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define _ISpeechRecoContextEvents_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define _ISpeechRecoContextEvents_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define _ISpeechRecoContextEvents_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define _ISpeechRecoContextEvents_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define _ISpeechRecoContextEvents_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + +#endif /* ___ISpeechRecoContextEvents_DISPINTERFACE_DEFINED__ */ + + +#ifndef __ISpeechGrammarRule_INTERFACE_DEFINED__ +#define __ISpeechGrammarRule_INTERFACE_DEFINED__ + +/* interface ISpeechGrammarRule */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechGrammarRule; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("AFE719CF-5DD1-44f2-999C-7A399F1CFCCC") + ISpeechGrammarRule : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Attributes( + /* [retval][out] */ SpeechRuleAttributes *Attributes) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_InitialState( + /* [retval][out] */ ISpeechGrammarRuleState **State) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Name( + /* [retval][out] */ BSTR *Name) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Id( + /* [retval][out] */ long *Id) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE Clear( void) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE AddResource( + /* [in] */ const BSTR ResourceName, + /* [in] */ const BSTR ResourceValue) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE AddState( + /* [retval][out] */ ISpeechGrammarRuleState **State) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechGrammarRuleVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechGrammarRule * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechGrammarRule * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechGrammarRule * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechGrammarRule * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechGrammarRule * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechGrammarRule * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechGrammarRule * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Attributes )( + ISpeechGrammarRule * This, + /* [retval][out] */ SpeechRuleAttributes *Attributes); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_InitialState )( + ISpeechGrammarRule * This, + /* [retval][out] */ ISpeechGrammarRuleState **State); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Name )( + ISpeechGrammarRule * This, + /* [retval][out] */ BSTR *Name); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Id )( + ISpeechGrammarRule * This, + /* [retval][out] */ long *Id); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Clear )( + ISpeechGrammarRule * This); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *AddResource )( + ISpeechGrammarRule * This, + /* [in] */ const BSTR ResourceName, + /* [in] */ const BSTR ResourceValue); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *AddState )( + ISpeechGrammarRule * This, + /* [retval][out] */ ISpeechGrammarRuleState **State); + + END_INTERFACE + } ISpeechGrammarRuleVtbl; + + interface ISpeechGrammarRule + { + CONST_VTBL struct ISpeechGrammarRuleVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechGrammarRule_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechGrammarRule_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechGrammarRule_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechGrammarRule_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechGrammarRule_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechGrammarRule_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechGrammarRule_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechGrammarRule_get_Attributes(This,Attributes) \ + (This)->lpVtbl -> get_Attributes(This,Attributes) + +#define ISpeechGrammarRule_get_InitialState(This,State) \ + (This)->lpVtbl -> get_InitialState(This,State) + +#define ISpeechGrammarRule_get_Name(This,Name) \ + (This)->lpVtbl -> get_Name(This,Name) + +#define ISpeechGrammarRule_get_Id(This,Id) \ + (This)->lpVtbl -> get_Id(This,Id) + +#define ISpeechGrammarRule_Clear(This) \ + (This)->lpVtbl -> Clear(This) + +#define ISpeechGrammarRule_AddResource(This,ResourceName,ResourceValue) \ + (This)->lpVtbl -> AddResource(This,ResourceName,ResourceValue) + +#define ISpeechGrammarRule_AddState(This,State) \ + (This)->lpVtbl -> AddState(This,State) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRule_get_Attributes_Proxy( + ISpeechGrammarRule * This, + /* [retval][out] */ SpeechRuleAttributes *Attributes); + + +void __RPC_STUB ISpeechGrammarRule_get_Attributes_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRule_get_InitialState_Proxy( + ISpeechGrammarRule * This, + /* [retval][out] */ ISpeechGrammarRuleState **State); + + +void __RPC_STUB ISpeechGrammarRule_get_InitialState_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRule_get_Name_Proxy( + ISpeechGrammarRule * This, + /* [retval][out] */ BSTR *Name); + + +void __RPC_STUB ISpeechGrammarRule_get_Name_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRule_get_Id_Proxy( + ISpeechGrammarRule * This, + /* [retval][out] */ long *Id); + + +void __RPC_STUB ISpeechGrammarRule_get_Id_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRule_Clear_Proxy( + ISpeechGrammarRule * This); + + +void __RPC_STUB ISpeechGrammarRule_Clear_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRule_AddResource_Proxy( + ISpeechGrammarRule * This, + /* [in] */ const BSTR ResourceName, + /* [in] */ const BSTR ResourceValue); + + +void __RPC_STUB ISpeechGrammarRule_AddResource_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRule_AddState_Proxy( + ISpeechGrammarRule * This, + /* [retval][out] */ ISpeechGrammarRuleState **State); + + +void __RPC_STUB ISpeechGrammarRule_AddState_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechGrammarRule_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechGrammarRules_INTERFACE_DEFINED__ +#define __ISpeechGrammarRules_INTERFACE_DEFINED__ + +/* interface ISpeechGrammarRules */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechGrammarRules; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("6FFA3B44-FC2D-40d1-8AFC-32911C7F1AD1") + ISpeechGrammarRules : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( + /* [retval][out] */ long *Count) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE FindRule( + /* [in] */ VARIANT RuleNameOrId, + /* [retval][out] */ ISpeechGrammarRule **Rule) = 0; + + virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( + /* [in] */ long Index, + /* [retval][out] */ ISpeechGrammarRule **Rule) = 0; + + virtual /* [restricted][helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get__NewEnum( + /* [retval][out] */ IUnknown **EnumVARIANT) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Dynamic( + /* [retval][out] */ VARIANT_BOOL *Dynamic) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE Add( + /* [in] */ BSTR RuleName, + /* [in] */ SpeechRuleAttributes Attributes, + /* [defaultvalue][in] */ long RuleId, + /* [retval][out] */ ISpeechGrammarRule **Rule) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE Commit( void) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE CommitAndSave( + /* [out] */ BSTR *ErrorText, + /* [retval][out] */ VARIANT *SaveStream) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechGrammarRulesVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechGrammarRules * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechGrammarRules * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechGrammarRules * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechGrammarRules * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechGrammarRules * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechGrammarRules * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechGrammarRules * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( + ISpeechGrammarRules * This, + /* [retval][out] */ long *Count); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *FindRule )( + ISpeechGrammarRules * This, + /* [in] */ VARIANT RuleNameOrId, + /* [retval][out] */ ISpeechGrammarRule **Rule); + + /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( + ISpeechGrammarRules * This, + /* [in] */ long Index, + /* [retval][out] */ ISpeechGrammarRule **Rule); + + /* [restricted][helpstring][propget][id] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( + ISpeechGrammarRules * This, + /* [retval][out] */ IUnknown **EnumVARIANT); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Dynamic )( + ISpeechGrammarRules * This, + /* [retval][out] */ VARIANT_BOOL *Dynamic); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Add )( + ISpeechGrammarRules * This, + /* [in] */ BSTR RuleName, + /* [in] */ SpeechRuleAttributes Attributes, + /* [defaultvalue][in] */ long RuleId, + /* [retval][out] */ ISpeechGrammarRule **Rule); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Commit )( + ISpeechGrammarRules * This); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *CommitAndSave )( + ISpeechGrammarRules * This, + /* [out] */ BSTR *ErrorText, + /* [retval][out] */ VARIANT *SaveStream); + + END_INTERFACE + } ISpeechGrammarRulesVtbl; + + interface ISpeechGrammarRules + { + CONST_VTBL struct ISpeechGrammarRulesVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechGrammarRules_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechGrammarRules_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechGrammarRules_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechGrammarRules_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechGrammarRules_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechGrammarRules_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechGrammarRules_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechGrammarRules_get_Count(This,Count) \ + (This)->lpVtbl -> get_Count(This,Count) + +#define ISpeechGrammarRules_FindRule(This,RuleNameOrId,Rule) \ + (This)->lpVtbl -> FindRule(This,RuleNameOrId,Rule) + +#define ISpeechGrammarRules_Item(This,Index,Rule) \ + (This)->lpVtbl -> Item(This,Index,Rule) + +#define ISpeechGrammarRules_get__NewEnum(This,EnumVARIANT) \ + (This)->lpVtbl -> get__NewEnum(This,EnumVARIANT) + +#define ISpeechGrammarRules_get_Dynamic(This,Dynamic) \ + (This)->lpVtbl -> get_Dynamic(This,Dynamic) + +#define ISpeechGrammarRules_Add(This,RuleName,Attributes,RuleId,Rule) \ + (This)->lpVtbl -> Add(This,RuleName,Attributes,RuleId,Rule) + +#define ISpeechGrammarRules_Commit(This) \ + (This)->lpVtbl -> Commit(This) + +#define ISpeechGrammarRules_CommitAndSave(This,ErrorText,SaveStream) \ + (This)->lpVtbl -> CommitAndSave(This,ErrorText,SaveStream) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRules_get_Count_Proxy( + ISpeechGrammarRules * This, + /* [retval][out] */ long *Count); + + +void __RPC_STUB ISpeechGrammarRules_get_Count_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRules_FindRule_Proxy( + ISpeechGrammarRules * This, + /* [in] */ VARIANT RuleNameOrId, + /* [retval][out] */ ISpeechGrammarRule **Rule); + + +void __RPC_STUB ISpeechGrammarRules_FindRule_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring][id] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRules_Item_Proxy( + ISpeechGrammarRules * This, + /* [in] */ long Index, + /* [retval][out] */ ISpeechGrammarRule **Rule); + + +void __RPC_STUB ISpeechGrammarRules_Item_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [restricted][helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRules_get__NewEnum_Proxy( + ISpeechGrammarRules * This, + /* [retval][out] */ IUnknown **EnumVARIANT); + + +void __RPC_STUB ISpeechGrammarRules_get__NewEnum_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRules_get_Dynamic_Proxy( + ISpeechGrammarRules * This, + /* [retval][out] */ VARIANT_BOOL *Dynamic); + + +void __RPC_STUB ISpeechGrammarRules_get_Dynamic_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRules_Add_Proxy( + ISpeechGrammarRules * This, + /* [in] */ BSTR RuleName, + /* [in] */ SpeechRuleAttributes Attributes, + /* [defaultvalue][in] */ long RuleId, + /* [retval][out] */ ISpeechGrammarRule **Rule); + + +void __RPC_STUB ISpeechGrammarRules_Add_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRules_Commit_Proxy( + ISpeechGrammarRules * This); + + +void __RPC_STUB ISpeechGrammarRules_Commit_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRules_CommitAndSave_Proxy( + ISpeechGrammarRules * This, + /* [out] */ BSTR *ErrorText, + /* [retval][out] */ VARIANT *SaveStream); + + +void __RPC_STUB ISpeechGrammarRules_CommitAndSave_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechGrammarRules_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechGrammarRuleState_INTERFACE_DEFINED__ +#define __ISpeechGrammarRuleState_INTERFACE_DEFINED__ + +/* interface ISpeechGrammarRuleState */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechGrammarRuleState; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("D4286F2C-EE67-45ae-B928-28D695362EDA") + ISpeechGrammarRuleState : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Rule( + /* [retval][out] */ ISpeechGrammarRule **Rule) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Transitions( + /* [retval][out] */ ISpeechGrammarRuleStateTransitions **Transitions) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE AddWordTransition( + /* [in] */ ISpeechGrammarRuleState *DestState, + /* [in] */ const BSTR Words, + /* [defaultvalue][in] */ const BSTR Separators = L" ", + /* [defaultvalue][in] */ SpeechGrammarWordType Type = SGLexical, + /* [defaultvalue][in] */ const BSTR PropertyName = L"", + /* [defaultvalue][in] */ long PropertyId = 0, + /* [defaultvalue][in] */ VARIANT *PropertyValue = 0, + /* [defaultvalue][in] */ float Weight = 1) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE AddRuleTransition( + /* [in] */ ISpeechGrammarRuleState *DestinationState, + /* [in] */ ISpeechGrammarRule *Rule, + /* [defaultvalue][in] */ const BSTR PropertyName = L"", + /* [defaultvalue][in] */ long PropertyId = 0, + /* [defaultvalue][in] */ VARIANT *PropertyValue = 0, + /* [defaultvalue][in] */ float Weight = 1) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE AddSpecialTransition( + /* [in] */ ISpeechGrammarRuleState *DestinationState, + /* [in] */ SpeechSpecialTransitionType Type, + /* [defaultvalue][in] */ const BSTR PropertyName = L"", + /* [defaultvalue][in] */ long PropertyId = 0, + /* [defaultvalue][in] */ VARIANT *PropertyValue = 0, + /* [defaultvalue][in] */ float Weight = 1) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechGrammarRuleStateVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechGrammarRuleState * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechGrammarRuleState * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechGrammarRuleState * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechGrammarRuleState * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechGrammarRuleState * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechGrammarRuleState * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechGrammarRuleState * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Rule )( + ISpeechGrammarRuleState * This, + /* [retval][out] */ ISpeechGrammarRule **Rule); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Transitions )( + ISpeechGrammarRuleState * This, + /* [retval][out] */ ISpeechGrammarRuleStateTransitions **Transitions); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *AddWordTransition )( + ISpeechGrammarRuleState * This, + /* [in] */ ISpeechGrammarRuleState *DestState, + /* [in] */ const BSTR Words, + /* [defaultvalue][in] */ const BSTR Separators, + /* [defaultvalue][in] */ SpeechGrammarWordType Type, + /* [defaultvalue][in] */ const BSTR PropertyName, + /* [defaultvalue][in] */ long PropertyId, + /* [defaultvalue][in] */ VARIANT *PropertyValue, + /* [defaultvalue][in] */ float Weight); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *AddRuleTransition )( + ISpeechGrammarRuleState * This, + /* [in] */ ISpeechGrammarRuleState *DestinationState, + /* [in] */ ISpeechGrammarRule *Rule, + /* [defaultvalue][in] */ const BSTR PropertyName, + /* [defaultvalue][in] */ long PropertyId, + /* [defaultvalue][in] */ VARIANT *PropertyValue, + /* [defaultvalue][in] */ float Weight); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *AddSpecialTransition )( + ISpeechGrammarRuleState * This, + /* [in] */ ISpeechGrammarRuleState *DestinationState, + /* [in] */ SpeechSpecialTransitionType Type, + /* [defaultvalue][in] */ const BSTR PropertyName, + /* [defaultvalue][in] */ long PropertyId, + /* [defaultvalue][in] */ VARIANT *PropertyValue, + /* [defaultvalue][in] */ float Weight); + + END_INTERFACE + } ISpeechGrammarRuleStateVtbl; + + interface ISpeechGrammarRuleState + { + CONST_VTBL struct ISpeechGrammarRuleStateVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechGrammarRuleState_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechGrammarRuleState_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechGrammarRuleState_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechGrammarRuleState_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechGrammarRuleState_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechGrammarRuleState_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechGrammarRuleState_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechGrammarRuleState_get_Rule(This,Rule) \ + (This)->lpVtbl -> get_Rule(This,Rule) + +#define ISpeechGrammarRuleState_get_Transitions(This,Transitions) \ + (This)->lpVtbl -> get_Transitions(This,Transitions) + +#define ISpeechGrammarRuleState_AddWordTransition(This,DestState,Words,Separators,Type,PropertyName,PropertyId,PropertyValue,Weight) \ + (This)->lpVtbl -> AddWordTransition(This,DestState,Words,Separators,Type,PropertyName,PropertyId,PropertyValue,Weight) + +#define ISpeechGrammarRuleState_AddRuleTransition(This,DestinationState,Rule,PropertyName,PropertyId,PropertyValue,Weight) \ + (This)->lpVtbl -> AddRuleTransition(This,DestinationState,Rule,PropertyName,PropertyId,PropertyValue,Weight) + +#define ISpeechGrammarRuleState_AddSpecialTransition(This,DestinationState,Type,PropertyName,PropertyId,PropertyValue,Weight) \ + (This)->lpVtbl -> AddSpecialTransition(This,DestinationState,Type,PropertyName,PropertyId,PropertyValue,Weight) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRuleState_get_Rule_Proxy( + ISpeechGrammarRuleState * This, + /* [retval][out] */ ISpeechGrammarRule **Rule); + + +void __RPC_STUB ISpeechGrammarRuleState_get_Rule_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRuleState_get_Transitions_Proxy( + ISpeechGrammarRuleState * This, + /* [retval][out] */ ISpeechGrammarRuleStateTransitions **Transitions); + + +void __RPC_STUB ISpeechGrammarRuleState_get_Transitions_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRuleState_AddWordTransition_Proxy( + ISpeechGrammarRuleState * This, + /* [in] */ ISpeechGrammarRuleState *DestState, + /* [in] */ const BSTR Words, + /* [defaultvalue][in] */ const BSTR Separators, + /* [defaultvalue][in] */ SpeechGrammarWordType Type, + /* [defaultvalue][in] */ const BSTR PropertyName, + /* [defaultvalue][in] */ long PropertyId, + /* [defaultvalue][in] */ VARIANT *PropertyValue, + /* [defaultvalue][in] */ float Weight); + + +void __RPC_STUB ISpeechGrammarRuleState_AddWordTransition_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRuleState_AddRuleTransition_Proxy( + ISpeechGrammarRuleState * This, + /* [in] */ ISpeechGrammarRuleState *DestinationState, + /* [in] */ ISpeechGrammarRule *Rule, + /* [defaultvalue][in] */ const BSTR PropertyName, + /* [defaultvalue][in] */ long PropertyId, + /* [defaultvalue][in] */ VARIANT *PropertyValue, + /* [defaultvalue][in] */ float Weight); + + +void __RPC_STUB ISpeechGrammarRuleState_AddRuleTransition_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRuleState_AddSpecialTransition_Proxy( + ISpeechGrammarRuleState * This, + /* [in] */ ISpeechGrammarRuleState *DestinationState, + /* [in] */ SpeechSpecialTransitionType Type, + /* [defaultvalue][in] */ const BSTR PropertyName, + /* [defaultvalue][in] */ long PropertyId, + /* [defaultvalue][in] */ VARIANT *PropertyValue, + /* [defaultvalue][in] */ float Weight); + + +void __RPC_STUB ISpeechGrammarRuleState_AddSpecialTransition_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechGrammarRuleState_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechGrammarRuleStateTransition_INTERFACE_DEFINED__ +#define __ISpeechGrammarRuleStateTransition_INTERFACE_DEFINED__ + +/* interface ISpeechGrammarRuleStateTransition */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechGrammarRuleStateTransition; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("CAFD1DB1-41D1-4a06-9863-E2E81DA17A9A") + ISpeechGrammarRuleStateTransition : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Type( + /* [retval][out] */ SpeechGrammarRuleStateTransitionType *Type) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Text( + /* [retval][out] */ BSTR *Text) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Rule( + /* [retval][out] */ ISpeechGrammarRule **Rule) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Weight( + /* [retval][out] */ VARIANT *Weight) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_PropertyName( + /* [retval][out] */ BSTR *PropertyName) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_PropertyId( + /* [retval][out] */ long *PropertyId) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_PropertyValue( + /* [retval][out] */ VARIANT *PropertyValue) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_NextState( + /* [retval][out] */ ISpeechGrammarRuleState **NextState) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechGrammarRuleStateTransitionVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechGrammarRuleStateTransition * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechGrammarRuleStateTransition * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechGrammarRuleStateTransition * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechGrammarRuleStateTransition * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechGrammarRuleStateTransition * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechGrammarRuleStateTransition * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechGrammarRuleStateTransition * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Type )( + ISpeechGrammarRuleStateTransition * This, + /* [retval][out] */ SpeechGrammarRuleStateTransitionType *Type); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Text )( + ISpeechGrammarRuleStateTransition * This, + /* [retval][out] */ BSTR *Text); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Rule )( + ISpeechGrammarRuleStateTransition * This, + /* [retval][out] */ ISpeechGrammarRule **Rule); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Weight )( + ISpeechGrammarRuleStateTransition * This, + /* [retval][out] */ VARIANT *Weight); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PropertyName )( + ISpeechGrammarRuleStateTransition * This, + /* [retval][out] */ BSTR *PropertyName); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PropertyId )( + ISpeechGrammarRuleStateTransition * This, + /* [retval][out] */ long *PropertyId); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PropertyValue )( + ISpeechGrammarRuleStateTransition * This, + /* [retval][out] */ VARIANT *PropertyValue); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_NextState )( + ISpeechGrammarRuleStateTransition * This, + /* [retval][out] */ ISpeechGrammarRuleState **NextState); + + END_INTERFACE + } ISpeechGrammarRuleStateTransitionVtbl; + + interface ISpeechGrammarRuleStateTransition + { + CONST_VTBL struct ISpeechGrammarRuleStateTransitionVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechGrammarRuleStateTransition_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechGrammarRuleStateTransition_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechGrammarRuleStateTransition_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechGrammarRuleStateTransition_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechGrammarRuleStateTransition_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechGrammarRuleStateTransition_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechGrammarRuleStateTransition_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechGrammarRuleStateTransition_get_Type(This,Type) \ + (This)->lpVtbl -> get_Type(This,Type) + +#define ISpeechGrammarRuleStateTransition_get_Text(This,Text) \ + (This)->lpVtbl -> get_Text(This,Text) + +#define ISpeechGrammarRuleStateTransition_get_Rule(This,Rule) \ + (This)->lpVtbl -> get_Rule(This,Rule) + +#define ISpeechGrammarRuleStateTransition_get_Weight(This,Weight) \ + (This)->lpVtbl -> get_Weight(This,Weight) + +#define ISpeechGrammarRuleStateTransition_get_PropertyName(This,PropertyName) \ + (This)->lpVtbl -> get_PropertyName(This,PropertyName) + +#define ISpeechGrammarRuleStateTransition_get_PropertyId(This,PropertyId) \ + (This)->lpVtbl -> get_PropertyId(This,PropertyId) + +#define ISpeechGrammarRuleStateTransition_get_PropertyValue(This,PropertyValue) \ + (This)->lpVtbl -> get_PropertyValue(This,PropertyValue) + +#define ISpeechGrammarRuleStateTransition_get_NextState(This,NextState) \ + (This)->lpVtbl -> get_NextState(This,NextState) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRuleStateTransition_get_Type_Proxy( + ISpeechGrammarRuleStateTransition * This, + /* [retval][out] */ SpeechGrammarRuleStateTransitionType *Type); + + +void __RPC_STUB ISpeechGrammarRuleStateTransition_get_Type_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRuleStateTransition_get_Text_Proxy( + ISpeechGrammarRuleStateTransition * This, + /* [retval][out] */ BSTR *Text); + + +void __RPC_STUB ISpeechGrammarRuleStateTransition_get_Text_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRuleStateTransition_get_Rule_Proxy( + ISpeechGrammarRuleStateTransition * This, + /* [retval][out] */ ISpeechGrammarRule **Rule); + + +void __RPC_STUB ISpeechGrammarRuleStateTransition_get_Rule_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRuleStateTransition_get_Weight_Proxy( + ISpeechGrammarRuleStateTransition * This, + /* [retval][out] */ VARIANT *Weight); + + +void __RPC_STUB ISpeechGrammarRuleStateTransition_get_Weight_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRuleStateTransition_get_PropertyName_Proxy( + ISpeechGrammarRuleStateTransition * This, + /* [retval][out] */ BSTR *PropertyName); + + +void __RPC_STUB ISpeechGrammarRuleStateTransition_get_PropertyName_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRuleStateTransition_get_PropertyId_Proxy( + ISpeechGrammarRuleStateTransition * This, + /* [retval][out] */ long *PropertyId); + + +void __RPC_STUB ISpeechGrammarRuleStateTransition_get_PropertyId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRuleStateTransition_get_PropertyValue_Proxy( + ISpeechGrammarRuleStateTransition * This, + /* [retval][out] */ VARIANT *PropertyValue); + + +void __RPC_STUB ISpeechGrammarRuleStateTransition_get_PropertyValue_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRuleStateTransition_get_NextState_Proxy( + ISpeechGrammarRuleStateTransition * This, + /* [retval][out] */ ISpeechGrammarRuleState **NextState); + + +void __RPC_STUB ISpeechGrammarRuleStateTransition_get_NextState_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechGrammarRuleStateTransition_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechGrammarRuleStateTransitions_INTERFACE_DEFINED__ +#define __ISpeechGrammarRuleStateTransitions_INTERFACE_DEFINED__ + +/* interface ISpeechGrammarRuleStateTransitions */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechGrammarRuleStateTransitions; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("EABCE657-75BC-44a2-AA7F-C56476742963") + ISpeechGrammarRuleStateTransitions : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( + /* [retval][out] */ long *Count) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE Item( + /* [in] */ long Index, + /* [retval][out] */ ISpeechGrammarRuleStateTransition **Transition) = 0; + + virtual /* [id][restricted][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( + /* [retval][out] */ IUnknown **EnumVARIANT) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechGrammarRuleStateTransitionsVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechGrammarRuleStateTransitions * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechGrammarRuleStateTransitions * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechGrammarRuleStateTransitions * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechGrammarRuleStateTransitions * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechGrammarRuleStateTransitions * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechGrammarRuleStateTransitions * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechGrammarRuleStateTransitions * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( + ISpeechGrammarRuleStateTransitions * This, + /* [retval][out] */ long *Count); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Item )( + ISpeechGrammarRuleStateTransitions * This, + /* [in] */ long Index, + /* [retval][out] */ ISpeechGrammarRuleStateTransition **Transition); + + /* [id][restricted][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( + ISpeechGrammarRuleStateTransitions * This, + /* [retval][out] */ IUnknown **EnumVARIANT); + + END_INTERFACE + } ISpeechGrammarRuleStateTransitionsVtbl; + + interface ISpeechGrammarRuleStateTransitions + { + CONST_VTBL struct ISpeechGrammarRuleStateTransitionsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechGrammarRuleStateTransitions_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechGrammarRuleStateTransitions_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechGrammarRuleStateTransitions_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechGrammarRuleStateTransitions_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechGrammarRuleStateTransitions_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechGrammarRuleStateTransitions_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechGrammarRuleStateTransitions_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechGrammarRuleStateTransitions_get_Count(This,Count) \ + (This)->lpVtbl -> get_Count(This,Count) + +#define ISpeechGrammarRuleStateTransitions_Item(This,Index,Transition) \ + (This)->lpVtbl -> Item(This,Index,Transition) + +#define ISpeechGrammarRuleStateTransitions_get__NewEnum(This,EnumVARIANT) \ + (This)->lpVtbl -> get__NewEnum(This,EnumVARIANT) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRuleStateTransitions_get_Count_Proxy( + ISpeechGrammarRuleStateTransitions * This, + /* [retval][out] */ long *Count); + + +void __RPC_STUB ISpeechGrammarRuleStateTransitions_get_Count_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRuleStateTransitions_Item_Proxy( + ISpeechGrammarRuleStateTransitions * This, + /* [in] */ long Index, + /* [retval][out] */ ISpeechGrammarRuleStateTransition **Transition); + + +void __RPC_STUB ISpeechGrammarRuleStateTransitions_Item_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][restricted][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechGrammarRuleStateTransitions_get__NewEnum_Proxy( + ISpeechGrammarRuleStateTransitions * This, + /* [retval][out] */ IUnknown **EnumVARIANT); + + +void __RPC_STUB ISpeechGrammarRuleStateTransitions_get__NewEnum_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechGrammarRuleStateTransitions_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechTextSelectionInformation_INTERFACE_DEFINED__ +#define __ISpeechTextSelectionInformation_INTERFACE_DEFINED__ + +/* interface ISpeechTextSelectionInformation */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechTextSelectionInformation; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("3B9C7E7A-6EEE-4DED-9092-11657279ADBE") + ISpeechTextSelectionInformation : public IDispatch + { + public: + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_ActiveOffset( + /* [in] */ long ActiveOffset) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_ActiveOffset( + /* [retval][out] */ long *ActiveOffset) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_ActiveLength( + /* [in] */ long ActiveLength) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_ActiveLength( + /* [retval][out] */ long *ActiveLength) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_SelectionOffset( + /* [in] */ long SelectionOffset) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_SelectionOffset( + /* [retval][out] */ long *SelectionOffset) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_SelectionLength( + /* [in] */ long SelectionLength) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_SelectionLength( + /* [retval][out] */ long *SelectionLength) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechTextSelectionInformationVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechTextSelectionInformation * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechTextSelectionInformation * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechTextSelectionInformation * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechTextSelectionInformation * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechTextSelectionInformation * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechTextSelectionInformation * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechTextSelectionInformation * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_ActiveOffset )( + ISpeechTextSelectionInformation * This, + /* [in] */ long ActiveOffset); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_ActiveOffset )( + ISpeechTextSelectionInformation * This, + /* [retval][out] */ long *ActiveOffset); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_ActiveLength )( + ISpeechTextSelectionInformation * This, + /* [in] */ long ActiveLength); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_ActiveLength )( + ISpeechTextSelectionInformation * This, + /* [retval][out] */ long *ActiveLength); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_SelectionOffset )( + ISpeechTextSelectionInformation * This, + /* [in] */ long SelectionOffset); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_SelectionOffset )( + ISpeechTextSelectionInformation * This, + /* [retval][out] */ long *SelectionOffset); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_SelectionLength )( + ISpeechTextSelectionInformation * This, + /* [in] */ long SelectionLength); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_SelectionLength )( + ISpeechTextSelectionInformation * This, + /* [retval][out] */ long *SelectionLength); + + END_INTERFACE + } ISpeechTextSelectionInformationVtbl; + + interface ISpeechTextSelectionInformation + { + CONST_VTBL struct ISpeechTextSelectionInformationVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechTextSelectionInformation_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechTextSelectionInformation_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechTextSelectionInformation_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechTextSelectionInformation_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechTextSelectionInformation_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechTextSelectionInformation_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechTextSelectionInformation_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechTextSelectionInformation_put_ActiveOffset(This,ActiveOffset) \ + (This)->lpVtbl -> put_ActiveOffset(This,ActiveOffset) + +#define ISpeechTextSelectionInformation_get_ActiveOffset(This,ActiveOffset) \ + (This)->lpVtbl -> get_ActiveOffset(This,ActiveOffset) + +#define ISpeechTextSelectionInformation_put_ActiveLength(This,ActiveLength) \ + (This)->lpVtbl -> put_ActiveLength(This,ActiveLength) + +#define ISpeechTextSelectionInformation_get_ActiveLength(This,ActiveLength) \ + (This)->lpVtbl -> get_ActiveLength(This,ActiveLength) + +#define ISpeechTextSelectionInformation_put_SelectionOffset(This,SelectionOffset) \ + (This)->lpVtbl -> put_SelectionOffset(This,SelectionOffset) + +#define ISpeechTextSelectionInformation_get_SelectionOffset(This,SelectionOffset) \ + (This)->lpVtbl -> get_SelectionOffset(This,SelectionOffset) + +#define ISpeechTextSelectionInformation_put_SelectionLength(This,SelectionLength) \ + (This)->lpVtbl -> put_SelectionLength(This,SelectionLength) + +#define ISpeechTextSelectionInformation_get_SelectionLength(This,SelectionLength) \ + (This)->lpVtbl -> get_SelectionLength(This,SelectionLength) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechTextSelectionInformation_put_ActiveOffset_Proxy( + ISpeechTextSelectionInformation * This, + /* [in] */ long ActiveOffset); + + +void __RPC_STUB ISpeechTextSelectionInformation_put_ActiveOffset_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechTextSelectionInformation_get_ActiveOffset_Proxy( + ISpeechTextSelectionInformation * This, + /* [retval][out] */ long *ActiveOffset); + + +void __RPC_STUB ISpeechTextSelectionInformation_get_ActiveOffset_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechTextSelectionInformation_put_ActiveLength_Proxy( + ISpeechTextSelectionInformation * This, + /* [in] */ long ActiveLength); + + +void __RPC_STUB ISpeechTextSelectionInformation_put_ActiveLength_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechTextSelectionInformation_get_ActiveLength_Proxy( + ISpeechTextSelectionInformation * This, + /* [retval][out] */ long *ActiveLength); + + +void __RPC_STUB ISpeechTextSelectionInformation_get_ActiveLength_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechTextSelectionInformation_put_SelectionOffset_Proxy( + ISpeechTextSelectionInformation * This, + /* [in] */ long SelectionOffset); + + +void __RPC_STUB ISpeechTextSelectionInformation_put_SelectionOffset_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechTextSelectionInformation_get_SelectionOffset_Proxy( + ISpeechTextSelectionInformation * This, + /* [retval][out] */ long *SelectionOffset); + + +void __RPC_STUB ISpeechTextSelectionInformation_get_SelectionOffset_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechTextSelectionInformation_put_SelectionLength_Proxy( + ISpeechTextSelectionInformation * This, + /* [in] */ long SelectionLength); + + +void __RPC_STUB ISpeechTextSelectionInformation_put_SelectionLength_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechTextSelectionInformation_get_SelectionLength_Proxy( + ISpeechTextSelectionInformation * This, + /* [retval][out] */ long *SelectionLength); + + +void __RPC_STUB ISpeechTextSelectionInformation_get_SelectionLength_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechTextSelectionInformation_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechRecoResult_INTERFACE_DEFINED__ +#define __ISpeechRecoResult_INTERFACE_DEFINED__ + +/* interface ISpeechRecoResult */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechRecoResult; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("ED2879CF-CED9-4ee6-A534-DE0191D5468D") + ISpeechRecoResult : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_RecoContext( + /* [retval][out] */ ISpeechRecoContext **RecoContext) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Times( + /* [retval][out] */ ISpeechRecoResultTimes **Times) = 0; + + virtual /* [id][helpstring][propputref] */ HRESULT STDMETHODCALLTYPE putref_AudioFormat( + /* [in] */ ISpeechAudioFormat *Format) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_AudioFormat( + /* [retval][out] */ ISpeechAudioFormat **Format) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_PhraseInfo( + /* [retval][out] */ ISpeechPhraseInfo **PhraseInfo) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE Alternates( + /* [in] */ long RequestCount, + /* [defaultvalue][in] */ long StartElement, + /* [defaultvalue][in] */ long Elements, + /* [retval][out] */ ISpeechPhraseAlternates **Alternates) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE Audio( + /* [defaultvalue][in] */ long StartElement, + /* [defaultvalue][in] */ long Elements, + /* [retval][out] */ ISpeechMemoryStream **Stream) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE SpeakAudio( + /* [defaultvalue][in] */ long StartElement, + /* [defaultvalue][in] */ long Elements, + /* [defaultvalue][in] */ SpeechVoiceSpeakFlags Flags, + /* [retval][out] */ long *StreamNumber) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE SaveToMemory( + /* [retval][out] */ VARIANT *ResultBlock) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE DiscardResultInfo( + /* [in] */ SpeechDiscardType ValueTypes) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechRecoResultVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechRecoResult * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechRecoResult * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechRecoResult * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechRecoResult * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechRecoResult * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechRecoResult * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechRecoResult * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_RecoContext )( + ISpeechRecoResult * This, + /* [retval][out] */ ISpeechRecoContext **RecoContext); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Times )( + ISpeechRecoResult * This, + /* [retval][out] */ ISpeechRecoResultTimes **Times); + + /* [id][helpstring][propputref] */ HRESULT ( STDMETHODCALLTYPE *putref_AudioFormat )( + ISpeechRecoResult * This, + /* [in] */ ISpeechAudioFormat *Format); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_AudioFormat )( + ISpeechRecoResult * This, + /* [retval][out] */ ISpeechAudioFormat **Format); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PhraseInfo )( + ISpeechRecoResult * This, + /* [retval][out] */ ISpeechPhraseInfo **PhraseInfo); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Alternates )( + ISpeechRecoResult * This, + /* [in] */ long RequestCount, + /* [defaultvalue][in] */ long StartElement, + /* [defaultvalue][in] */ long Elements, + /* [retval][out] */ ISpeechPhraseAlternates **Alternates); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Audio )( + ISpeechRecoResult * This, + /* [defaultvalue][in] */ long StartElement, + /* [defaultvalue][in] */ long Elements, + /* [retval][out] */ ISpeechMemoryStream **Stream); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *SpeakAudio )( + ISpeechRecoResult * This, + /* [defaultvalue][in] */ long StartElement, + /* [defaultvalue][in] */ long Elements, + /* [defaultvalue][in] */ SpeechVoiceSpeakFlags Flags, + /* [retval][out] */ long *StreamNumber); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *SaveToMemory )( + ISpeechRecoResult * This, + /* [retval][out] */ VARIANT *ResultBlock); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *DiscardResultInfo )( + ISpeechRecoResult * This, + /* [in] */ SpeechDiscardType ValueTypes); + + END_INTERFACE + } ISpeechRecoResultVtbl; + + interface ISpeechRecoResult + { + CONST_VTBL struct ISpeechRecoResultVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechRecoResult_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechRecoResult_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechRecoResult_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechRecoResult_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechRecoResult_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechRecoResult_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechRecoResult_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechRecoResult_get_RecoContext(This,RecoContext) \ + (This)->lpVtbl -> get_RecoContext(This,RecoContext) + +#define ISpeechRecoResult_get_Times(This,Times) \ + (This)->lpVtbl -> get_Times(This,Times) + +#define ISpeechRecoResult_putref_AudioFormat(This,Format) \ + (This)->lpVtbl -> putref_AudioFormat(This,Format) + +#define ISpeechRecoResult_get_AudioFormat(This,Format) \ + (This)->lpVtbl -> get_AudioFormat(This,Format) + +#define ISpeechRecoResult_get_PhraseInfo(This,PhraseInfo) \ + (This)->lpVtbl -> get_PhraseInfo(This,PhraseInfo) + +#define ISpeechRecoResult_Alternates(This,RequestCount,StartElement,Elements,Alternates) \ + (This)->lpVtbl -> Alternates(This,RequestCount,StartElement,Elements,Alternates) + +#define ISpeechRecoResult_Audio(This,StartElement,Elements,Stream) \ + (This)->lpVtbl -> Audio(This,StartElement,Elements,Stream) + +#define ISpeechRecoResult_SpeakAudio(This,StartElement,Elements,Flags,StreamNumber) \ + (This)->lpVtbl -> SpeakAudio(This,StartElement,Elements,Flags,StreamNumber) + +#define ISpeechRecoResult_SaveToMemory(This,ResultBlock) \ + (This)->lpVtbl -> SaveToMemory(This,ResultBlock) + +#define ISpeechRecoResult_DiscardResultInfo(This,ValueTypes) \ + (This)->lpVtbl -> DiscardResultInfo(This,ValueTypes) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecoResult_get_RecoContext_Proxy( + ISpeechRecoResult * This, + /* [retval][out] */ ISpeechRecoContext **RecoContext); + + +void __RPC_STUB ISpeechRecoResult_get_RecoContext_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecoResult_get_Times_Proxy( + ISpeechRecoResult * This, + /* [retval][out] */ ISpeechRecoResultTimes **Times); + + +void __RPC_STUB ISpeechRecoResult_get_Times_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propputref] */ HRESULT STDMETHODCALLTYPE ISpeechRecoResult_putref_AudioFormat_Proxy( + ISpeechRecoResult * This, + /* [in] */ ISpeechAudioFormat *Format); + + +void __RPC_STUB ISpeechRecoResult_putref_AudioFormat_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecoResult_get_AudioFormat_Proxy( + ISpeechRecoResult * This, + /* [retval][out] */ ISpeechAudioFormat **Format); + + +void __RPC_STUB ISpeechRecoResult_get_AudioFormat_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecoResult_get_PhraseInfo_Proxy( + ISpeechRecoResult * This, + /* [retval][out] */ ISpeechPhraseInfo **PhraseInfo); + + +void __RPC_STUB ISpeechRecoResult_get_PhraseInfo_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecoResult_Alternates_Proxy( + ISpeechRecoResult * This, + /* [in] */ long RequestCount, + /* [defaultvalue][in] */ long StartElement, + /* [defaultvalue][in] */ long Elements, + /* [retval][out] */ ISpeechPhraseAlternates **Alternates); + + +void __RPC_STUB ISpeechRecoResult_Alternates_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecoResult_Audio_Proxy( + ISpeechRecoResult * This, + /* [defaultvalue][in] */ long StartElement, + /* [defaultvalue][in] */ long Elements, + /* [retval][out] */ ISpeechMemoryStream **Stream); + + +void __RPC_STUB ISpeechRecoResult_Audio_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecoResult_SpeakAudio_Proxy( + ISpeechRecoResult * This, + /* [defaultvalue][in] */ long StartElement, + /* [defaultvalue][in] */ long Elements, + /* [defaultvalue][in] */ SpeechVoiceSpeakFlags Flags, + /* [retval][out] */ long *StreamNumber); + + +void __RPC_STUB ISpeechRecoResult_SpeakAudio_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecoResult_SaveToMemory_Proxy( + ISpeechRecoResult * This, + /* [retval][out] */ VARIANT *ResultBlock); + + +void __RPC_STUB ISpeechRecoResult_SaveToMemory_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechRecoResult_DiscardResultInfo_Proxy( + ISpeechRecoResult * This, + /* [in] */ SpeechDiscardType ValueTypes); + + +void __RPC_STUB ISpeechRecoResult_DiscardResultInfo_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechRecoResult_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechRecoResultTimes_INTERFACE_DEFINED__ +#define __ISpeechRecoResultTimes_INTERFACE_DEFINED__ + +/* interface ISpeechRecoResultTimes */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechRecoResultTimes; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("62B3B8FB-F6E7-41be-BDCB-056B1C29EFC0") + ISpeechRecoResultTimes : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_StreamTime( + /* [retval][out] */ VARIANT *Time) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Length( + /* [retval][out] */ VARIANT *Length) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_TickCount( + /* [retval][out] */ long *TickCount) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_OffsetFromStart( + /* [retval][out] */ VARIANT *OffsetFromStart) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechRecoResultTimesVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechRecoResultTimes * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechRecoResultTimes * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechRecoResultTimes * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechRecoResultTimes * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechRecoResultTimes * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechRecoResultTimes * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechRecoResultTimes * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_StreamTime )( + ISpeechRecoResultTimes * This, + /* [retval][out] */ VARIANT *Time); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Length )( + ISpeechRecoResultTimes * This, + /* [retval][out] */ VARIANT *Length); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_TickCount )( + ISpeechRecoResultTimes * This, + /* [retval][out] */ long *TickCount); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_OffsetFromStart )( + ISpeechRecoResultTimes * This, + /* [retval][out] */ VARIANT *OffsetFromStart); + + END_INTERFACE + } ISpeechRecoResultTimesVtbl; + + interface ISpeechRecoResultTimes + { + CONST_VTBL struct ISpeechRecoResultTimesVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechRecoResultTimes_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechRecoResultTimes_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechRecoResultTimes_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechRecoResultTimes_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechRecoResultTimes_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechRecoResultTimes_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechRecoResultTimes_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechRecoResultTimes_get_StreamTime(This,Time) \ + (This)->lpVtbl -> get_StreamTime(This,Time) + +#define ISpeechRecoResultTimes_get_Length(This,Length) \ + (This)->lpVtbl -> get_Length(This,Length) + +#define ISpeechRecoResultTimes_get_TickCount(This,TickCount) \ + (This)->lpVtbl -> get_TickCount(This,TickCount) + +#define ISpeechRecoResultTimes_get_OffsetFromStart(This,OffsetFromStart) \ + (This)->lpVtbl -> get_OffsetFromStart(This,OffsetFromStart) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecoResultTimes_get_StreamTime_Proxy( + ISpeechRecoResultTimes * This, + /* [retval][out] */ VARIANT *Time); + + +void __RPC_STUB ISpeechRecoResultTimes_get_StreamTime_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecoResultTimes_get_Length_Proxy( + ISpeechRecoResultTimes * This, + /* [retval][out] */ VARIANT *Length); + + +void __RPC_STUB ISpeechRecoResultTimes_get_Length_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecoResultTimes_get_TickCount_Proxy( + ISpeechRecoResultTimes * This, + /* [retval][out] */ long *TickCount); + + +void __RPC_STUB ISpeechRecoResultTimes_get_TickCount_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechRecoResultTimes_get_OffsetFromStart_Proxy( + ISpeechRecoResultTimes * This, + /* [retval][out] */ VARIANT *OffsetFromStart); + + +void __RPC_STUB ISpeechRecoResultTimes_get_OffsetFromStart_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechRecoResultTimes_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechPhraseAlternate_INTERFACE_DEFINED__ +#define __ISpeechPhraseAlternate_INTERFACE_DEFINED__ + +/* interface ISpeechPhraseAlternate */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechPhraseAlternate; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("27864A2A-2B9F-4cb8-92D3-0D2722FD1E73") + ISpeechPhraseAlternate : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_RecoResult( + /* [retval][out] */ ISpeechRecoResult **RecoResult) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_StartElementInResult( + /* [retval][out] */ long *StartElement) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_NumberOfElementsInResult( + /* [retval][out] */ long *NumberOfElements) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_PhraseInfo( + /* [retval][out] */ ISpeechPhraseInfo **PhraseInfo) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE Commit( void) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechPhraseAlternateVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechPhraseAlternate * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechPhraseAlternate * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechPhraseAlternate * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechPhraseAlternate * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechPhraseAlternate * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechPhraseAlternate * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechPhraseAlternate * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_RecoResult )( + ISpeechPhraseAlternate * This, + /* [retval][out] */ ISpeechRecoResult **RecoResult); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_StartElementInResult )( + ISpeechPhraseAlternate * This, + /* [retval][out] */ long *StartElement); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_NumberOfElementsInResult )( + ISpeechPhraseAlternate * This, + /* [retval][out] */ long *NumberOfElements); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PhraseInfo )( + ISpeechPhraseAlternate * This, + /* [retval][out] */ ISpeechPhraseInfo **PhraseInfo); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Commit )( + ISpeechPhraseAlternate * This); + + END_INTERFACE + } ISpeechPhraseAlternateVtbl; + + interface ISpeechPhraseAlternate + { + CONST_VTBL struct ISpeechPhraseAlternateVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechPhraseAlternate_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechPhraseAlternate_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechPhraseAlternate_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechPhraseAlternate_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechPhraseAlternate_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechPhraseAlternate_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechPhraseAlternate_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechPhraseAlternate_get_RecoResult(This,RecoResult) \ + (This)->lpVtbl -> get_RecoResult(This,RecoResult) + +#define ISpeechPhraseAlternate_get_StartElementInResult(This,StartElement) \ + (This)->lpVtbl -> get_StartElementInResult(This,StartElement) + +#define ISpeechPhraseAlternate_get_NumberOfElementsInResult(This,NumberOfElements) \ + (This)->lpVtbl -> get_NumberOfElementsInResult(This,NumberOfElements) + +#define ISpeechPhraseAlternate_get_PhraseInfo(This,PhraseInfo) \ + (This)->lpVtbl -> get_PhraseInfo(This,PhraseInfo) + +#define ISpeechPhraseAlternate_Commit(This) \ + (This)->lpVtbl -> Commit(This) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseAlternate_get_RecoResult_Proxy( + ISpeechPhraseAlternate * This, + /* [retval][out] */ ISpeechRecoResult **RecoResult); + + +void __RPC_STUB ISpeechPhraseAlternate_get_RecoResult_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseAlternate_get_StartElementInResult_Proxy( + ISpeechPhraseAlternate * This, + /* [retval][out] */ long *StartElement); + + +void __RPC_STUB ISpeechPhraseAlternate_get_StartElementInResult_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseAlternate_get_NumberOfElementsInResult_Proxy( + ISpeechPhraseAlternate * This, + /* [retval][out] */ long *NumberOfElements); + + +void __RPC_STUB ISpeechPhraseAlternate_get_NumberOfElementsInResult_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseAlternate_get_PhraseInfo_Proxy( + ISpeechPhraseAlternate * This, + /* [retval][out] */ ISpeechPhraseInfo **PhraseInfo); + + +void __RPC_STUB ISpeechPhraseAlternate_get_PhraseInfo_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseAlternate_Commit_Proxy( + ISpeechPhraseAlternate * This); + + +void __RPC_STUB ISpeechPhraseAlternate_Commit_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechPhraseAlternate_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechPhraseAlternates_INTERFACE_DEFINED__ +#define __ISpeechPhraseAlternates_INTERFACE_DEFINED__ + +/* interface ISpeechPhraseAlternates */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechPhraseAlternates; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("B238B6D5-F276-4c3d-A6C1-2974801C3CC2") + ISpeechPhraseAlternates : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( + /* [retval][out] */ long *Count) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE Item( + /* [in] */ long Index, + /* [retval][out] */ ISpeechPhraseAlternate **PhraseAlternate) = 0; + + virtual /* [id][restricted][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( + /* [retval][out] */ IUnknown **EnumVARIANT) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechPhraseAlternatesVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechPhraseAlternates * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechPhraseAlternates * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechPhraseAlternates * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechPhraseAlternates * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechPhraseAlternates * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechPhraseAlternates * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechPhraseAlternates * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( + ISpeechPhraseAlternates * This, + /* [retval][out] */ long *Count); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Item )( + ISpeechPhraseAlternates * This, + /* [in] */ long Index, + /* [retval][out] */ ISpeechPhraseAlternate **PhraseAlternate); + + /* [id][restricted][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( + ISpeechPhraseAlternates * This, + /* [retval][out] */ IUnknown **EnumVARIANT); + + END_INTERFACE + } ISpeechPhraseAlternatesVtbl; + + interface ISpeechPhraseAlternates + { + CONST_VTBL struct ISpeechPhraseAlternatesVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechPhraseAlternates_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechPhraseAlternates_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechPhraseAlternates_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechPhraseAlternates_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechPhraseAlternates_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechPhraseAlternates_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechPhraseAlternates_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechPhraseAlternates_get_Count(This,Count) \ + (This)->lpVtbl -> get_Count(This,Count) + +#define ISpeechPhraseAlternates_Item(This,Index,PhraseAlternate) \ + (This)->lpVtbl -> Item(This,Index,PhraseAlternate) + +#define ISpeechPhraseAlternates_get__NewEnum(This,EnumVARIANT) \ + (This)->lpVtbl -> get__NewEnum(This,EnumVARIANT) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseAlternates_get_Count_Proxy( + ISpeechPhraseAlternates * This, + /* [retval][out] */ long *Count); + + +void __RPC_STUB ISpeechPhraseAlternates_get_Count_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseAlternates_Item_Proxy( + ISpeechPhraseAlternates * This, + /* [in] */ long Index, + /* [retval][out] */ ISpeechPhraseAlternate **PhraseAlternate); + + +void __RPC_STUB ISpeechPhraseAlternates_Item_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][restricted][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseAlternates_get__NewEnum_Proxy( + ISpeechPhraseAlternates * This, + /* [retval][out] */ IUnknown **EnumVARIANT); + + +void __RPC_STUB ISpeechPhraseAlternates_get__NewEnum_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechPhraseAlternates_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechPhraseInfo_INTERFACE_DEFINED__ +#define __ISpeechPhraseInfo_INTERFACE_DEFINED__ + +/* interface ISpeechPhraseInfo */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechPhraseInfo; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("961559CF-4E67-4662-8BF0-D93F1FCD61B3") + ISpeechPhraseInfo : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_LanguageId( + /* [retval][out] */ long *LanguageId) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_GrammarId( + /* [retval][out] */ VARIANT *GrammarId) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_StartTime( + /* [retval][out] */ VARIANT *StartTime) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_AudioStreamPosition( + /* [retval][out] */ VARIANT *AudioStreamPosition) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_AudioSizeBytes( + /* [retval][out] */ long *pAudioSizeBytes) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_RetainedSizeBytes( + /* [retval][out] */ long *RetainedSizeBytes) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_AudioSizeTime( + /* [retval][out] */ long *AudioSizeTime) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Rule( + /* [retval][out] */ ISpeechPhraseRule **Rule) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Properties( + /* [retval][out] */ ISpeechPhraseProperties **Properties) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Elements( + /* [retval][out] */ ISpeechPhraseElements **Elements) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Replacements( + /* [retval][out] */ ISpeechPhraseReplacements **Replacements) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_EngineId( + /* [retval][out] */ BSTR *EngineIdGuid) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_EnginePrivateData( + /* [retval][out] */ VARIANT *PrivateData) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE SaveToMemory( + /* [retval][out] */ VARIANT *PhraseBlock) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE GetText( + /* [defaultvalue][in] */ long StartElement, + /* [defaultvalue][in] */ long Elements, + /* [defaultvalue][in] */ VARIANT_BOOL UseReplacements, + /* [retval][out] */ BSTR *Text) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE GetDisplayAttributes( + /* [defaultvalue][in] */ long StartElement, + /* [defaultvalue][in] */ long Elements, + /* [defaultvalue][in] */ VARIANT_BOOL UseReplacements, + /* [retval][out] */ SpeechDisplayAttributes *DisplayAttributes) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechPhraseInfoVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechPhraseInfo * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechPhraseInfo * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechPhraseInfo * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechPhraseInfo * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechPhraseInfo * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechPhraseInfo * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechPhraseInfo * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_LanguageId )( + ISpeechPhraseInfo * This, + /* [retval][out] */ long *LanguageId); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_GrammarId )( + ISpeechPhraseInfo * This, + /* [retval][out] */ VARIANT *GrammarId); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_StartTime )( + ISpeechPhraseInfo * This, + /* [retval][out] */ VARIANT *StartTime); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_AudioStreamPosition )( + ISpeechPhraseInfo * This, + /* [retval][out] */ VARIANT *AudioStreamPosition); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_AudioSizeBytes )( + ISpeechPhraseInfo * This, + /* [retval][out] */ long *pAudioSizeBytes); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_RetainedSizeBytes )( + ISpeechPhraseInfo * This, + /* [retval][out] */ long *RetainedSizeBytes); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_AudioSizeTime )( + ISpeechPhraseInfo * This, + /* [retval][out] */ long *AudioSizeTime); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Rule )( + ISpeechPhraseInfo * This, + /* [retval][out] */ ISpeechPhraseRule **Rule); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Properties )( + ISpeechPhraseInfo * This, + /* [retval][out] */ ISpeechPhraseProperties **Properties); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Elements )( + ISpeechPhraseInfo * This, + /* [retval][out] */ ISpeechPhraseElements **Elements); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Replacements )( + ISpeechPhraseInfo * This, + /* [retval][out] */ ISpeechPhraseReplacements **Replacements); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_EngineId )( + ISpeechPhraseInfo * This, + /* [retval][out] */ BSTR *EngineIdGuid); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_EnginePrivateData )( + ISpeechPhraseInfo * This, + /* [retval][out] */ VARIANT *PrivateData); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *SaveToMemory )( + ISpeechPhraseInfo * This, + /* [retval][out] */ VARIANT *PhraseBlock); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetText )( + ISpeechPhraseInfo * This, + /* [defaultvalue][in] */ long StartElement, + /* [defaultvalue][in] */ long Elements, + /* [defaultvalue][in] */ VARIANT_BOOL UseReplacements, + /* [retval][out] */ BSTR *Text); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetDisplayAttributes )( + ISpeechPhraseInfo * This, + /* [defaultvalue][in] */ long StartElement, + /* [defaultvalue][in] */ long Elements, + /* [defaultvalue][in] */ VARIANT_BOOL UseReplacements, + /* [retval][out] */ SpeechDisplayAttributes *DisplayAttributes); + + END_INTERFACE + } ISpeechPhraseInfoVtbl; + + interface ISpeechPhraseInfo + { + CONST_VTBL struct ISpeechPhraseInfoVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechPhraseInfo_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechPhraseInfo_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechPhraseInfo_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechPhraseInfo_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechPhraseInfo_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechPhraseInfo_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechPhraseInfo_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechPhraseInfo_get_LanguageId(This,LanguageId) \ + (This)->lpVtbl -> get_LanguageId(This,LanguageId) + +#define ISpeechPhraseInfo_get_GrammarId(This,GrammarId) \ + (This)->lpVtbl -> get_GrammarId(This,GrammarId) + +#define ISpeechPhraseInfo_get_StartTime(This,StartTime) \ + (This)->lpVtbl -> get_StartTime(This,StartTime) + +#define ISpeechPhraseInfo_get_AudioStreamPosition(This,AudioStreamPosition) \ + (This)->lpVtbl -> get_AudioStreamPosition(This,AudioStreamPosition) + +#define ISpeechPhraseInfo_get_AudioSizeBytes(This,pAudioSizeBytes) \ + (This)->lpVtbl -> get_AudioSizeBytes(This,pAudioSizeBytes) + +#define ISpeechPhraseInfo_get_RetainedSizeBytes(This,RetainedSizeBytes) \ + (This)->lpVtbl -> get_RetainedSizeBytes(This,RetainedSizeBytes) + +#define ISpeechPhraseInfo_get_AudioSizeTime(This,AudioSizeTime) \ + (This)->lpVtbl -> get_AudioSizeTime(This,AudioSizeTime) + +#define ISpeechPhraseInfo_get_Rule(This,Rule) \ + (This)->lpVtbl -> get_Rule(This,Rule) + +#define ISpeechPhraseInfo_get_Properties(This,Properties) \ + (This)->lpVtbl -> get_Properties(This,Properties) + +#define ISpeechPhraseInfo_get_Elements(This,Elements) \ + (This)->lpVtbl -> get_Elements(This,Elements) + +#define ISpeechPhraseInfo_get_Replacements(This,Replacements) \ + (This)->lpVtbl -> get_Replacements(This,Replacements) + +#define ISpeechPhraseInfo_get_EngineId(This,EngineIdGuid) \ + (This)->lpVtbl -> get_EngineId(This,EngineIdGuid) + +#define ISpeechPhraseInfo_get_EnginePrivateData(This,PrivateData) \ + (This)->lpVtbl -> get_EnginePrivateData(This,PrivateData) + +#define ISpeechPhraseInfo_SaveToMemory(This,PhraseBlock) \ + (This)->lpVtbl -> SaveToMemory(This,PhraseBlock) + +#define ISpeechPhraseInfo_GetText(This,StartElement,Elements,UseReplacements,Text) \ + (This)->lpVtbl -> GetText(This,StartElement,Elements,UseReplacements,Text) + +#define ISpeechPhraseInfo_GetDisplayAttributes(This,StartElement,Elements,UseReplacements,DisplayAttributes) \ + (This)->lpVtbl -> GetDisplayAttributes(This,StartElement,Elements,UseReplacements,DisplayAttributes) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseInfo_get_LanguageId_Proxy( + ISpeechPhraseInfo * This, + /* [retval][out] */ long *LanguageId); + + +void __RPC_STUB ISpeechPhraseInfo_get_LanguageId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseInfo_get_GrammarId_Proxy( + ISpeechPhraseInfo * This, + /* [retval][out] */ VARIANT *GrammarId); + + +void __RPC_STUB ISpeechPhraseInfo_get_GrammarId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseInfo_get_StartTime_Proxy( + ISpeechPhraseInfo * This, + /* [retval][out] */ VARIANT *StartTime); + + +void __RPC_STUB ISpeechPhraseInfo_get_StartTime_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseInfo_get_AudioStreamPosition_Proxy( + ISpeechPhraseInfo * This, + /* [retval][out] */ VARIANT *AudioStreamPosition); + + +void __RPC_STUB ISpeechPhraseInfo_get_AudioStreamPosition_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseInfo_get_AudioSizeBytes_Proxy( + ISpeechPhraseInfo * This, + /* [retval][out] */ long *pAudioSizeBytes); + + +void __RPC_STUB ISpeechPhraseInfo_get_AudioSizeBytes_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseInfo_get_RetainedSizeBytes_Proxy( + ISpeechPhraseInfo * This, + /* [retval][out] */ long *RetainedSizeBytes); + + +void __RPC_STUB ISpeechPhraseInfo_get_RetainedSizeBytes_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseInfo_get_AudioSizeTime_Proxy( + ISpeechPhraseInfo * This, + /* [retval][out] */ long *AudioSizeTime); + + +void __RPC_STUB ISpeechPhraseInfo_get_AudioSizeTime_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseInfo_get_Rule_Proxy( + ISpeechPhraseInfo * This, + /* [retval][out] */ ISpeechPhraseRule **Rule); + + +void __RPC_STUB ISpeechPhraseInfo_get_Rule_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseInfo_get_Properties_Proxy( + ISpeechPhraseInfo * This, + /* [retval][out] */ ISpeechPhraseProperties **Properties); + + +void __RPC_STUB ISpeechPhraseInfo_get_Properties_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseInfo_get_Elements_Proxy( + ISpeechPhraseInfo * This, + /* [retval][out] */ ISpeechPhraseElements **Elements); + + +void __RPC_STUB ISpeechPhraseInfo_get_Elements_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseInfo_get_Replacements_Proxy( + ISpeechPhraseInfo * This, + /* [retval][out] */ ISpeechPhraseReplacements **Replacements); + + +void __RPC_STUB ISpeechPhraseInfo_get_Replacements_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseInfo_get_EngineId_Proxy( + ISpeechPhraseInfo * This, + /* [retval][out] */ BSTR *EngineIdGuid); + + +void __RPC_STUB ISpeechPhraseInfo_get_EngineId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseInfo_get_EnginePrivateData_Proxy( + ISpeechPhraseInfo * This, + /* [retval][out] */ VARIANT *PrivateData); + + +void __RPC_STUB ISpeechPhraseInfo_get_EnginePrivateData_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseInfo_SaveToMemory_Proxy( + ISpeechPhraseInfo * This, + /* [retval][out] */ VARIANT *PhraseBlock); + + +void __RPC_STUB ISpeechPhraseInfo_SaveToMemory_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseInfo_GetText_Proxy( + ISpeechPhraseInfo * This, + /* [defaultvalue][in] */ long StartElement, + /* [defaultvalue][in] */ long Elements, + /* [defaultvalue][in] */ VARIANT_BOOL UseReplacements, + /* [retval][out] */ BSTR *Text); + + +void __RPC_STUB ISpeechPhraseInfo_GetText_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseInfo_GetDisplayAttributes_Proxy( + ISpeechPhraseInfo * This, + /* [defaultvalue][in] */ long StartElement, + /* [defaultvalue][in] */ long Elements, + /* [defaultvalue][in] */ VARIANT_BOOL UseReplacements, + /* [retval][out] */ SpeechDisplayAttributes *DisplayAttributes); + + +void __RPC_STUB ISpeechPhraseInfo_GetDisplayAttributes_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechPhraseInfo_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechPhraseElement_INTERFACE_DEFINED__ +#define __ISpeechPhraseElement_INTERFACE_DEFINED__ + +/* interface ISpeechPhraseElement */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechPhraseElement; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("E6176F96-E373-4801-B223-3B62C068C0B4") + ISpeechPhraseElement : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_AudioTimeOffset( + /* [retval][out] */ long *AudioTimeOffset) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_AudioSizeTime( + /* [retval][out] */ long *AudioSizeTime) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_AudioStreamOffset( + /* [retval][out] */ long *AudioStreamOffset) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_AudioSizeBytes( + /* [retval][out] */ long *AudioSizeBytes) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_RetainedStreamOffset( + /* [retval][out] */ long *RetainedStreamOffset) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_RetainedSizeBytes( + /* [retval][out] */ long *RetainedSizeBytes) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_DisplayText( + /* [retval][out] */ BSTR *DisplayText) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_LexicalForm( + /* [retval][out] */ BSTR *LexicalForm) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Pronunciation( + /* [retval][out] */ VARIANT *Pronunciation) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_DisplayAttributes( + /* [retval][out] */ SpeechDisplayAttributes *DisplayAttributes) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_RequiredConfidence( + /* [retval][out] */ SpeechEngineConfidence *RequiredConfidence) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_ActualConfidence( + /* [retval][out] */ SpeechEngineConfidence *ActualConfidence) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_EngineConfidence( + /* [retval][out] */ float *EngineConfidence) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechPhraseElementVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechPhraseElement * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechPhraseElement * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechPhraseElement * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechPhraseElement * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechPhraseElement * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechPhraseElement * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechPhraseElement * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_AudioTimeOffset )( + ISpeechPhraseElement * This, + /* [retval][out] */ long *AudioTimeOffset); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_AudioSizeTime )( + ISpeechPhraseElement * This, + /* [retval][out] */ long *AudioSizeTime); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_AudioStreamOffset )( + ISpeechPhraseElement * This, + /* [retval][out] */ long *AudioStreamOffset); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_AudioSizeBytes )( + ISpeechPhraseElement * This, + /* [retval][out] */ long *AudioSizeBytes); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_RetainedStreamOffset )( + ISpeechPhraseElement * This, + /* [retval][out] */ long *RetainedStreamOffset); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_RetainedSizeBytes )( + ISpeechPhraseElement * This, + /* [retval][out] */ long *RetainedSizeBytes); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_DisplayText )( + ISpeechPhraseElement * This, + /* [retval][out] */ BSTR *DisplayText); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_LexicalForm )( + ISpeechPhraseElement * This, + /* [retval][out] */ BSTR *LexicalForm); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Pronunciation )( + ISpeechPhraseElement * This, + /* [retval][out] */ VARIANT *Pronunciation); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_DisplayAttributes )( + ISpeechPhraseElement * This, + /* [retval][out] */ SpeechDisplayAttributes *DisplayAttributes); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_RequiredConfidence )( + ISpeechPhraseElement * This, + /* [retval][out] */ SpeechEngineConfidence *RequiredConfidence); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_ActualConfidence )( + ISpeechPhraseElement * This, + /* [retval][out] */ SpeechEngineConfidence *ActualConfidence); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_EngineConfidence )( + ISpeechPhraseElement * This, + /* [retval][out] */ float *EngineConfidence); + + END_INTERFACE + } ISpeechPhraseElementVtbl; + + interface ISpeechPhraseElement + { + CONST_VTBL struct ISpeechPhraseElementVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechPhraseElement_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechPhraseElement_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechPhraseElement_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechPhraseElement_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechPhraseElement_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechPhraseElement_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechPhraseElement_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechPhraseElement_get_AudioTimeOffset(This,AudioTimeOffset) \ + (This)->lpVtbl -> get_AudioTimeOffset(This,AudioTimeOffset) + +#define ISpeechPhraseElement_get_AudioSizeTime(This,AudioSizeTime) \ + (This)->lpVtbl -> get_AudioSizeTime(This,AudioSizeTime) + +#define ISpeechPhraseElement_get_AudioStreamOffset(This,AudioStreamOffset) \ + (This)->lpVtbl -> get_AudioStreamOffset(This,AudioStreamOffset) + +#define ISpeechPhraseElement_get_AudioSizeBytes(This,AudioSizeBytes) \ + (This)->lpVtbl -> get_AudioSizeBytes(This,AudioSizeBytes) + +#define ISpeechPhraseElement_get_RetainedStreamOffset(This,RetainedStreamOffset) \ + (This)->lpVtbl -> get_RetainedStreamOffset(This,RetainedStreamOffset) + +#define ISpeechPhraseElement_get_RetainedSizeBytes(This,RetainedSizeBytes) \ + (This)->lpVtbl -> get_RetainedSizeBytes(This,RetainedSizeBytes) + +#define ISpeechPhraseElement_get_DisplayText(This,DisplayText) \ + (This)->lpVtbl -> get_DisplayText(This,DisplayText) + +#define ISpeechPhraseElement_get_LexicalForm(This,LexicalForm) \ + (This)->lpVtbl -> get_LexicalForm(This,LexicalForm) + +#define ISpeechPhraseElement_get_Pronunciation(This,Pronunciation) \ + (This)->lpVtbl -> get_Pronunciation(This,Pronunciation) + +#define ISpeechPhraseElement_get_DisplayAttributes(This,DisplayAttributes) \ + (This)->lpVtbl -> get_DisplayAttributes(This,DisplayAttributes) + +#define ISpeechPhraseElement_get_RequiredConfidence(This,RequiredConfidence) \ + (This)->lpVtbl -> get_RequiredConfidence(This,RequiredConfidence) + +#define ISpeechPhraseElement_get_ActualConfidence(This,ActualConfidence) \ + (This)->lpVtbl -> get_ActualConfidence(This,ActualConfidence) + +#define ISpeechPhraseElement_get_EngineConfidence(This,EngineConfidence) \ + (This)->lpVtbl -> get_EngineConfidence(This,EngineConfidence) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseElement_get_AudioTimeOffset_Proxy( + ISpeechPhraseElement * This, + /* [retval][out] */ long *AudioTimeOffset); + + +void __RPC_STUB ISpeechPhraseElement_get_AudioTimeOffset_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseElement_get_AudioSizeTime_Proxy( + ISpeechPhraseElement * This, + /* [retval][out] */ long *AudioSizeTime); + + +void __RPC_STUB ISpeechPhraseElement_get_AudioSizeTime_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseElement_get_AudioStreamOffset_Proxy( + ISpeechPhraseElement * This, + /* [retval][out] */ long *AudioStreamOffset); + + +void __RPC_STUB ISpeechPhraseElement_get_AudioStreamOffset_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseElement_get_AudioSizeBytes_Proxy( + ISpeechPhraseElement * This, + /* [retval][out] */ long *AudioSizeBytes); + + +void __RPC_STUB ISpeechPhraseElement_get_AudioSizeBytes_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseElement_get_RetainedStreamOffset_Proxy( + ISpeechPhraseElement * This, + /* [retval][out] */ long *RetainedStreamOffset); + + +void __RPC_STUB ISpeechPhraseElement_get_RetainedStreamOffset_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseElement_get_RetainedSizeBytes_Proxy( + ISpeechPhraseElement * This, + /* [retval][out] */ long *RetainedSizeBytes); + + +void __RPC_STUB ISpeechPhraseElement_get_RetainedSizeBytes_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseElement_get_DisplayText_Proxy( + ISpeechPhraseElement * This, + /* [retval][out] */ BSTR *DisplayText); + + +void __RPC_STUB ISpeechPhraseElement_get_DisplayText_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseElement_get_LexicalForm_Proxy( + ISpeechPhraseElement * This, + /* [retval][out] */ BSTR *LexicalForm); + + +void __RPC_STUB ISpeechPhraseElement_get_LexicalForm_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseElement_get_Pronunciation_Proxy( + ISpeechPhraseElement * This, + /* [retval][out] */ VARIANT *Pronunciation); + + +void __RPC_STUB ISpeechPhraseElement_get_Pronunciation_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseElement_get_DisplayAttributes_Proxy( + ISpeechPhraseElement * This, + /* [retval][out] */ SpeechDisplayAttributes *DisplayAttributes); + + +void __RPC_STUB ISpeechPhraseElement_get_DisplayAttributes_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseElement_get_RequiredConfidence_Proxy( + ISpeechPhraseElement * This, + /* [retval][out] */ SpeechEngineConfidence *RequiredConfidence); + + +void __RPC_STUB ISpeechPhraseElement_get_RequiredConfidence_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseElement_get_ActualConfidence_Proxy( + ISpeechPhraseElement * This, + /* [retval][out] */ SpeechEngineConfidence *ActualConfidence); + + +void __RPC_STUB ISpeechPhraseElement_get_ActualConfidence_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseElement_get_EngineConfidence_Proxy( + ISpeechPhraseElement * This, + /* [retval][out] */ float *EngineConfidence); + + +void __RPC_STUB ISpeechPhraseElement_get_EngineConfidence_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechPhraseElement_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechPhraseElements_INTERFACE_DEFINED__ +#define __ISpeechPhraseElements_INTERFACE_DEFINED__ + +/* interface ISpeechPhraseElements */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechPhraseElements; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("0626B328-3478-467d-A0B3-D0853B93DDA3") + ISpeechPhraseElements : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( + /* [retval][out] */ long *Count) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE Item( + /* [in] */ long Index, + /* [retval][out] */ ISpeechPhraseElement **Element) = 0; + + virtual /* [id][restricted][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( + /* [retval][out] */ IUnknown **EnumVARIANT) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechPhraseElementsVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechPhraseElements * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechPhraseElements * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechPhraseElements * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechPhraseElements * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechPhraseElements * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechPhraseElements * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechPhraseElements * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( + ISpeechPhraseElements * This, + /* [retval][out] */ long *Count); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Item )( + ISpeechPhraseElements * This, + /* [in] */ long Index, + /* [retval][out] */ ISpeechPhraseElement **Element); + + /* [id][restricted][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( + ISpeechPhraseElements * This, + /* [retval][out] */ IUnknown **EnumVARIANT); + + END_INTERFACE + } ISpeechPhraseElementsVtbl; + + interface ISpeechPhraseElements + { + CONST_VTBL struct ISpeechPhraseElementsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechPhraseElements_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechPhraseElements_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechPhraseElements_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechPhraseElements_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechPhraseElements_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechPhraseElements_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechPhraseElements_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechPhraseElements_get_Count(This,Count) \ + (This)->lpVtbl -> get_Count(This,Count) + +#define ISpeechPhraseElements_Item(This,Index,Element) \ + (This)->lpVtbl -> Item(This,Index,Element) + +#define ISpeechPhraseElements_get__NewEnum(This,EnumVARIANT) \ + (This)->lpVtbl -> get__NewEnum(This,EnumVARIANT) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseElements_get_Count_Proxy( + ISpeechPhraseElements * This, + /* [retval][out] */ long *Count); + + +void __RPC_STUB ISpeechPhraseElements_get_Count_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseElements_Item_Proxy( + ISpeechPhraseElements * This, + /* [in] */ long Index, + /* [retval][out] */ ISpeechPhraseElement **Element); + + +void __RPC_STUB ISpeechPhraseElements_Item_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][restricted][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseElements_get__NewEnum_Proxy( + ISpeechPhraseElements * This, + /* [retval][out] */ IUnknown **EnumVARIANT); + + +void __RPC_STUB ISpeechPhraseElements_get__NewEnum_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechPhraseElements_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechPhraseReplacement_INTERFACE_DEFINED__ +#define __ISpeechPhraseReplacement_INTERFACE_DEFINED__ + +/* interface ISpeechPhraseReplacement */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechPhraseReplacement; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("2890A410-53A7-4fb5-94EC-06D4998E3D02") + ISpeechPhraseReplacement : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_DisplayAttributes( + /* [retval][out] */ SpeechDisplayAttributes *DisplayAttributes) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Text( + /* [retval][out] */ BSTR *Text) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_FirstElement( + /* [retval][out] */ long *FirstElement) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_NumberOfElements( + /* [retval][out] */ long *NumberOfElements) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechPhraseReplacementVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechPhraseReplacement * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechPhraseReplacement * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechPhraseReplacement * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechPhraseReplacement * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechPhraseReplacement * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechPhraseReplacement * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechPhraseReplacement * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_DisplayAttributes )( + ISpeechPhraseReplacement * This, + /* [retval][out] */ SpeechDisplayAttributes *DisplayAttributes); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Text )( + ISpeechPhraseReplacement * This, + /* [retval][out] */ BSTR *Text); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_FirstElement )( + ISpeechPhraseReplacement * This, + /* [retval][out] */ long *FirstElement); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_NumberOfElements )( + ISpeechPhraseReplacement * This, + /* [retval][out] */ long *NumberOfElements); + + END_INTERFACE + } ISpeechPhraseReplacementVtbl; + + interface ISpeechPhraseReplacement + { + CONST_VTBL struct ISpeechPhraseReplacementVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechPhraseReplacement_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechPhraseReplacement_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechPhraseReplacement_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechPhraseReplacement_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechPhraseReplacement_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechPhraseReplacement_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechPhraseReplacement_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechPhraseReplacement_get_DisplayAttributes(This,DisplayAttributes) \ + (This)->lpVtbl -> get_DisplayAttributes(This,DisplayAttributes) + +#define ISpeechPhraseReplacement_get_Text(This,Text) \ + (This)->lpVtbl -> get_Text(This,Text) + +#define ISpeechPhraseReplacement_get_FirstElement(This,FirstElement) \ + (This)->lpVtbl -> get_FirstElement(This,FirstElement) + +#define ISpeechPhraseReplacement_get_NumberOfElements(This,NumberOfElements) \ + (This)->lpVtbl -> get_NumberOfElements(This,NumberOfElements) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseReplacement_get_DisplayAttributes_Proxy( + ISpeechPhraseReplacement * This, + /* [retval][out] */ SpeechDisplayAttributes *DisplayAttributes); + + +void __RPC_STUB ISpeechPhraseReplacement_get_DisplayAttributes_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseReplacement_get_Text_Proxy( + ISpeechPhraseReplacement * This, + /* [retval][out] */ BSTR *Text); + + +void __RPC_STUB ISpeechPhraseReplacement_get_Text_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseReplacement_get_FirstElement_Proxy( + ISpeechPhraseReplacement * This, + /* [retval][out] */ long *FirstElement); + + +void __RPC_STUB ISpeechPhraseReplacement_get_FirstElement_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseReplacement_get_NumberOfElements_Proxy( + ISpeechPhraseReplacement * This, + /* [retval][out] */ long *NumberOfElements); + + +void __RPC_STUB ISpeechPhraseReplacement_get_NumberOfElements_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechPhraseReplacement_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechPhraseReplacements_INTERFACE_DEFINED__ +#define __ISpeechPhraseReplacements_INTERFACE_DEFINED__ + +/* interface ISpeechPhraseReplacements */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechPhraseReplacements; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("38BC662F-2257-4525-959E-2069D2596C05") + ISpeechPhraseReplacements : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( + /* [retval][out] */ long *Count) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE Item( + /* [in] */ long Index, + /* [retval][out] */ ISpeechPhraseReplacement **Reps) = 0; + + virtual /* [id][restricted][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( + /* [retval][out] */ IUnknown **EnumVARIANT) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechPhraseReplacementsVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechPhraseReplacements * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechPhraseReplacements * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechPhraseReplacements * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechPhraseReplacements * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechPhraseReplacements * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechPhraseReplacements * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechPhraseReplacements * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( + ISpeechPhraseReplacements * This, + /* [retval][out] */ long *Count); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Item )( + ISpeechPhraseReplacements * This, + /* [in] */ long Index, + /* [retval][out] */ ISpeechPhraseReplacement **Reps); + + /* [id][restricted][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( + ISpeechPhraseReplacements * This, + /* [retval][out] */ IUnknown **EnumVARIANT); + + END_INTERFACE + } ISpeechPhraseReplacementsVtbl; + + interface ISpeechPhraseReplacements + { + CONST_VTBL struct ISpeechPhraseReplacementsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechPhraseReplacements_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechPhraseReplacements_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechPhraseReplacements_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechPhraseReplacements_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechPhraseReplacements_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechPhraseReplacements_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechPhraseReplacements_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechPhraseReplacements_get_Count(This,Count) \ + (This)->lpVtbl -> get_Count(This,Count) + +#define ISpeechPhraseReplacements_Item(This,Index,Reps) \ + (This)->lpVtbl -> Item(This,Index,Reps) + +#define ISpeechPhraseReplacements_get__NewEnum(This,EnumVARIANT) \ + (This)->lpVtbl -> get__NewEnum(This,EnumVARIANT) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseReplacements_get_Count_Proxy( + ISpeechPhraseReplacements * This, + /* [retval][out] */ long *Count); + + +void __RPC_STUB ISpeechPhraseReplacements_get_Count_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseReplacements_Item_Proxy( + ISpeechPhraseReplacements * This, + /* [in] */ long Index, + /* [retval][out] */ ISpeechPhraseReplacement **Reps); + + +void __RPC_STUB ISpeechPhraseReplacements_Item_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][restricted][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseReplacements_get__NewEnum_Proxy( + ISpeechPhraseReplacements * This, + /* [retval][out] */ IUnknown **EnumVARIANT); + + +void __RPC_STUB ISpeechPhraseReplacements_get__NewEnum_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechPhraseReplacements_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechPhraseProperty_INTERFACE_DEFINED__ +#define __ISpeechPhraseProperty_INTERFACE_DEFINED__ + +/* interface ISpeechPhraseProperty */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechPhraseProperty; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("CE563D48-961E-4732-A2E1-378A42B430BE") + ISpeechPhraseProperty : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Name( + /* [retval][out] */ BSTR *Name) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Id( + /* [retval][out] */ long *Id) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Value( + /* [retval][out] */ VARIANT *Value) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_FirstElement( + /* [retval][out] */ long *FirstElement) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_NumberOfElements( + /* [retval][out] */ long *NumberOfElements) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_EngineConfidence( + /* [retval][out] */ float *Confidence) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Confidence( + /* [retval][out] */ SpeechEngineConfidence *Confidence) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Parent( + /* [retval][out] */ ISpeechPhraseProperty **ParentProperty) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Children( + /* [retval][out] */ ISpeechPhraseProperties **Children) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechPhrasePropertyVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechPhraseProperty * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechPhraseProperty * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechPhraseProperty * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechPhraseProperty * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechPhraseProperty * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechPhraseProperty * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechPhraseProperty * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Name )( + ISpeechPhraseProperty * This, + /* [retval][out] */ BSTR *Name); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Id )( + ISpeechPhraseProperty * This, + /* [retval][out] */ long *Id); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Value )( + ISpeechPhraseProperty * This, + /* [retval][out] */ VARIANT *Value); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_FirstElement )( + ISpeechPhraseProperty * This, + /* [retval][out] */ long *FirstElement); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_NumberOfElements )( + ISpeechPhraseProperty * This, + /* [retval][out] */ long *NumberOfElements); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_EngineConfidence )( + ISpeechPhraseProperty * This, + /* [retval][out] */ float *Confidence); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Confidence )( + ISpeechPhraseProperty * This, + /* [retval][out] */ SpeechEngineConfidence *Confidence); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Parent )( + ISpeechPhraseProperty * This, + /* [retval][out] */ ISpeechPhraseProperty **ParentProperty); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Children )( + ISpeechPhraseProperty * This, + /* [retval][out] */ ISpeechPhraseProperties **Children); + + END_INTERFACE + } ISpeechPhrasePropertyVtbl; + + interface ISpeechPhraseProperty + { + CONST_VTBL struct ISpeechPhrasePropertyVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechPhraseProperty_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechPhraseProperty_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechPhraseProperty_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechPhraseProperty_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechPhraseProperty_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechPhraseProperty_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechPhraseProperty_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechPhraseProperty_get_Name(This,Name) \ + (This)->lpVtbl -> get_Name(This,Name) + +#define ISpeechPhraseProperty_get_Id(This,Id) \ + (This)->lpVtbl -> get_Id(This,Id) + +#define ISpeechPhraseProperty_get_Value(This,Value) \ + (This)->lpVtbl -> get_Value(This,Value) + +#define ISpeechPhraseProperty_get_FirstElement(This,FirstElement) \ + (This)->lpVtbl -> get_FirstElement(This,FirstElement) + +#define ISpeechPhraseProperty_get_NumberOfElements(This,NumberOfElements) \ + (This)->lpVtbl -> get_NumberOfElements(This,NumberOfElements) + +#define ISpeechPhraseProperty_get_EngineConfidence(This,Confidence) \ + (This)->lpVtbl -> get_EngineConfidence(This,Confidence) + +#define ISpeechPhraseProperty_get_Confidence(This,Confidence) \ + (This)->lpVtbl -> get_Confidence(This,Confidence) + +#define ISpeechPhraseProperty_get_Parent(This,ParentProperty) \ + (This)->lpVtbl -> get_Parent(This,ParentProperty) + +#define ISpeechPhraseProperty_get_Children(This,Children) \ + (This)->lpVtbl -> get_Children(This,Children) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseProperty_get_Name_Proxy( + ISpeechPhraseProperty * This, + /* [retval][out] */ BSTR *Name); + + +void __RPC_STUB ISpeechPhraseProperty_get_Name_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseProperty_get_Id_Proxy( + ISpeechPhraseProperty * This, + /* [retval][out] */ long *Id); + + +void __RPC_STUB ISpeechPhraseProperty_get_Id_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseProperty_get_Value_Proxy( + ISpeechPhraseProperty * This, + /* [retval][out] */ VARIANT *Value); + + +void __RPC_STUB ISpeechPhraseProperty_get_Value_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseProperty_get_FirstElement_Proxy( + ISpeechPhraseProperty * This, + /* [retval][out] */ long *FirstElement); + + +void __RPC_STUB ISpeechPhraseProperty_get_FirstElement_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseProperty_get_NumberOfElements_Proxy( + ISpeechPhraseProperty * This, + /* [retval][out] */ long *NumberOfElements); + + +void __RPC_STUB ISpeechPhraseProperty_get_NumberOfElements_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseProperty_get_EngineConfidence_Proxy( + ISpeechPhraseProperty * This, + /* [retval][out] */ float *Confidence); + + +void __RPC_STUB ISpeechPhraseProperty_get_EngineConfidence_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseProperty_get_Confidence_Proxy( + ISpeechPhraseProperty * This, + /* [retval][out] */ SpeechEngineConfidence *Confidence); + + +void __RPC_STUB ISpeechPhraseProperty_get_Confidence_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseProperty_get_Parent_Proxy( + ISpeechPhraseProperty * This, + /* [retval][out] */ ISpeechPhraseProperty **ParentProperty); + + +void __RPC_STUB ISpeechPhraseProperty_get_Parent_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseProperty_get_Children_Proxy( + ISpeechPhraseProperty * This, + /* [retval][out] */ ISpeechPhraseProperties **Children); + + +void __RPC_STUB ISpeechPhraseProperty_get_Children_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechPhraseProperty_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechPhraseProperties_INTERFACE_DEFINED__ +#define __ISpeechPhraseProperties_INTERFACE_DEFINED__ + +/* interface ISpeechPhraseProperties */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechPhraseProperties; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("08166B47-102E-4b23-A599-BDB98DBFD1F4") + ISpeechPhraseProperties : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( + /* [retval][out] */ long *Count) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE Item( + /* [in] */ long Index, + /* [retval][out] */ ISpeechPhraseProperty **Property) = 0; + + virtual /* [id][restricted][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( + /* [retval][out] */ IUnknown **EnumVARIANT) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechPhrasePropertiesVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechPhraseProperties * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechPhraseProperties * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechPhraseProperties * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechPhraseProperties * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechPhraseProperties * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechPhraseProperties * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechPhraseProperties * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( + ISpeechPhraseProperties * This, + /* [retval][out] */ long *Count); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Item )( + ISpeechPhraseProperties * This, + /* [in] */ long Index, + /* [retval][out] */ ISpeechPhraseProperty **Property); + + /* [id][restricted][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( + ISpeechPhraseProperties * This, + /* [retval][out] */ IUnknown **EnumVARIANT); + + END_INTERFACE + } ISpeechPhrasePropertiesVtbl; + + interface ISpeechPhraseProperties + { + CONST_VTBL struct ISpeechPhrasePropertiesVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechPhraseProperties_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechPhraseProperties_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechPhraseProperties_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechPhraseProperties_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechPhraseProperties_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechPhraseProperties_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechPhraseProperties_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechPhraseProperties_get_Count(This,Count) \ + (This)->lpVtbl -> get_Count(This,Count) + +#define ISpeechPhraseProperties_Item(This,Index,Property) \ + (This)->lpVtbl -> Item(This,Index,Property) + +#define ISpeechPhraseProperties_get__NewEnum(This,EnumVARIANT) \ + (This)->lpVtbl -> get__NewEnum(This,EnumVARIANT) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseProperties_get_Count_Proxy( + ISpeechPhraseProperties * This, + /* [retval][out] */ long *Count); + + +void __RPC_STUB ISpeechPhraseProperties_get_Count_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseProperties_Item_Proxy( + ISpeechPhraseProperties * This, + /* [in] */ long Index, + /* [retval][out] */ ISpeechPhraseProperty **Property); + + +void __RPC_STUB ISpeechPhraseProperties_Item_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][restricted][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseProperties_get__NewEnum_Proxy( + ISpeechPhraseProperties * This, + /* [retval][out] */ IUnknown **EnumVARIANT); + + +void __RPC_STUB ISpeechPhraseProperties_get__NewEnum_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechPhraseProperties_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechPhraseRule_INTERFACE_DEFINED__ +#define __ISpeechPhraseRule_INTERFACE_DEFINED__ + +/* interface ISpeechPhraseRule */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechPhraseRule; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("A7BFE112-A4A0-48d9-B602-C313843F6964") + ISpeechPhraseRule : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Name( + /* [retval][out] */ BSTR *Name) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Id( + /* [retval][out] */ long *Id) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_FirstElement( + /* [retval][out] */ long *FirstElement) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_NumberOfElements( + /* [retval][out] */ long *NumberOfElements) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Parent( + /* [retval][out] */ ISpeechPhraseRule **Parent) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Children( + /* [retval][out] */ ISpeechPhraseRules **Children) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Confidence( + /* [retval][out] */ SpeechEngineConfidence *ActualConfidence) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_EngineConfidence( + /* [retval][out] */ float *EngineConfidence) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechPhraseRuleVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechPhraseRule * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechPhraseRule * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechPhraseRule * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechPhraseRule * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechPhraseRule * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechPhraseRule * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechPhraseRule * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Name )( + ISpeechPhraseRule * This, + /* [retval][out] */ BSTR *Name); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Id )( + ISpeechPhraseRule * This, + /* [retval][out] */ long *Id); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_FirstElement )( + ISpeechPhraseRule * This, + /* [retval][out] */ long *FirstElement); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_NumberOfElements )( + ISpeechPhraseRule * This, + /* [retval][out] */ long *NumberOfElements); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Parent )( + ISpeechPhraseRule * This, + /* [retval][out] */ ISpeechPhraseRule **Parent); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Children )( + ISpeechPhraseRule * This, + /* [retval][out] */ ISpeechPhraseRules **Children); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Confidence )( + ISpeechPhraseRule * This, + /* [retval][out] */ SpeechEngineConfidence *ActualConfidence); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_EngineConfidence )( + ISpeechPhraseRule * This, + /* [retval][out] */ float *EngineConfidence); + + END_INTERFACE + } ISpeechPhraseRuleVtbl; + + interface ISpeechPhraseRule + { + CONST_VTBL struct ISpeechPhraseRuleVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechPhraseRule_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechPhraseRule_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechPhraseRule_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechPhraseRule_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechPhraseRule_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechPhraseRule_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechPhraseRule_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechPhraseRule_get_Name(This,Name) \ + (This)->lpVtbl -> get_Name(This,Name) + +#define ISpeechPhraseRule_get_Id(This,Id) \ + (This)->lpVtbl -> get_Id(This,Id) + +#define ISpeechPhraseRule_get_FirstElement(This,FirstElement) \ + (This)->lpVtbl -> get_FirstElement(This,FirstElement) + +#define ISpeechPhraseRule_get_NumberOfElements(This,NumberOfElements) \ + (This)->lpVtbl -> get_NumberOfElements(This,NumberOfElements) + +#define ISpeechPhraseRule_get_Parent(This,Parent) \ + (This)->lpVtbl -> get_Parent(This,Parent) + +#define ISpeechPhraseRule_get_Children(This,Children) \ + (This)->lpVtbl -> get_Children(This,Children) + +#define ISpeechPhraseRule_get_Confidence(This,ActualConfidence) \ + (This)->lpVtbl -> get_Confidence(This,ActualConfidence) + +#define ISpeechPhraseRule_get_EngineConfidence(This,EngineConfidence) \ + (This)->lpVtbl -> get_EngineConfidence(This,EngineConfidence) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseRule_get_Name_Proxy( + ISpeechPhraseRule * This, + /* [retval][out] */ BSTR *Name); + + +void __RPC_STUB ISpeechPhraseRule_get_Name_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseRule_get_Id_Proxy( + ISpeechPhraseRule * This, + /* [retval][out] */ long *Id); + + +void __RPC_STUB ISpeechPhraseRule_get_Id_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseRule_get_FirstElement_Proxy( + ISpeechPhraseRule * This, + /* [retval][out] */ long *FirstElement); + + +void __RPC_STUB ISpeechPhraseRule_get_FirstElement_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseRule_get_NumberOfElements_Proxy( + ISpeechPhraseRule * This, + /* [retval][out] */ long *NumberOfElements); + + +void __RPC_STUB ISpeechPhraseRule_get_NumberOfElements_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseRule_get_Parent_Proxy( + ISpeechPhraseRule * This, + /* [retval][out] */ ISpeechPhraseRule **Parent); + + +void __RPC_STUB ISpeechPhraseRule_get_Parent_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseRule_get_Children_Proxy( + ISpeechPhraseRule * This, + /* [retval][out] */ ISpeechPhraseRules **Children); + + +void __RPC_STUB ISpeechPhraseRule_get_Children_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseRule_get_Confidence_Proxy( + ISpeechPhraseRule * This, + /* [retval][out] */ SpeechEngineConfidence *ActualConfidence); + + +void __RPC_STUB ISpeechPhraseRule_get_Confidence_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseRule_get_EngineConfidence_Proxy( + ISpeechPhraseRule * This, + /* [retval][out] */ float *EngineConfidence); + + +void __RPC_STUB ISpeechPhraseRule_get_EngineConfidence_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechPhraseRule_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechPhraseRules_INTERFACE_DEFINED__ +#define __ISpeechPhraseRules_INTERFACE_DEFINED__ + +/* interface ISpeechPhraseRules */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechPhraseRules; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("9047D593-01DD-4b72-81A3-E4A0CA69F407") + ISpeechPhraseRules : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( + /* [retval][out] */ long *Count) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE Item( + /* [in] */ long Index, + /* [retval][out] */ ISpeechPhraseRule **Rule) = 0; + + virtual /* [id][restricted][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( + /* [retval][out] */ IUnknown **EnumVARIANT) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechPhraseRulesVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechPhraseRules * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechPhraseRules * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechPhraseRules * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechPhraseRules * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechPhraseRules * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechPhraseRules * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechPhraseRules * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( + ISpeechPhraseRules * This, + /* [retval][out] */ long *Count); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *Item )( + ISpeechPhraseRules * This, + /* [in] */ long Index, + /* [retval][out] */ ISpeechPhraseRule **Rule); + + /* [id][restricted][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( + ISpeechPhraseRules * This, + /* [retval][out] */ IUnknown **EnumVARIANT); + + END_INTERFACE + } ISpeechPhraseRulesVtbl; + + interface ISpeechPhraseRules + { + CONST_VTBL struct ISpeechPhraseRulesVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechPhraseRules_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechPhraseRules_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechPhraseRules_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechPhraseRules_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechPhraseRules_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechPhraseRules_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechPhraseRules_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechPhraseRules_get_Count(This,Count) \ + (This)->lpVtbl -> get_Count(This,Count) + +#define ISpeechPhraseRules_Item(This,Index,Rule) \ + (This)->lpVtbl -> Item(This,Index,Rule) + +#define ISpeechPhraseRules_get__NewEnum(This,EnumVARIANT) \ + (This)->lpVtbl -> get__NewEnum(This,EnumVARIANT) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseRules_get_Count_Proxy( + ISpeechPhraseRules * This, + /* [retval][out] */ long *Count); + + +void __RPC_STUB ISpeechPhraseRules_get_Count_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseRules_Item_Proxy( + ISpeechPhraseRules * This, + /* [in] */ long Index, + /* [retval][out] */ ISpeechPhraseRule **Rule); + + +void __RPC_STUB ISpeechPhraseRules_Item_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][restricted][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseRules_get__NewEnum_Proxy( + ISpeechPhraseRules * This, + /* [retval][out] */ IUnknown **EnumVARIANT); + + +void __RPC_STUB ISpeechPhraseRules_get__NewEnum_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechPhraseRules_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechLexicon_INTERFACE_DEFINED__ +#define __ISpeechLexicon_INTERFACE_DEFINED__ + +/* interface ISpeechLexicon */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechLexicon; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("3DA7627A-C7AE-4b23-8708-638C50362C25") + ISpeechLexicon : public IDispatch + { + public: + virtual /* [hidden][id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_GenerationId( + /* [retval][out] */ long *GenerationId) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE GetWords( + /* [defaultvalue][in] */ SpeechLexiconType Flags, + /* [defaultvalue][out] */ long *GenerationID, + /* [retval][out] */ ISpeechLexiconWords **Words) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE AddPronunciation( + /* [in] */ BSTR bstrWord, + /* [in] */ SpeechLanguageId LangId, + /* [defaultvalue][in] */ SpeechPartOfSpeech PartOfSpeech = SPSUnknown, + /* [defaultvalue][in] */ BSTR bstrPronunciation = L"") = 0; + + virtual /* [id][hidden][helpstring] */ HRESULT STDMETHODCALLTYPE AddPronunciationByPhoneIds( + /* [in] */ BSTR bstrWord, + /* [in] */ SpeechLanguageId LangId, + /* [defaultvalue][in] */ SpeechPartOfSpeech PartOfSpeech = SPSUnknown, + /* [defaultvalue][in] */ VARIANT *PhoneIds = 0) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE RemovePronunciation( + /* [in] */ BSTR bstrWord, + /* [in] */ SpeechLanguageId LangId, + /* [defaultvalue][in] */ SpeechPartOfSpeech PartOfSpeech = SPSUnknown, + /* [defaultvalue][in] */ BSTR bstrPronunciation = L"") = 0; + + virtual /* [id][hidden][helpstring] */ HRESULT STDMETHODCALLTYPE RemovePronunciationByPhoneIds( + /* [in] */ BSTR bstrWord, + /* [in] */ SpeechLanguageId LangId, + /* [defaultvalue][in] */ SpeechPartOfSpeech PartOfSpeech = SPSUnknown, + /* [defaultvalue][in] */ VARIANT *PhoneIds = 0) = 0; + + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE GetPronunciations( + /* [in] */ BSTR bstrWord, + /* [defaultvalue][in] */ SpeechLanguageId LangId, + /* [defaultvalue][in] */ SpeechLexiconType TypeFlags, + /* [retval][out] */ ISpeechLexiconPronunciations **ppPronunciations) = 0; + + virtual /* [hidden][id][helpstring] */ HRESULT STDMETHODCALLTYPE GetGenerationChange( + /* [out][in] */ long *GenerationID, + /* [retval][out] */ ISpeechLexiconWords **ppWords) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechLexiconVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechLexicon * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechLexicon * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechLexicon * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechLexicon * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechLexicon * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechLexicon * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechLexicon * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [hidden][id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_GenerationId )( + ISpeechLexicon * This, + /* [retval][out] */ long *GenerationId); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetWords )( + ISpeechLexicon * This, + /* [defaultvalue][in] */ SpeechLexiconType Flags, + /* [defaultvalue][out] */ long *GenerationID, + /* [retval][out] */ ISpeechLexiconWords **Words); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *AddPronunciation )( + ISpeechLexicon * This, + /* [in] */ BSTR bstrWord, + /* [in] */ SpeechLanguageId LangId, + /* [defaultvalue][in] */ SpeechPartOfSpeech PartOfSpeech, + /* [defaultvalue][in] */ BSTR bstrPronunciation); + + /* [id][hidden][helpstring] */ HRESULT ( STDMETHODCALLTYPE *AddPronunciationByPhoneIds )( + ISpeechLexicon * This, + /* [in] */ BSTR bstrWord, + /* [in] */ SpeechLanguageId LangId, + /* [defaultvalue][in] */ SpeechPartOfSpeech PartOfSpeech, + /* [defaultvalue][in] */ VARIANT *PhoneIds); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *RemovePronunciation )( + ISpeechLexicon * This, + /* [in] */ BSTR bstrWord, + /* [in] */ SpeechLanguageId LangId, + /* [defaultvalue][in] */ SpeechPartOfSpeech PartOfSpeech, + /* [defaultvalue][in] */ BSTR bstrPronunciation); + + /* [id][hidden][helpstring] */ HRESULT ( STDMETHODCALLTYPE *RemovePronunciationByPhoneIds )( + ISpeechLexicon * This, + /* [in] */ BSTR bstrWord, + /* [in] */ SpeechLanguageId LangId, + /* [defaultvalue][in] */ SpeechPartOfSpeech PartOfSpeech, + /* [defaultvalue][in] */ VARIANT *PhoneIds); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetPronunciations )( + ISpeechLexicon * This, + /* [in] */ BSTR bstrWord, + /* [defaultvalue][in] */ SpeechLanguageId LangId, + /* [defaultvalue][in] */ SpeechLexiconType TypeFlags, + /* [retval][out] */ ISpeechLexiconPronunciations **ppPronunciations); + + /* [hidden][id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *GetGenerationChange )( + ISpeechLexicon * This, + /* [out][in] */ long *GenerationID, + /* [retval][out] */ ISpeechLexiconWords **ppWords); + + END_INTERFACE + } ISpeechLexiconVtbl; + + interface ISpeechLexicon + { + CONST_VTBL struct ISpeechLexiconVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechLexicon_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechLexicon_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechLexicon_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechLexicon_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechLexicon_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechLexicon_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechLexicon_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechLexicon_get_GenerationId(This,GenerationId) \ + (This)->lpVtbl -> get_GenerationId(This,GenerationId) + +#define ISpeechLexicon_GetWords(This,Flags,GenerationID,Words) \ + (This)->lpVtbl -> GetWords(This,Flags,GenerationID,Words) + +#define ISpeechLexicon_AddPronunciation(This,bstrWord,LangId,PartOfSpeech,bstrPronunciation) \ + (This)->lpVtbl -> AddPronunciation(This,bstrWord,LangId,PartOfSpeech,bstrPronunciation) + +#define ISpeechLexicon_AddPronunciationByPhoneIds(This,bstrWord,LangId,PartOfSpeech,PhoneIds) \ + (This)->lpVtbl -> AddPronunciationByPhoneIds(This,bstrWord,LangId,PartOfSpeech,PhoneIds) + +#define ISpeechLexicon_RemovePronunciation(This,bstrWord,LangId,PartOfSpeech,bstrPronunciation) \ + (This)->lpVtbl -> RemovePronunciation(This,bstrWord,LangId,PartOfSpeech,bstrPronunciation) + +#define ISpeechLexicon_RemovePronunciationByPhoneIds(This,bstrWord,LangId,PartOfSpeech,PhoneIds) \ + (This)->lpVtbl -> RemovePronunciationByPhoneIds(This,bstrWord,LangId,PartOfSpeech,PhoneIds) + +#define ISpeechLexicon_GetPronunciations(This,bstrWord,LangId,TypeFlags,ppPronunciations) \ + (This)->lpVtbl -> GetPronunciations(This,bstrWord,LangId,TypeFlags,ppPronunciations) + +#define ISpeechLexicon_GetGenerationChange(This,GenerationID,ppWords) \ + (This)->lpVtbl -> GetGenerationChange(This,GenerationID,ppWords) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [hidden][id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechLexicon_get_GenerationId_Proxy( + ISpeechLexicon * This, + /* [retval][out] */ long *GenerationId); + + +void __RPC_STUB ISpeechLexicon_get_GenerationId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechLexicon_GetWords_Proxy( + ISpeechLexicon * This, + /* [defaultvalue][in] */ SpeechLexiconType Flags, + /* [defaultvalue][out] */ long *GenerationID, + /* [retval][out] */ ISpeechLexiconWords **Words); + + +void __RPC_STUB ISpeechLexicon_GetWords_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechLexicon_AddPronunciation_Proxy( + ISpeechLexicon * This, + /* [in] */ BSTR bstrWord, + /* [in] */ SpeechLanguageId LangId, + /* [defaultvalue][in] */ SpeechPartOfSpeech PartOfSpeech, + /* [defaultvalue][in] */ BSTR bstrPronunciation); + + +void __RPC_STUB ISpeechLexicon_AddPronunciation_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][hidden][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechLexicon_AddPronunciationByPhoneIds_Proxy( + ISpeechLexicon * This, + /* [in] */ BSTR bstrWord, + /* [in] */ SpeechLanguageId LangId, + /* [defaultvalue][in] */ SpeechPartOfSpeech PartOfSpeech, + /* [defaultvalue][in] */ VARIANT *PhoneIds); + + +void __RPC_STUB ISpeechLexicon_AddPronunciationByPhoneIds_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechLexicon_RemovePronunciation_Proxy( + ISpeechLexicon * This, + /* [in] */ BSTR bstrWord, + /* [in] */ SpeechLanguageId LangId, + /* [defaultvalue][in] */ SpeechPartOfSpeech PartOfSpeech, + /* [defaultvalue][in] */ BSTR bstrPronunciation); + + +void __RPC_STUB ISpeechLexicon_RemovePronunciation_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][hidden][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechLexicon_RemovePronunciationByPhoneIds_Proxy( + ISpeechLexicon * This, + /* [in] */ BSTR bstrWord, + /* [in] */ SpeechLanguageId LangId, + /* [defaultvalue][in] */ SpeechPartOfSpeech PartOfSpeech, + /* [defaultvalue][in] */ VARIANT *PhoneIds); + + +void __RPC_STUB ISpeechLexicon_RemovePronunciationByPhoneIds_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechLexicon_GetPronunciations_Proxy( + ISpeechLexicon * This, + /* [in] */ BSTR bstrWord, + /* [defaultvalue][in] */ SpeechLanguageId LangId, + /* [defaultvalue][in] */ SpeechLexiconType TypeFlags, + /* [retval][out] */ ISpeechLexiconPronunciations **ppPronunciations); + + +void __RPC_STUB ISpeechLexicon_GetPronunciations_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [hidden][id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechLexicon_GetGenerationChange_Proxy( + ISpeechLexicon * This, + /* [out][in] */ long *GenerationID, + /* [retval][out] */ ISpeechLexiconWords **ppWords); + + +void __RPC_STUB ISpeechLexicon_GetGenerationChange_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechLexicon_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechLexiconWords_INTERFACE_DEFINED__ +#define __ISpeechLexiconWords_INTERFACE_DEFINED__ + +/* interface ISpeechLexiconWords */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechLexiconWords; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("8D199862-415E-47d5-AC4F-FAA608B424E6") + ISpeechLexiconWords : public IDispatch + { + public: + virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_Count( + /* [retval][out] */ long *Count) = 0; + + virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( + /* [in] */ long Index, + /* [retval][out] */ ISpeechLexiconWord **Word) = 0; + + virtual /* [restricted][helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get__NewEnum( + /* [retval][out] */ IUnknown **EnumVARIANT) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechLexiconWordsVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechLexiconWords * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechLexiconWords * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechLexiconWords * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechLexiconWords * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechLexiconWords * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechLexiconWords * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechLexiconWords * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [helpstring][propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( + ISpeechLexiconWords * This, + /* [retval][out] */ long *Count); + + /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( + ISpeechLexiconWords * This, + /* [in] */ long Index, + /* [retval][out] */ ISpeechLexiconWord **Word); + + /* [restricted][helpstring][propget][id] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( + ISpeechLexiconWords * This, + /* [retval][out] */ IUnknown **EnumVARIANT); + + END_INTERFACE + } ISpeechLexiconWordsVtbl; + + interface ISpeechLexiconWords + { + CONST_VTBL struct ISpeechLexiconWordsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechLexiconWords_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechLexiconWords_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechLexiconWords_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechLexiconWords_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechLexiconWords_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechLexiconWords_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechLexiconWords_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechLexiconWords_get_Count(This,Count) \ + (This)->lpVtbl -> get_Count(This,Count) + +#define ISpeechLexiconWords_Item(This,Index,Word) \ + (This)->lpVtbl -> Item(This,Index,Word) + +#define ISpeechLexiconWords_get__NewEnum(This,EnumVARIANT) \ + (This)->lpVtbl -> get__NewEnum(This,EnumVARIANT) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE ISpeechLexiconWords_get_Count_Proxy( + ISpeechLexiconWords * This, + /* [retval][out] */ long *Count); + + +void __RPC_STUB ISpeechLexiconWords_get_Count_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring][id] */ HRESULT STDMETHODCALLTYPE ISpeechLexiconWords_Item_Proxy( + ISpeechLexiconWords * This, + /* [in] */ long Index, + /* [retval][out] */ ISpeechLexiconWord **Word); + + +void __RPC_STUB ISpeechLexiconWords_Item_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [restricted][helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE ISpeechLexiconWords_get__NewEnum_Proxy( + ISpeechLexiconWords * This, + /* [retval][out] */ IUnknown **EnumVARIANT); + + +void __RPC_STUB ISpeechLexiconWords_get__NewEnum_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechLexiconWords_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechLexiconWord_INTERFACE_DEFINED__ +#define __ISpeechLexiconWord_INTERFACE_DEFINED__ + +/* interface ISpeechLexiconWord */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechLexiconWord; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("4E5B933C-C9BE-48ed-8842-1EE51BB1D4FF") + ISpeechLexiconWord : public IDispatch + { + public: + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_LangId( + /* [retval][out] */ SpeechLanguageId *LangId) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Type( + /* [retval][out] */ SpeechWordType *WordType) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Word( + /* [retval][out] */ BSTR *Word) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Pronunciations( + /* [retval][out] */ ISpeechLexiconPronunciations **Pronunciations) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechLexiconWordVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechLexiconWord * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechLexiconWord * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechLexiconWord * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechLexiconWord * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechLexiconWord * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechLexiconWord * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechLexiconWord * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_LangId )( + ISpeechLexiconWord * This, + /* [retval][out] */ SpeechLanguageId *LangId); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Type )( + ISpeechLexiconWord * This, + /* [retval][out] */ SpeechWordType *WordType); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Word )( + ISpeechLexiconWord * This, + /* [retval][out] */ BSTR *Word); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Pronunciations )( + ISpeechLexiconWord * This, + /* [retval][out] */ ISpeechLexiconPronunciations **Pronunciations); + + END_INTERFACE + } ISpeechLexiconWordVtbl; + + interface ISpeechLexiconWord + { + CONST_VTBL struct ISpeechLexiconWordVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechLexiconWord_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechLexiconWord_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechLexiconWord_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechLexiconWord_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechLexiconWord_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechLexiconWord_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechLexiconWord_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechLexiconWord_get_LangId(This,LangId) \ + (This)->lpVtbl -> get_LangId(This,LangId) + +#define ISpeechLexiconWord_get_Type(This,WordType) \ + (This)->lpVtbl -> get_Type(This,WordType) + +#define ISpeechLexiconWord_get_Word(This,Word) \ + (This)->lpVtbl -> get_Word(This,Word) + +#define ISpeechLexiconWord_get_Pronunciations(This,Pronunciations) \ + (This)->lpVtbl -> get_Pronunciations(This,Pronunciations) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [propget][id] */ HRESULT STDMETHODCALLTYPE ISpeechLexiconWord_get_LangId_Proxy( + ISpeechLexiconWord * This, + /* [retval][out] */ SpeechLanguageId *LangId); + + +void __RPC_STUB ISpeechLexiconWord_get_LangId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [propget][id] */ HRESULT STDMETHODCALLTYPE ISpeechLexiconWord_get_Type_Proxy( + ISpeechLexiconWord * This, + /* [retval][out] */ SpeechWordType *WordType); + + +void __RPC_STUB ISpeechLexiconWord_get_Type_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [propget][id] */ HRESULT STDMETHODCALLTYPE ISpeechLexiconWord_get_Word_Proxy( + ISpeechLexiconWord * This, + /* [retval][out] */ BSTR *Word); + + +void __RPC_STUB ISpeechLexiconWord_get_Word_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [propget][id] */ HRESULT STDMETHODCALLTYPE ISpeechLexiconWord_get_Pronunciations_Proxy( + ISpeechLexiconWord * This, + /* [retval][out] */ ISpeechLexiconPronunciations **Pronunciations); + + +void __RPC_STUB ISpeechLexiconWord_get_Pronunciations_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechLexiconWord_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechLexiconPronunciations_INTERFACE_DEFINED__ +#define __ISpeechLexiconPronunciations_INTERFACE_DEFINED__ + +/* interface ISpeechLexiconPronunciations */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechLexiconPronunciations; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("72829128-5682-4704-A0D4-3E2BB6F2EAD3") + ISpeechLexiconPronunciations : public IDispatch + { + public: + virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_Count( + /* [retval][out] */ long *Count) = 0; + + virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( + /* [in] */ long Index, + /* [retval][out] */ ISpeechLexiconPronunciation **Pronunciation) = 0; + + virtual /* [restricted][helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get__NewEnum( + /* [retval][out] */ IUnknown **EnumVARIANT) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechLexiconPronunciationsVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechLexiconPronunciations * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechLexiconPronunciations * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechLexiconPronunciations * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechLexiconPronunciations * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechLexiconPronunciations * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechLexiconPronunciations * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechLexiconPronunciations * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [helpstring][propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( + ISpeechLexiconPronunciations * This, + /* [retval][out] */ long *Count); + + /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( + ISpeechLexiconPronunciations * This, + /* [in] */ long Index, + /* [retval][out] */ ISpeechLexiconPronunciation **Pronunciation); + + /* [restricted][helpstring][propget][id] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( + ISpeechLexiconPronunciations * This, + /* [retval][out] */ IUnknown **EnumVARIANT); + + END_INTERFACE + } ISpeechLexiconPronunciationsVtbl; + + interface ISpeechLexiconPronunciations + { + CONST_VTBL struct ISpeechLexiconPronunciationsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechLexiconPronunciations_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechLexiconPronunciations_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechLexiconPronunciations_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechLexiconPronunciations_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechLexiconPronunciations_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechLexiconPronunciations_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechLexiconPronunciations_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechLexiconPronunciations_get_Count(This,Count) \ + (This)->lpVtbl -> get_Count(This,Count) + +#define ISpeechLexiconPronunciations_Item(This,Index,Pronunciation) \ + (This)->lpVtbl -> Item(This,Index,Pronunciation) + +#define ISpeechLexiconPronunciations_get__NewEnum(This,EnumVARIANT) \ + (This)->lpVtbl -> get__NewEnum(This,EnumVARIANT) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE ISpeechLexiconPronunciations_get_Count_Proxy( + ISpeechLexiconPronunciations * This, + /* [retval][out] */ long *Count); + + +void __RPC_STUB ISpeechLexiconPronunciations_get_Count_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring][id] */ HRESULT STDMETHODCALLTYPE ISpeechLexiconPronunciations_Item_Proxy( + ISpeechLexiconPronunciations * This, + /* [in] */ long Index, + /* [retval][out] */ ISpeechLexiconPronunciation **Pronunciation); + + +void __RPC_STUB ISpeechLexiconPronunciations_Item_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [restricted][helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE ISpeechLexiconPronunciations_get__NewEnum_Proxy( + ISpeechLexiconPronunciations * This, + /* [retval][out] */ IUnknown **EnumVARIANT); + + +void __RPC_STUB ISpeechLexiconPronunciations_get__NewEnum_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechLexiconPronunciations_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechLexiconPronunciation_INTERFACE_DEFINED__ +#define __ISpeechLexiconPronunciation_INTERFACE_DEFINED__ + +/* interface ISpeechLexiconPronunciation */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechLexiconPronunciation; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("95252C5D-9E43-4f4a-9899-48EE73352F9F") + ISpeechLexiconPronunciation : public IDispatch + { + public: + virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_Type( + /* [retval][out] */ SpeechLexiconType *LexiconType) = 0; + + virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_LangId( + /* [retval][out] */ SpeechLanguageId *LangId) = 0; + + virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_PartOfSpeech( + /* [retval][out] */ SpeechPartOfSpeech *PartOfSpeech) = 0; + + virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_PhoneIds( + /* [retval][out] */ VARIANT *PhoneIds) = 0; + + virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE get_Symbolic( + /* [retval][out] */ BSTR *Symbolic) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechLexiconPronunciationVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechLexiconPronunciation * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechLexiconPronunciation * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechLexiconPronunciation * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechLexiconPronunciation * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechLexiconPronunciation * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechLexiconPronunciation * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechLexiconPronunciation * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [helpstring][propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Type )( + ISpeechLexiconPronunciation * This, + /* [retval][out] */ SpeechLexiconType *LexiconType); + + /* [helpstring][propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_LangId )( + ISpeechLexiconPronunciation * This, + /* [retval][out] */ SpeechLanguageId *LangId); + + /* [helpstring][propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_PartOfSpeech )( + ISpeechLexiconPronunciation * This, + /* [retval][out] */ SpeechPartOfSpeech *PartOfSpeech); + + /* [helpstring][propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_PhoneIds )( + ISpeechLexiconPronunciation * This, + /* [retval][out] */ VARIANT *PhoneIds); + + /* [helpstring][propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Symbolic )( + ISpeechLexiconPronunciation * This, + /* [retval][out] */ BSTR *Symbolic); + + END_INTERFACE + } ISpeechLexiconPronunciationVtbl; + + interface ISpeechLexiconPronunciation + { + CONST_VTBL struct ISpeechLexiconPronunciationVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechLexiconPronunciation_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechLexiconPronunciation_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechLexiconPronunciation_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechLexiconPronunciation_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechLexiconPronunciation_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechLexiconPronunciation_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechLexiconPronunciation_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechLexiconPronunciation_get_Type(This,LexiconType) \ + (This)->lpVtbl -> get_Type(This,LexiconType) + +#define ISpeechLexiconPronunciation_get_LangId(This,LangId) \ + (This)->lpVtbl -> get_LangId(This,LangId) + +#define ISpeechLexiconPronunciation_get_PartOfSpeech(This,PartOfSpeech) \ + (This)->lpVtbl -> get_PartOfSpeech(This,PartOfSpeech) + +#define ISpeechLexiconPronunciation_get_PhoneIds(This,PhoneIds) \ + (This)->lpVtbl -> get_PhoneIds(This,PhoneIds) + +#define ISpeechLexiconPronunciation_get_Symbolic(This,Symbolic) \ + (This)->lpVtbl -> get_Symbolic(This,Symbolic) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE ISpeechLexiconPronunciation_get_Type_Proxy( + ISpeechLexiconPronunciation * This, + /* [retval][out] */ SpeechLexiconType *LexiconType); + + +void __RPC_STUB ISpeechLexiconPronunciation_get_Type_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE ISpeechLexiconPronunciation_get_LangId_Proxy( + ISpeechLexiconPronunciation * This, + /* [retval][out] */ SpeechLanguageId *LangId); + + +void __RPC_STUB ISpeechLexiconPronunciation_get_LangId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE ISpeechLexiconPronunciation_get_PartOfSpeech_Proxy( + ISpeechLexiconPronunciation * This, + /* [retval][out] */ SpeechPartOfSpeech *PartOfSpeech); + + +void __RPC_STUB ISpeechLexiconPronunciation_get_PartOfSpeech_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE ISpeechLexiconPronunciation_get_PhoneIds_Proxy( + ISpeechLexiconPronunciation * This, + /* [retval][out] */ VARIANT *PhoneIds); + + +void __RPC_STUB ISpeechLexiconPronunciation_get_PhoneIds_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE ISpeechLexiconPronunciation_get_Symbolic_Proxy( + ISpeechLexiconPronunciation * This, + /* [retval][out] */ BSTR *Symbolic); + + +void __RPC_STUB ISpeechLexiconPronunciation_get_Symbolic_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechLexiconPronunciation_INTERFACE_DEFINED__ */ + + + +#ifndef __SpeechStringConstants_MODULE_DEFINED__ +#define __SpeechStringConstants_MODULE_DEFINED__ + + +/* module SpeechStringConstants */ +/* [uuid] */ + +const BSTR SpeechRegistryUserRoot = L"HKEY_CURRENT_USER\SOFTWARE\Microsoft\Speech"; + +const BSTR SpeechRegistryLocalMachineRoot = L"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Speech"; + +const BSTR SpeechCategoryAudioOut = L"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Speech\AudioOutput"; + +const BSTR SpeechCategoryAudioIn = L"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Speech\AudioInput"; + +const BSTR SpeechCategoryVoices = L"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Speech\Voices"; + +const BSTR SpeechCategoryRecognizers = L"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Speech\Recognizers"; + +const BSTR SpeechCategoryAppLexicons = L"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Speech\AppLexicons"; + +const BSTR SpeechCategoryPhoneConverters = L"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Speech\PhoneConverters"; + +const BSTR SpeechCategoryRecoProfiles = L"HKEY_CURRENT_USER\SOFTWARE\Microsoft\Speech\RecoProfiles"; + +const BSTR SpeechTokenIdUserLexicon = L"HKEY_CURRENT_USER\SOFTWARE\Microsoft\Speech\CurrentUserLexicon"; + +const BSTR SpeechTokenValueCLSID = L"CLSID"; + +const BSTR SpeechTokenKeyFiles = L"Files"; + +const BSTR SpeechTokenKeyUI = L"UI"; + +const BSTR SpeechTokenKeyAttributes = L"Attributes"; + +const BSTR SpeechVoiceCategoryTTSRate = L"DefaultTTSRate"; + +const BSTR SpeechPropertyResourceUsage = L"ResourceUsage"; + +const BSTR SpeechPropertyHighConfidenceThreshold = L"HighConfidenceThreshold"; + +const BSTR SpeechPropertyNormalConfidenceThreshold = L"NormalConfidenceThreshold"; + +const BSTR SpeechPropertyLowConfidenceThreshold = L"LowConfidenceThreshold"; + +const BSTR SpeechPropertyResponseSpeed = L"ResponseSpeed"; + +const BSTR SpeechPropertyComplexResponseSpeed = L"ComplexResponseSpeed"; + +const BSTR SpeechPropertyAdaptationOn = L"AdaptationOn"; + +const BSTR SpeechDictationTopicSpelling = L"Spelling"; + +const BSTR SpeechGrammarTagWildcard = L"..."; + +const BSTR SpeechGrammarTagDictation = L"*"; + +const BSTR SpeechGrammarTagUnlimitedDictation = L"*+"; + +const BSTR SpeechEngineProperties = L"EngineProperties"; + +const BSTR SpeechAddRemoveWord = L"AddRemoveWord"; + +const BSTR SpeechUserTraining = L"UserTraining"; + +const BSTR SpeechMicTraining = L"MicTraining"; + +const BSTR SpeechRecoProfileProperties = L"RecoProfileProperties"; + +const BSTR SpeechAudioProperties = L"AudioProperties"; + +const BSTR SpeechAudioVolume = L"AudioVolume"; + +const BSTR SpeechVoiceSkipTypeSentence = L"Sentence"; + +const BSTR SpeechAudioFormatGUIDWave = L"{C31ADBAE-527F-4ff5-A230-F62BB61FF70C}"; + +const BSTR SpeechAudioFormatGUIDText = L"{7CEEF9F9-3D13-11d2-9EE7-00C04F797396}"; + +#endif /* __SpeechStringConstants_MODULE_DEFINED__ */ + + +#ifndef __SpeechConstants_MODULE_DEFINED__ +#define __SpeechConstants_MODULE_DEFINED__ + + +/* module SpeechConstants */ +/* [uuid] */ + +const float Speech_Default_Weight = DEFAULT_WEIGHT; + +const LONG Speech_Max_Word_Length = SP_MAX_WORD_LENGTH; + +const LONG Speech_Max_Pron_Length = SP_MAX_PRON_LENGTH; + +const LONG Speech_StreamPos_Asap = SP_STREAMPOS_ASAP; + +const LONG Speech_StreamPos_RealTime = SP_STREAMPOS_REALTIME; + +const LONG SpeechAllElements = SPPR_ALL_ELEMENTS; + +#endif /* __SpeechConstants_MODULE_DEFINED__ */ + +#ifndef __ISpeechPhraseInfoBuilder_INTERFACE_DEFINED__ +#define __ISpeechPhraseInfoBuilder_INTERFACE_DEFINED__ + +/* interface ISpeechPhraseInfoBuilder */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechPhraseInfoBuilder; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("3B151836-DF3A-4E0A-846C-D2ADC9334333") + ISpeechPhraseInfoBuilder : public IDispatch + { + public: + virtual /* [id][helpstring] */ HRESULT STDMETHODCALLTYPE RestorePhraseFromMemory( + /* [in] */ VARIANT *PhraseInMemory, + /* [retval][out] */ ISpeechPhraseInfo **PhraseInfo) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechPhraseInfoBuilderVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechPhraseInfoBuilder * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechPhraseInfoBuilder * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechPhraseInfoBuilder * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechPhraseInfoBuilder * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechPhraseInfoBuilder * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechPhraseInfoBuilder * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechPhraseInfoBuilder * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring] */ HRESULT ( STDMETHODCALLTYPE *RestorePhraseFromMemory )( + ISpeechPhraseInfoBuilder * This, + /* [in] */ VARIANT *PhraseInMemory, + /* [retval][out] */ ISpeechPhraseInfo **PhraseInfo); + + END_INTERFACE + } ISpeechPhraseInfoBuilderVtbl; + + interface ISpeechPhraseInfoBuilder + { + CONST_VTBL struct ISpeechPhraseInfoBuilderVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechPhraseInfoBuilder_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechPhraseInfoBuilder_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechPhraseInfoBuilder_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechPhraseInfoBuilder_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechPhraseInfoBuilder_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechPhraseInfoBuilder_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechPhraseInfoBuilder_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechPhraseInfoBuilder_RestorePhraseFromMemory(This,PhraseInMemory,PhraseInfo) \ + (This)->lpVtbl -> RestorePhraseFromMemory(This,PhraseInMemory,PhraseInfo) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring] */ HRESULT STDMETHODCALLTYPE ISpeechPhraseInfoBuilder_RestorePhraseFromMemory_Proxy( + ISpeechPhraseInfoBuilder * This, + /* [in] */ VARIANT *PhraseInMemory, + /* [retval][out] */ ISpeechPhraseInfo **PhraseInfo); + + +void __RPC_STUB ISpeechPhraseInfoBuilder_RestorePhraseFromMemory_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechPhraseInfoBuilder_INTERFACE_DEFINED__ */ + + +#ifndef __ISpeechPhoneConverter_INTERFACE_DEFINED__ +#define __ISpeechPhoneConverter_INTERFACE_DEFINED__ + +/* interface ISpeechPhoneConverter */ +/* [unique][helpstring][dual][uuid][object] */ + + +EXTERN_C const IID IID_ISpeechPhoneConverter; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("C3E4F353-433F-43d6-89A1-6A62A7054C3D") + ISpeechPhoneConverter : public IDispatch + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_LanguageId( + /* [retval][out] */ SpeechLanguageId *LanguageId) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_LanguageId( + /* [in] */ SpeechLanguageId LanguageId) = 0; + + virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE PhoneToId( + /* [in] */ const BSTR Phonemes, + /* [retval][out] */ VARIANT *IdArray) = 0; + + virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE IdToPhone( + /* [in] */ const VARIANT IdArray, + /* [retval][out] */ BSTR *Phonemes) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpeechPhoneConverterVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpeechPhoneConverter * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpeechPhoneConverter * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpeechPhoneConverter * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + ISpeechPhoneConverter * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + ISpeechPhoneConverter * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + ISpeechPhoneConverter * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + ISpeechPhoneConverter * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_LanguageId )( + ISpeechPhoneConverter * This, + /* [retval][out] */ SpeechLanguageId *LanguageId); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_LanguageId )( + ISpeechPhoneConverter * This, + /* [in] */ SpeechLanguageId LanguageId); + + /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *PhoneToId )( + ISpeechPhoneConverter * This, + /* [in] */ const BSTR Phonemes, + /* [retval][out] */ VARIANT *IdArray); + + /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *IdToPhone )( + ISpeechPhoneConverter * This, + /* [in] */ const VARIANT IdArray, + /* [retval][out] */ BSTR *Phonemes); + + END_INTERFACE + } ISpeechPhoneConverterVtbl; + + interface ISpeechPhoneConverter + { + CONST_VTBL struct ISpeechPhoneConverterVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpeechPhoneConverter_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpeechPhoneConverter_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpeechPhoneConverter_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpeechPhoneConverter_GetTypeInfoCount(This,pctinfo) \ + (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) + +#define ISpeechPhoneConverter_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) + +#define ISpeechPhoneConverter_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) + +#define ISpeechPhoneConverter_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) + + +#define ISpeechPhoneConverter_get_LanguageId(This,LanguageId) \ + (This)->lpVtbl -> get_LanguageId(This,LanguageId) + +#define ISpeechPhoneConverter_put_LanguageId(This,LanguageId) \ + (This)->lpVtbl -> put_LanguageId(This,LanguageId) + +#define ISpeechPhoneConverter_PhoneToId(This,Phonemes,IdArray) \ + (This)->lpVtbl -> PhoneToId(This,Phonemes,IdArray) + +#define ISpeechPhoneConverter_IdToPhone(This,IdArray,Phonemes) \ + (This)->lpVtbl -> IdToPhone(This,IdArray,Phonemes) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE ISpeechPhoneConverter_get_LanguageId_Proxy( + ISpeechPhoneConverter * This, + /* [retval][out] */ SpeechLanguageId *LanguageId); + + +void __RPC_STUB ISpeechPhoneConverter_get_LanguageId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE ISpeechPhoneConverter_put_LanguageId_Proxy( + ISpeechPhoneConverter * This, + /* [in] */ SpeechLanguageId LanguageId); + + +void __RPC_STUB ISpeechPhoneConverter_put_LanguageId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring][id] */ HRESULT STDMETHODCALLTYPE ISpeechPhoneConverter_PhoneToId_Proxy( + ISpeechPhoneConverter * This, + /* [in] */ const BSTR Phonemes, + /* [retval][out] */ VARIANT *IdArray); + + +void __RPC_STUB ISpeechPhoneConverter_PhoneToId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [helpstring][id] */ HRESULT STDMETHODCALLTYPE ISpeechPhoneConverter_IdToPhone_Proxy( + ISpeechPhoneConverter * This, + /* [in] */ const VARIANT IdArray, + /* [retval][out] */ BSTR *Phonemes); + + +void __RPC_STUB ISpeechPhoneConverter_IdToPhone_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpeechPhoneConverter_INTERFACE_DEFINED__ */ + + +EXTERN_C const CLSID CLSID_SpNotifyTranslator; + +#ifdef __cplusplus + +class DECLSPEC_UUID("E2AE5372-5D40-11D2-960E-00C04F8EE628") +SpNotifyTranslator; +#endif + +EXTERN_C const CLSID CLSID_SpObjectTokenCategory; + +#ifdef __cplusplus + +class DECLSPEC_UUID("A910187F-0C7A-45AC-92CC-59EDAFB77B53") +SpObjectTokenCategory; +#endif + +EXTERN_C const CLSID CLSID_SpObjectToken; + +#ifdef __cplusplus + +class DECLSPEC_UUID("EF411752-3736-4CB4-9C8C-8EF4CCB58EFE") +SpObjectToken; +#endif + +EXTERN_C const CLSID CLSID_SpResourceManager; + +#ifdef __cplusplus + +class DECLSPEC_UUID("96749373-3391-11D2-9EE3-00C04F797396") +SpResourceManager; +#endif + +EXTERN_C const CLSID CLSID_SpStreamFormatConverter; + +#ifdef __cplusplus + +class DECLSPEC_UUID("7013943A-E2EC-11D2-A086-00C04F8EF9B5") +SpStreamFormatConverter; +#endif + +EXTERN_C const CLSID CLSID_SpMMAudioEnum; + +#ifdef __cplusplus + +class DECLSPEC_UUID("AB1890A0-E91F-11D2-BB91-00C04F8EE6C0") +SpMMAudioEnum; +#endif + +EXTERN_C const CLSID CLSID_SpMMAudioIn; + +#ifdef __cplusplus + +class DECLSPEC_UUID("CF3D2E50-53F2-11D2-960C-00C04F8EE628") +SpMMAudioIn; +#endif + +EXTERN_C const CLSID CLSID_SpMMAudioOut; + +#ifdef __cplusplus + +class DECLSPEC_UUID("A8C680EB-3D32-11D2-9EE7-00C04F797396") +SpMMAudioOut; +#endif + +EXTERN_C const CLSID CLSID_SpRecPlayAudio; + +#ifdef __cplusplus + +class DECLSPEC_UUID("FEE225FC-7AFD-45E9-95D0-5A318079D911") +SpRecPlayAudio; +#endif + +EXTERN_C const CLSID CLSID_SpStream; + +#ifdef __cplusplus + +class DECLSPEC_UUID("715D9C59-4442-11D2-9605-00C04F8EE628") +SpStream; +#endif + +EXTERN_C const CLSID CLSID_SpVoice; + +#ifdef __cplusplus + +class DECLSPEC_UUID("96749377-3391-11D2-9EE3-00C04F797396") +SpVoice; +#endif + +EXTERN_C const CLSID CLSID_SpSharedRecoContext; + +#ifdef __cplusplus + +class DECLSPEC_UUID("47206204-5ECA-11D2-960F-00C04F8EE628") +SpSharedRecoContext; +#endif + +EXTERN_C const CLSID CLSID_SpInprocRecognizer; + +#ifdef __cplusplus + +class DECLSPEC_UUID("41B89B6B-9399-11D2-9623-00C04F8EE628") +SpInprocRecognizer; +#endif + +EXTERN_C const CLSID CLSID_SpSharedRecognizer; + +#ifdef __cplusplus + +class DECLSPEC_UUID("3BEE4890-4FE9-4A37-8C1E-5E7E12791C1F") +SpSharedRecognizer; +#endif + +EXTERN_C const CLSID CLSID_SpLexicon; + +#ifdef __cplusplus + +class DECLSPEC_UUID("0655E396-25D0-11D3-9C26-00C04F8EF87C") +SpLexicon; +#endif + +EXTERN_C const CLSID CLSID_SpUnCompressedLexicon; + +#ifdef __cplusplus + +class DECLSPEC_UUID("C9E37C15-DF92-4727-85D6-72E5EEB6995A") +SpUnCompressedLexicon; +#endif + +EXTERN_C const CLSID CLSID_SpCompressedLexicon; + +#ifdef __cplusplus + +class DECLSPEC_UUID("90903716-2F42-11D3-9C26-00C04F8EF87C") +SpCompressedLexicon; +#endif + +EXTERN_C const CLSID CLSID_SpPhoneConverter; + +#ifdef __cplusplus + +class DECLSPEC_UUID("9185F743-1143-4C28-86B5-BFF14F20E5C8") +SpPhoneConverter; +#endif + +EXTERN_C const CLSID CLSID_SpNullPhoneConverter; + +#ifdef __cplusplus + +class DECLSPEC_UUID("455F24E9-7396-4A16-9715-7C0FDBE3EFE3") +SpNullPhoneConverter; +#endif + +EXTERN_C const CLSID CLSID_SpTextSelectionInformation; + +#ifdef __cplusplus + +class DECLSPEC_UUID("0F92030A-CBFD-4AB8-A164-FF5985547FF6") +SpTextSelectionInformation; +#endif + +EXTERN_C const CLSID CLSID_SpPhraseInfoBuilder; + +#ifdef __cplusplus + +class DECLSPEC_UUID("C23FC28D-C55F-4720-8B32-91F73C2BD5D1") +SpPhraseInfoBuilder; +#endif + +EXTERN_C const CLSID CLSID_SpAudioFormat; + +#ifdef __cplusplus + +class DECLSPEC_UUID("9EF96870-E160-4792-820D-48CF0649E4EC") +SpAudioFormat; +#endif + +EXTERN_C const CLSID CLSID_SpWaveFormatEx; + +#ifdef __cplusplus + +class DECLSPEC_UUID("C79A574C-63BE-44b9-801F-283F87F898BE") +SpWaveFormatEx; +#endif + +EXTERN_C const CLSID CLSID_SpInProcRecoContext; + +#ifdef __cplusplus + +class DECLSPEC_UUID("73AD6842-ACE0-45E8-A4DD-8795881A2C2A") +SpInProcRecoContext; +#endif + +EXTERN_C const CLSID CLSID_SpCustomStream; + +#ifdef __cplusplus + +class DECLSPEC_UUID("8DBEF13F-1948-4aa8-8CF0-048EEBED95D8") +SpCustomStream; +#endif + +EXTERN_C const CLSID CLSID_SpFileStream; + +#ifdef __cplusplus + +class DECLSPEC_UUID("947812B3-2AE1-4644-BA86-9E90DED7EC91") +SpFileStream; +#endif + +EXTERN_C const CLSID CLSID_SpMemoryStream; + +#ifdef __cplusplus + +class DECLSPEC_UUID("5FB7EF7D-DFF4-468a-B6B7-2FCBD188F994") +SpMemoryStream; +#endif +#endif /* __SpeechLib_LIBRARY_DEFINED__ */ + +/* Additional Prototypes for ALL interfaces */ + +/* end of Additional Prototypes */ + +#ifdef __cplusplus +} +#endif + +#endif + + diff --git a/speech2/third_party/sapi5/include/sapiddk.h b/speech2/third_party/sapi5/include/sapiddk.h new file mode 100644 index 0000000..c311aad --- /dev/null +++ b/speech2/third_party/sapi5/include/sapiddk.h @@ -0,0 +1,4557 @@ + +#pragma warning( disable: 4049 ) /* more than 64k source lines */ + +/* this ALWAYS GENERATED file contains the definitions for the interfaces */ + + + /* File created by MIDL compiler version 6.00.0347 */ +/* Compiler settings for sapiddk.idl: + Oicf, W1, Zp8, env=Win32 (32b run) + protocol : dce , ms_ext, c_ext + error checks: allocation ref bounds_check enum stub_data + VC __declspec() decoration level: + __declspec(uuid()), __declspec(selectany), __declspec(novtable) + DECLSPEC_UUID(), MIDL_INTERFACE() +*/ +//@@MIDL_FILE_HEADING( ) + + +/* verify that the version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCNDR_H_VERSION__ +#define __REQUIRED_RPCNDR_H_VERSION__ 440 +#endif + +#include "rpc.h" +#include "rpcndr.h" + +#ifndef __RPCNDR_H_VERSION__ +#error this stub requires an updated version of +#endif // __RPCNDR_H_VERSION__ + +#ifndef COM_NO_WINDOWS_H +#include "windows.h" +#include "ole2.h" +#endif /*COM_NO_WINDOWS_H*/ + +#ifndef __sapiddk_h__ +#define __sapiddk_h__ + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#pragma once +#endif + +/* Forward Declarations */ + +#ifndef __ISpTokenUI_FWD_DEFINED__ +#define __ISpTokenUI_FWD_DEFINED__ +typedef interface ISpTokenUI ISpTokenUI; +#endif /* __ISpTokenUI_FWD_DEFINED__ */ + + +#ifndef __ISpObjectTokenEnumBuilder_FWD_DEFINED__ +#define __ISpObjectTokenEnumBuilder_FWD_DEFINED__ +typedef interface ISpObjectTokenEnumBuilder ISpObjectTokenEnumBuilder; +#endif /* __ISpObjectTokenEnumBuilder_FWD_DEFINED__ */ + + +#ifndef __ISpErrorLog_FWD_DEFINED__ +#define __ISpErrorLog_FWD_DEFINED__ +typedef interface ISpErrorLog ISpErrorLog; +#endif /* __ISpErrorLog_FWD_DEFINED__ */ + + +#ifndef __ISpGrammarCompiler_FWD_DEFINED__ +#define __ISpGrammarCompiler_FWD_DEFINED__ +typedef interface ISpGrammarCompiler ISpGrammarCompiler; +#endif /* __ISpGrammarCompiler_FWD_DEFINED__ */ + + +#ifndef __ISpGramCompBackend_FWD_DEFINED__ +#define __ISpGramCompBackend_FWD_DEFINED__ +typedef interface ISpGramCompBackend ISpGramCompBackend; +#endif /* __ISpGramCompBackend_FWD_DEFINED__ */ + + +#ifndef __ISpITNProcessor_FWD_DEFINED__ +#define __ISpITNProcessor_FWD_DEFINED__ +typedef interface ISpITNProcessor ISpITNProcessor; +#endif /* __ISpITNProcessor_FWD_DEFINED__ */ + + +#ifndef __ISpPhraseBuilder_FWD_DEFINED__ +#define __ISpPhraseBuilder_FWD_DEFINED__ +typedef interface ISpPhraseBuilder ISpPhraseBuilder; +#endif /* __ISpPhraseBuilder_FWD_DEFINED__ */ + + +#ifndef __ISpThreadControl_FWD_DEFINED__ +#define __ISpThreadControl_FWD_DEFINED__ +typedef interface ISpThreadControl ISpThreadControl; +#endif /* __ISpThreadControl_FWD_DEFINED__ */ + + +#ifndef __ISpTaskManager_FWD_DEFINED__ +#define __ISpTaskManager_FWD_DEFINED__ +typedef interface ISpTaskManager ISpTaskManager; +#endif /* __ISpTaskManager_FWD_DEFINED__ */ + + +#ifndef __ISpTTSEngineSite_FWD_DEFINED__ +#define __ISpTTSEngineSite_FWD_DEFINED__ +typedef interface ISpTTSEngineSite ISpTTSEngineSite; +#endif /* __ISpTTSEngineSite_FWD_DEFINED__ */ + + +#ifndef __ISpTTSEngine_FWD_DEFINED__ +#define __ISpTTSEngine_FWD_DEFINED__ +typedef interface ISpTTSEngine ISpTTSEngine; +#endif /* __ISpTTSEngine_FWD_DEFINED__ */ + + +#ifndef __ISpCFGInterpreterSite_FWD_DEFINED__ +#define __ISpCFGInterpreterSite_FWD_DEFINED__ +typedef interface ISpCFGInterpreterSite ISpCFGInterpreterSite; +#endif /* __ISpCFGInterpreterSite_FWD_DEFINED__ */ + + +#ifndef __ISpCFGInterpreter_FWD_DEFINED__ +#define __ISpCFGInterpreter_FWD_DEFINED__ +typedef interface ISpCFGInterpreter ISpCFGInterpreter; +#endif /* __ISpCFGInterpreter_FWD_DEFINED__ */ + + +#ifndef __ISpSREngineSite_FWD_DEFINED__ +#define __ISpSREngineSite_FWD_DEFINED__ +typedef interface ISpSREngineSite ISpSREngineSite; +#endif /* __ISpSREngineSite_FWD_DEFINED__ */ + + +#ifndef __ISpSREngine_FWD_DEFINED__ +#define __ISpSREngine_FWD_DEFINED__ +typedef interface ISpSREngine ISpSREngine; +#endif /* __ISpSREngine_FWD_DEFINED__ */ + + +#ifndef __ISpSRAlternates_FWD_DEFINED__ +#define __ISpSRAlternates_FWD_DEFINED__ +typedef interface ISpSRAlternates ISpSRAlternates; +#endif /* __ISpSRAlternates_FWD_DEFINED__ */ + + +#ifndef ___ISpPrivateEngineCall_FWD_DEFINED__ +#define ___ISpPrivateEngineCall_FWD_DEFINED__ +typedef interface _ISpPrivateEngineCall _ISpPrivateEngineCall; +#endif /* ___ISpPrivateEngineCall_FWD_DEFINED__ */ + + +#ifndef __SpDataKey_FWD_DEFINED__ +#define __SpDataKey_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpDataKey SpDataKey; +#else +typedef struct SpDataKey SpDataKey; +#endif /* __cplusplus */ + +#endif /* __SpDataKey_FWD_DEFINED__ */ + + +#ifndef __SpObjectTokenEnum_FWD_DEFINED__ +#define __SpObjectTokenEnum_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpObjectTokenEnum SpObjectTokenEnum; +#else +typedef struct SpObjectTokenEnum SpObjectTokenEnum; +#endif /* __cplusplus */ + +#endif /* __SpObjectTokenEnum_FWD_DEFINED__ */ + + +#ifndef __SpPhraseBuilder_FWD_DEFINED__ +#define __SpPhraseBuilder_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpPhraseBuilder SpPhraseBuilder; +#else +typedef struct SpPhraseBuilder SpPhraseBuilder; +#endif /* __cplusplus */ + +#endif /* __SpPhraseBuilder_FWD_DEFINED__ */ + + +#ifndef __SpITNProcessor_FWD_DEFINED__ +#define __SpITNProcessor_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpITNProcessor SpITNProcessor; +#else +typedef struct SpITNProcessor SpITNProcessor; +#endif /* __cplusplus */ + +#endif /* __SpITNProcessor_FWD_DEFINED__ */ + + +#ifndef __SpGrammarCompiler_FWD_DEFINED__ +#define __SpGrammarCompiler_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpGrammarCompiler SpGrammarCompiler; +#else +typedef struct SpGrammarCompiler SpGrammarCompiler; +#endif /* __cplusplus */ + +#endif /* __SpGrammarCompiler_FWD_DEFINED__ */ + + +#ifndef __SpGramCompBackend_FWD_DEFINED__ +#define __SpGramCompBackend_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class SpGramCompBackend SpGramCompBackend; +#else +typedef struct SpGramCompBackend SpGramCompBackend; +#endif /* __cplusplus */ + +#endif /* __SpGramCompBackend_FWD_DEFINED__ */ + + +/* header files for imported files */ +#include "oaidl.h" +#include "ocidl.h" +#include "sapi.h" + +#ifdef __cplusplus +extern "C"{ +#endif + +void * __RPC_USER MIDL_user_allocate(size_t); +void __RPC_USER MIDL_user_free( void * ); + +/* interface __MIDL_itf_sapiddk_0000 */ +/* [local] */ + + + + + + +#define SPRECOEXTENSION L"RecoExtension" +#define SPALTERNATESCLSID L"AlternatesCLSID" + + +extern RPC_IF_HANDLE __MIDL_itf_sapiddk_0000_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_sapiddk_0000_v0_0_s_ifspec; + +#ifndef __ISpTokenUI_INTERFACE_DEFINED__ +#define __ISpTokenUI_INTERFACE_DEFINED__ + +/* interface ISpTokenUI */ +/* [restricted][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpTokenUI; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("F8E690F0-39CB-4843-B8D7-C84696E1119D") + ISpTokenUI : public IUnknown + { + public: + virtual /* [local] */ HRESULT STDMETHODCALLTYPE IsUISupported( + /* [in] */ const WCHAR *pszTypeOfUI, + /* [in] */ void *pvExtraData, + /* [in] */ ULONG cbExtraData, + /* [in] */ IUnknown *punkObject, + /* [out] */ BOOL *pfSupported) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE DisplayUI( + /* [in] */ HWND hwndParent, + /* [in] */ const WCHAR *pszTitle, + /* [in] */ const WCHAR *pszTypeOfUI, + /* [in] */ void *pvExtraData, + /* [in] */ ULONG cbExtraData, + /* [in] */ ISpObjectToken *pToken, + /* [in] */ IUnknown *punkObject) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpTokenUIVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpTokenUI * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpTokenUI * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpTokenUI * This); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *IsUISupported )( + ISpTokenUI * This, + /* [in] */ const WCHAR *pszTypeOfUI, + /* [in] */ void *pvExtraData, + /* [in] */ ULONG cbExtraData, + /* [in] */ IUnknown *punkObject, + /* [out] */ BOOL *pfSupported); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *DisplayUI )( + ISpTokenUI * This, + /* [in] */ HWND hwndParent, + /* [in] */ const WCHAR *pszTitle, + /* [in] */ const WCHAR *pszTypeOfUI, + /* [in] */ void *pvExtraData, + /* [in] */ ULONG cbExtraData, + /* [in] */ ISpObjectToken *pToken, + /* [in] */ IUnknown *punkObject); + + END_INTERFACE + } ISpTokenUIVtbl; + + interface ISpTokenUI + { + CONST_VTBL struct ISpTokenUIVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpTokenUI_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpTokenUI_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpTokenUI_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpTokenUI_IsUISupported(This,pszTypeOfUI,pvExtraData,cbExtraData,punkObject,pfSupported) \ + (This)->lpVtbl -> IsUISupported(This,pszTypeOfUI,pvExtraData,cbExtraData,punkObject,pfSupported) + +#define ISpTokenUI_DisplayUI(This,hwndParent,pszTitle,pszTypeOfUI,pvExtraData,cbExtraData,pToken,punkObject) \ + (This)->lpVtbl -> DisplayUI(This,hwndParent,pszTitle,pszTypeOfUI,pvExtraData,cbExtraData,pToken,punkObject) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [local] */ HRESULT STDMETHODCALLTYPE ISpTokenUI_IsUISupported_Proxy( + ISpTokenUI * This, + /* [in] */ const WCHAR *pszTypeOfUI, + /* [in] */ void *pvExtraData, + /* [in] */ ULONG cbExtraData, + /* [in] */ IUnknown *punkObject, + /* [out] */ BOOL *pfSupported); + + +void __RPC_STUB ISpTokenUI_IsUISupported_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [local] */ HRESULT STDMETHODCALLTYPE ISpTokenUI_DisplayUI_Proxy( + ISpTokenUI * This, + /* [in] */ HWND hwndParent, + /* [in] */ const WCHAR *pszTitle, + /* [in] */ const WCHAR *pszTypeOfUI, + /* [in] */ void *pvExtraData, + /* [in] */ ULONG cbExtraData, + /* [in] */ ISpObjectToken *pToken, + /* [in] */ IUnknown *punkObject); + + +void __RPC_STUB ISpTokenUI_DisplayUI_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpTokenUI_INTERFACE_DEFINED__ */ + + +#ifndef __ISpObjectTokenEnumBuilder_INTERFACE_DEFINED__ +#define __ISpObjectTokenEnumBuilder_INTERFACE_DEFINED__ + +/* interface ISpObjectTokenEnumBuilder */ +/* [restricted][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpObjectTokenEnumBuilder; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("06B64F9F-7FDA-11d2-B4F2-00C04F797396") + ISpObjectTokenEnumBuilder : public IEnumSpObjectTokens + { + public: + virtual HRESULT STDMETHODCALLTYPE SetAttribs( + const WCHAR *pszReqAttribs, + const WCHAR *pszOptAttribs) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddTokens( + ULONG cTokens, + ISpObjectToken **pToken) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddTokensFromDataKey( + ISpDataKey *pDataKey, + const WCHAR *pszSubKey, + const WCHAR *pszCategoryId) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddTokensFromTokenEnum( + IEnumSpObjectTokens *pTokenEnum) = 0; + + virtual HRESULT STDMETHODCALLTYPE Sort( + const WCHAR *pszTokenIdToListFirst) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpObjectTokenEnumBuilderVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpObjectTokenEnumBuilder * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpObjectTokenEnumBuilder * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpObjectTokenEnumBuilder * This); + + HRESULT ( STDMETHODCALLTYPE *Next )( + ISpObjectTokenEnumBuilder * This, + /* [in] */ ULONG celt, + /* [length_is][size_is][out] */ ISpObjectToken **pelt, + /* [out] */ ULONG *pceltFetched); + + HRESULT ( STDMETHODCALLTYPE *Skip )( + ISpObjectTokenEnumBuilder * This, + /* [in] */ ULONG celt); + + HRESULT ( STDMETHODCALLTYPE *Reset )( + ISpObjectTokenEnumBuilder * This); + + HRESULT ( STDMETHODCALLTYPE *Clone )( + ISpObjectTokenEnumBuilder * This, + /* [out] */ IEnumSpObjectTokens **ppEnum); + + HRESULT ( STDMETHODCALLTYPE *Item )( + ISpObjectTokenEnumBuilder * This, + /* [in] */ ULONG Index, + /* [out] */ ISpObjectToken **ppToken); + + HRESULT ( STDMETHODCALLTYPE *GetCount )( + ISpObjectTokenEnumBuilder * This, + /* [out] */ ULONG *pCount); + + HRESULT ( STDMETHODCALLTYPE *SetAttribs )( + ISpObjectTokenEnumBuilder * This, + const WCHAR *pszReqAttribs, + const WCHAR *pszOptAttribs); + + HRESULT ( STDMETHODCALLTYPE *AddTokens )( + ISpObjectTokenEnumBuilder * This, + ULONG cTokens, + ISpObjectToken **pToken); + + HRESULT ( STDMETHODCALLTYPE *AddTokensFromDataKey )( + ISpObjectTokenEnumBuilder * This, + ISpDataKey *pDataKey, + const WCHAR *pszSubKey, + const WCHAR *pszCategoryId); + + HRESULT ( STDMETHODCALLTYPE *AddTokensFromTokenEnum )( + ISpObjectTokenEnumBuilder * This, + IEnumSpObjectTokens *pTokenEnum); + + HRESULT ( STDMETHODCALLTYPE *Sort )( + ISpObjectTokenEnumBuilder * This, + const WCHAR *pszTokenIdToListFirst); + + END_INTERFACE + } ISpObjectTokenEnumBuilderVtbl; + + interface ISpObjectTokenEnumBuilder + { + CONST_VTBL struct ISpObjectTokenEnumBuilderVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpObjectTokenEnumBuilder_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpObjectTokenEnumBuilder_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpObjectTokenEnumBuilder_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpObjectTokenEnumBuilder_Next(This,celt,pelt,pceltFetched) \ + (This)->lpVtbl -> Next(This,celt,pelt,pceltFetched) + +#define ISpObjectTokenEnumBuilder_Skip(This,celt) \ + (This)->lpVtbl -> Skip(This,celt) + +#define ISpObjectTokenEnumBuilder_Reset(This) \ + (This)->lpVtbl -> Reset(This) + +#define ISpObjectTokenEnumBuilder_Clone(This,ppEnum) \ + (This)->lpVtbl -> Clone(This,ppEnum) + +#define ISpObjectTokenEnumBuilder_Item(This,Index,ppToken) \ + (This)->lpVtbl -> Item(This,Index,ppToken) + +#define ISpObjectTokenEnumBuilder_GetCount(This,pCount) \ + (This)->lpVtbl -> GetCount(This,pCount) + + +#define ISpObjectTokenEnumBuilder_SetAttribs(This,pszReqAttribs,pszOptAttribs) \ + (This)->lpVtbl -> SetAttribs(This,pszReqAttribs,pszOptAttribs) + +#define ISpObjectTokenEnumBuilder_AddTokens(This,cTokens,pToken) \ + (This)->lpVtbl -> AddTokens(This,cTokens,pToken) + +#define ISpObjectTokenEnumBuilder_AddTokensFromDataKey(This,pDataKey,pszSubKey,pszCategoryId) \ + (This)->lpVtbl -> AddTokensFromDataKey(This,pDataKey,pszSubKey,pszCategoryId) + +#define ISpObjectTokenEnumBuilder_AddTokensFromTokenEnum(This,pTokenEnum) \ + (This)->lpVtbl -> AddTokensFromTokenEnum(This,pTokenEnum) + +#define ISpObjectTokenEnumBuilder_Sort(This,pszTokenIdToListFirst) \ + (This)->lpVtbl -> Sort(This,pszTokenIdToListFirst) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpObjectTokenEnumBuilder_SetAttribs_Proxy( + ISpObjectTokenEnumBuilder * This, + const WCHAR *pszReqAttribs, + const WCHAR *pszOptAttribs); + + +void __RPC_STUB ISpObjectTokenEnumBuilder_SetAttribs_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpObjectTokenEnumBuilder_AddTokens_Proxy( + ISpObjectTokenEnumBuilder * This, + ULONG cTokens, + ISpObjectToken **pToken); + + +void __RPC_STUB ISpObjectTokenEnumBuilder_AddTokens_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpObjectTokenEnumBuilder_AddTokensFromDataKey_Proxy( + ISpObjectTokenEnumBuilder * This, + ISpDataKey *pDataKey, + const WCHAR *pszSubKey, + const WCHAR *pszCategoryId); + + +void __RPC_STUB ISpObjectTokenEnumBuilder_AddTokensFromDataKey_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpObjectTokenEnumBuilder_AddTokensFromTokenEnum_Proxy( + ISpObjectTokenEnumBuilder * This, + IEnumSpObjectTokens *pTokenEnum); + + +void __RPC_STUB ISpObjectTokenEnumBuilder_AddTokensFromTokenEnum_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpObjectTokenEnumBuilder_Sort_Proxy( + ISpObjectTokenEnumBuilder * This, + const WCHAR *pszTokenIdToListFirst); + + +void __RPC_STUB ISpObjectTokenEnumBuilder_Sort_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpObjectTokenEnumBuilder_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_sapiddk_0339 */ +/* [local] */ + +#if 0 +typedef void *SPWORDHANDLE; + +typedef void *SPRULEHANDLE; + +typedef void *SPGRAMMARHANDLE; + +typedef void *SPRECOCONTEXTHANDLE; + +typedef void *SPPHRASERULEHANDLE; + +typedef void *SPPHRASEPROPERTYHANDLE; + +typedef void *SPTRANSITIONID; + +#else +DECLARE_HANDLE(SPWORDHANDLE); +DECLARE_HANDLE(SPRULEHANDLE); +DECLARE_HANDLE(SPGRAMMARHANDLE); +DECLARE_HANDLE(SPRECOCONTEXTHANDLE); +DECLARE_HANDLE(SPPHRASERULEHANDLE); +DECLARE_HANDLE(SPPHRASEPROPERTYHANDLE); +DECLARE_HANDLE(SPTRANSITIONID); +#endif + + +extern RPC_IF_HANDLE __MIDL_itf_sapiddk_0339_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_sapiddk_0339_v0_0_s_ifspec; + +#ifndef __ISpErrorLog_INTERFACE_DEFINED__ +#define __ISpErrorLog_INTERFACE_DEFINED__ + +/* interface ISpErrorLog */ +/* [restricted][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpErrorLog; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("F4711347-E608-11d2-A086-00C04F8EF9B5") + ISpErrorLog : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE AddError( + const long lLineNumber, + HRESULT hr, + const WCHAR *pszDescription, + const WCHAR *pszHelpFile, + DWORD dwHelpContext) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpErrorLogVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpErrorLog * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpErrorLog * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpErrorLog * This); + + HRESULT ( STDMETHODCALLTYPE *AddError )( + ISpErrorLog * This, + const long lLineNumber, + HRESULT hr, + const WCHAR *pszDescription, + const WCHAR *pszHelpFile, + DWORD dwHelpContext); + + END_INTERFACE + } ISpErrorLogVtbl; + + interface ISpErrorLog + { + CONST_VTBL struct ISpErrorLogVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpErrorLog_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpErrorLog_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpErrorLog_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpErrorLog_AddError(This,lLineNumber,hr,pszDescription,pszHelpFile,dwHelpContext) \ + (This)->lpVtbl -> AddError(This,lLineNumber,hr,pszDescription,pszHelpFile,dwHelpContext) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpErrorLog_AddError_Proxy( + ISpErrorLog * This, + const long lLineNumber, + HRESULT hr, + const WCHAR *pszDescription, + const WCHAR *pszHelpFile, + DWORD dwHelpContext); + + +void __RPC_STUB ISpErrorLog_AddError_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpErrorLog_INTERFACE_DEFINED__ */ + + +#ifndef __ISpGrammarCompiler_INTERFACE_DEFINED__ +#define __ISpGrammarCompiler_INTERFACE_DEFINED__ + +/* interface ISpGrammarCompiler */ +/* [restricted][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpGrammarCompiler; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("B1E29D58-A675-11D2-8302-00C04F8EE6C0") + ISpGrammarCompiler : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE CompileStream( + IStream *pSource, + IStream *pDest, + IStream *pHeader, + IUnknown *pReserved, + ISpErrorLog *pErrorLog, + /* [in] */ DWORD dwFlags) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpGrammarCompilerVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpGrammarCompiler * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpGrammarCompiler * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpGrammarCompiler * This); + + HRESULT ( STDMETHODCALLTYPE *CompileStream )( + ISpGrammarCompiler * This, + IStream *pSource, + IStream *pDest, + IStream *pHeader, + IUnknown *pReserved, + ISpErrorLog *pErrorLog, + /* [in] */ DWORD dwFlags); + + END_INTERFACE + } ISpGrammarCompilerVtbl; + + interface ISpGrammarCompiler + { + CONST_VTBL struct ISpGrammarCompilerVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpGrammarCompiler_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpGrammarCompiler_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpGrammarCompiler_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpGrammarCompiler_CompileStream(This,pSource,pDest,pHeader,pReserved,pErrorLog,dwFlags) \ + (This)->lpVtbl -> CompileStream(This,pSource,pDest,pHeader,pReserved,pErrorLog,dwFlags) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpGrammarCompiler_CompileStream_Proxy( + ISpGrammarCompiler * This, + IStream *pSource, + IStream *pDest, + IStream *pHeader, + IUnknown *pReserved, + ISpErrorLog *pErrorLog, + /* [in] */ DWORD dwFlags); + + +void __RPC_STUB ISpGrammarCompiler_CompileStream_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpGrammarCompiler_INTERFACE_DEFINED__ */ + + +#ifndef __ISpGramCompBackend_INTERFACE_DEFINED__ +#define __ISpGramCompBackend_INTERFACE_DEFINED__ + +/* interface ISpGramCompBackend */ +/* [restricted][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpGramCompBackend; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("3DDCA27C-665C-4786-9F97-8C90C3488B61") + ISpGramCompBackend : public ISpGrammarBuilder + { + public: + virtual HRESULT STDMETHODCALLTYPE SetSaveObjects( + IStream *pStream, + ISpErrorLog *pErrorLog) = 0; + + virtual HRESULT STDMETHODCALLTYPE InitFromBinaryGrammar( + const SPBINARYGRAMMAR *pBinaryData) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpGramCompBackendVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpGramCompBackend * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpGramCompBackend * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpGramCompBackend * This); + + HRESULT ( STDMETHODCALLTYPE *ResetGrammar )( + ISpGramCompBackend * This, + /* [in] */ WORD NewLanguage); + + HRESULT ( STDMETHODCALLTYPE *GetRule )( + ISpGramCompBackend * This, + /* [in] */ const WCHAR *pszRuleName, + /* [in] */ DWORD dwRuleId, + /* [in] */ DWORD dwAttributes, + /* [in] */ BOOL fCreateIfNotExist, + /* [out] */ SPSTATEHANDLE *phInitialState); + + HRESULT ( STDMETHODCALLTYPE *ClearRule )( + ISpGramCompBackend * This, + SPSTATEHANDLE hState); + + HRESULT ( STDMETHODCALLTYPE *CreateNewState )( + ISpGramCompBackend * This, + SPSTATEHANDLE hState, + SPSTATEHANDLE *phState); + + HRESULT ( STDMETHODCALLTYPE *AddWordTransition )( + ISpGramCompBackend * This, + SPSTATEHANDLE hFromState, + SPSTATEHANDLE hToState, + const WCHAR *psz, + const WCHAR *pszSeparators, + SPGRAMMARWORDTYPE eWordType, + float Weight, + const SPPROPERTYINFO *pPropInfo); + + HRESULT ( STDMETHODCALLTYPE *AddRuleTransition )( + ISpGramCompBackend * This, + SPSTATEHANDLE hFromState, + SPSTATEHANDLE hToState, + SPSTATEHANDLE hRule, + float Weight, + const SPPROPERTYINFO *pPropInfo); + + HRESULT ( STDMETHODCALLTYPE *AddResource )( + ISpGramCompBackend * This, + /* [in] */ SPSTATEHANDLE hRuleState, + /* [in] */ const WCHAR *pszResourceName, + /* [in] */ const WCHAR *pszResourceValue); + + HRESULT ( STDMETHODCALLTYPE *Commit )( + ISpGramCompBackend * This, + DWORD dwReserved); + + HRESULT ( STDMETHODCALLTYPE *SetSaveObjects )( + ISpGramCompBackend * This, + IStream *pStream, + ISpErrorLog *pErrorLog); + + HRESULT ( STDMETHODCALLTYPE *InitFromBinaryGrammar )( + ISpGramCompBackend * This, + const SPBINARYGRAMMAR *pBinaryData); + + END_INTERFACE + } ISpGramCompBackendVtbl; + + interface ISpGramCompBackend + { + CONST_VTBL struct ISpGramCompBackendVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpGramCompBackend_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpGramCompBackend_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpGramCompBackend_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpGramCompBackend_ResetGrammar(This,NewLanguage) \ + (This)->lpVtbl -> ResetGrammar(This,NewLanguage) + +#define ISpGramCompBackend_GetRule(This,pszRuleName,dwRuleId,dwAttributes,fCreateIfNotExist,phInitialState) \ + (This)->lpVtbl -> GetRule(This,pszRuleName,dwRuleId,dwAttributes,fCreateIfNotExist,phInitialState) + +#define ISpGramCompBackend_ClearRule(This,hState) \ + (This)->lpVtbl -> ClearRule(This,hState) + +#define ISpGramCompBackend_CreateNewState(This,hState,phState) \ + (This)->lpVtbl -> CreateNewState(This,hState,phState) + +#define ISpGramCompBackend_AddWordTransition(This,hFromState,hToState,psz,pszSeparators,eWordType,Weight,pPropInfo) \ + (This)->lpVtbl -> AddWordTransition(This,hFromState,hToState,psz,pszSeparators,eWordType,Weight,pPropInfo) + +#define ISpGramCompBackend_AddRuleTransition(This,hFromState,hToState,hRule,Weight,pPropInfo) \ + (This)->lpVtbl -> AddRuleTransition(This,hFromState,hToState,hRule,Weight,pPropInfo) + +#define ISpGramCompBackend_AddResource(This,hRuleState,pszResourceName,pszResourceValue) \ + (This)->lpVtbl -> AddResource(This,hRuleState,pszResourceName,pszResourceValue) + +#define ISpGramCompBackend_Commit(This,dwReserved) \ + (This)->lpVtbl -> Commit(This,dwReserved) + + +#define ISpGramCompBackend_SetSaveObjects(This,pStream,pErrorLog) \ + (This)->lpVtbl -> SetSaveObjects(This,pStream,pErrorLog) + +#define ISpGramCompBackend_InitFromBinaryGrammar(This,pBinaryData) \ + (This)->lpVtbl -> InitFromBinaryGrammar(This,pBinaryData) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpGramCompBackend_SetSaveObjects_Proxy( + ISpGramCompBackend * This, + IStream *pStream, + ISpErrorLog *pErrorLog); + + +void __RPC_STUB ISpGramCompBackend_SetSaveObjects_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpGramCompBackend_InitFromBinaryGrammar_Proxy( + ISpGramCompBackend * This, + const SPBINARYGRAMMAR *pBinaryData); + + +void __RPC_STUB ISpGramCompBackend_InitFromBinaryGrammar_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpGramCompBackend_INTERFACE_DEFINED__ */ + + +#ifndef __ISpITNProcessor_INTERFACE_DEFINED__ +#define __ISpITNProcessor_INTERFACE_DEFINED__ + +/* interface ISpITNProcessor */ +/* [restricted][local][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpITNProcessor; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("12D7360F-A1C9-11d3-BC90-00C04F72DF9F") + ISpITNProcessor : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE LoadITNGrammar( + WCHAR *pszCLSID) = 0; + + virtual HRESULT STDMETHODCALLTYPE ITNPhrase( + ISpPhraseBuilder *pPhrase) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpITNProcessorVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpITNProcessor * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpITNProcessor * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpITNProcessor * This); + + HRESULT ( STDMETHODCALLTYPE *LoadITNGrammar )( + ISpITNProcessor * This, + WCHAR *pszCLSID); + + HRESULT ( STDMETHODCALLTYPE *ITNPhrase )( + ISpITNProcessor * This, + ISpPhraseBuilder *pPhrase); + + END_INTERFACE + } ISpITNProcessorVtbl; + + interface ISpITNProcessor + { + CONST_VTBL struct ISpITNProcessorVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpITNProcessor_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpITNProcessor_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpITNProcessor_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpITNProcessor_LoadITNGrammar(This,pszCLSID) \ + (This)->lpVtbl -> LoadITNGrammar(This,pszCLSID) + +#define ISpITNProcessor_ITNPhrase(This,pPhrase) \ + (This)->lpVtbl -> ITNPhrase(This,pPhrase) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpITNProcessor_LoadITNGrammar_Proxy( + ISpITNProcessor * This, + WCHAR *pszCLSID); + + +void __RPC_STUB ISpITNProcessor_LoadITNGrammar_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpITNProcessor_ITNPhrase_Proxy( + ISpITNProcessor * This, + ISpPhraseBuilder *pPhrase); + + +void __RPC_STUB ISpITNProcessor_ITNPhrase_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpITNProcessor_INTERFACE_DEFINED__ */ + + +#ifndef __ISpPhraseBuilder_INTERFACE_DEFINED__ +#define __ISpPhraseBuilder_INTERFACE_DEFINED__ + +/* interface ISpPhraseBuilder */ +/* [restricted][unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_ISpPhraseBuilder; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("88A3342A-0BED-4834-922B-88D43173162F") + ISpPhraseBuilder : public ISpPhrase + { + public: + virtual HRESULT STDMETHODCALLTYPE InitFromPhrase( + const SPPHRASE *pPhrase) = 0; + + virtual HRESULT STDMETHODCALLTYPE InitFromSerializedPhrase( + const SPSERIALIZEDPHRASE *pPhrase) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddElements( + ULONG cElements, + const SPPHRASEELEMENT *pElement) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddRules( + const SPPHRASERULEHANDLE hParent, + const SPPHRASERULE *pRule, + SPPHRASERULEHANDLE *phNewRule) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddProperties( + const SPPHRASEPROPERTYHANDLE hParent, + const SPPHRASEPROPERTY *pProperty, + SPPHRASEPROPERTYHANDLE *phNewProperty) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddReplacements( + ULONG cReplacements, + const SPPHRASEREPLACEMENT *pReplacements) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpPhraseBuilderVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpPhraseBuilder * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpPhraseBuilder * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpPhraseBuilder * This); + + HRESULT ( STDMETHODCALLTYPE *GetPhrase )( + ISpPhraseBuilder * This, + /* [out] */ SPPHRASE **ppCoMemPhrase); + + HRESULT ( STDMETHODCALLTYPE *GetSerializedPhrase )( + ISpPhraseBuilder * This, + /* [out] */ SPSERIALIZEDPHRASE **ppCoMemPhrase); + + HRESULT ( STDMETHODCALLTYPE *GetText )( + ISpPhraseBuilder * This, + /* [in] */ ULONG ulStart, + /* [in] */ ULONG ulCount, + /* [in] */ BOOL fUseTextReplacements, + /* [out] */ WCHAR **ppszCoMemText, + /* [out] */ BYTE *pbDisplayAttributes); + + HRESULT ( STDMETHODCALLTYPE *Discard )( + ISpPhraseBuilder * This, + /* [in] */ DWORD dwValueTypes); + + HRESULT ( STDMETHODCALLTYPE *InitFromPhrase )( + ISpPhraseBuilder * This, + const SPPHRASE *pPhrase); + + HRESULT ( STDMETHODCALLTYPE *InitFromSerializedPhrase )( + ISpPhraseBuilder * This, + const SPSERIALIZEDPHRASE *pPhrase); + + HRESULT ( STDMETHODCALLTYPE *AddElements )( + ISpPhraseBuilder * This, + ULONG cElements, + const SPPHRASEELEMENT *pElement); + + HRESULT ( STDMETHODCALLTYPE *AddRules )( + ISpPhraseBuilder * This, + const SPPHRASERULEHANDLE hParent, + const SPPHRASERULE *pRule, + SPPHRASERULEHANDLE *phNewRule); + + HRESULT ( STDMETHODCALLTYPE *AddProperties )( + ISpPhraseBuilder * This, + const SPPHRASEPROPERTYHANDLE hParent, + const SPPHRASEPROPERTY *pProperty, + SPPHRASEPROPERTYHANDLE *phNewProperty); + + HRESULT ( STDMETHODCALLTYPE *AddReplacements )( + ISpPhraseBuilder * This, + ULONG cReplacements, + const SPPHRASEREPLACEMENT *pReplacements); + + END_INTERFACE + } ISpPhraseBuilderVtbl; + + interface ISpPhraseBuilder + { + CONST_VTBL struct ISpPhraseBuilderVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpPhraseBuilder_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpPhraseBuilder_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpPhraseBuilder_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpPhraseBuilder_GetPhrase(This,ppCoMemPhrase) \ + (This)->lpVtbl -> GetPhrase(This,ppCoMemPhrase) + +#define ISpPhraseBuilder_GetSerializedPhrase(This,ppCoMemPhrase) \ + (This)->lpVtbl -> GetSerializedPhrase(This,ppCoMemPhrase) + +#define ISpPhraseBuilder_GetText(This,ulStart,ulCount,fUseTextReplacements,ppszCoMemText,pbDisplayAttributes) \ + (This)->lpVtbl -> GetText(This,ulStart,ulCount,fUseTextReplacements,ppszCoMemText,pbDisplayAttributes) + +#define ISpPhraseBuilder_Discard(This,dwValueTypes) \ + (This)->lpVtbl -> Discard(This,dwValueTypes) + + +#define ISpPhraseBuilder_InitFromPhrase(This,pPhrase) \ + (This)->lpVtbl -> InitFromPhrase(This,pPhrase) + +#define ISpPhraseBuilder_InitFromSerializedPhrase(This,pPhrase) \ + (This)->lpVtbl -> InitFromSerializedPhrase(This,pPhrase) + +#define ISpPhraseBuilder_AddElements(This,cElements,pElement) \ + (This)->lpVtbl -> AddElements(This,cElements,pElement) + +#define ISpPhraseBuilder_AddRules(This,hParent,pRule,phNewRule) \ + (This)->lpVtbl -> AddRules(This,hParent,pRule,phNewRule) + +#define ISpPhraseBuilder_AddProperties(This,hParent,pProperty,phNewProperty) \ + (This)->lpVtbl -> AddProperties(This,hParent,pProperty,phNewProperty) + +#define ISpPhraseBuilder_AddReplacements(This,cReplacements,pReplacements) \ + (This)->lpVtbl -> AddReplacements(This,cReplacements,pReplacements) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpPhraseBuilder_InitFromPhrase_Proxy( + ISpPhraseBuilder * This, + const SPPHRASE *pPhrase); + + +void __RPC_STUB ISpPhraseBuilder_InitFromPhrase_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpPhraseBuilder_InitFromSerializedPhrase_Proxy( + ISpPhraseBuilder * This, + const SPSERIALIZEDPHRASE *pPhrase); + + +void __RPC_STUB ISpPhraseBuilder_InitFromSerializedPhrase_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpPhraseBuilder_AddElements_Proxy( + ISpPhraseBuilder * This, + ULONG cElements, + const SPPHRASEELEMENT *pElement); + + +void __RPC_STUB ISpPhraseBuilder_AddElements_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpPhraseBuilder_AddRules_Proxy( + ISpPhraseBuilder * This, + const SPPHRASERULEHANDLE hParent, + const SPPHRASERULE *pRule, + SPPHRASERULEHANDLE *phNewRule); + + +void __RPC_STUB ISpPhraseBuilder_AddRules_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpPhraseBuilder_AddProperties_Proxy( + ISpPhraseBuilder * This, + const SPPHRASEPROPERTYHANDLE hParent, + const SPPHRASEPROPERTY *pProperty, + SPPHRASEPROPERTYHANDLE *phNewProperty); + + +void __RPC_STUB ISpPhraseBuilder_AddProperties_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpPhraseBuilder_AddReplacements_Proxy( + ISpPhraseBuilder * This, + ULONG cReplacements, + const SPPHRASEREPLACEMENT *pReplacements); + + +void __RPC_STUB ISpPhraseBuilder_AddReplacements_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpPhraseBuilder_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_sapiddk_0344 */ +/* [local] */ + +#if defined(__cplusplus) +interface ISpTask +{ +virtual HRESULT STDMETHODCALLTYPE Execute( + void *pvTaskData, + volatile const BOOL* pfContinueProcessing) = 0; +}; +#else +typedef void *ISpTask; + +#endif +#if defined(__cplusplus) +interface ISpThreadTask +{ +virtual HRESULT STDMETHODCALLTYPE InitThread( + void * pvTaskData, + HWND hwnd) = 0; +virtual HRESULT STDMETHODCALLTYPE ThreadProc( + void *pvTaskData, + HANDLE hExitThreadEvent, + HANDLE hNotifyEvent, + HWND hwndWorker, + volatile const BOOL * pfContinueProcessing) = 0; +virtual LRESULT STDMETHODCALLTYPE WindowMessage( + void *pvTaskData, + HWND hWnd, + UINT Msg, + WPARAM wParam, + LPARAM lParam) = 0; +}; +#else +typedef void *ISpThreadTask; + +#endif + + +extern RPC_IF_HANDLE __MIDL_itf_sapiddk_0344_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_sapiddk_0344_v0_0_s_ifspec; + +#ifndef __ISpThreadControl_INTERFACE_DEFINED__ +#define __ISpThreadControl_INTERFACE_DEFINED__ + +/* interface ISpThreadControl */ +/* [restricted][local][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpThreadControl; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("A6BE4D73-4403-4358-B22D-0346E23B1764") + ISpThreadControl : public ISpNotifySink + { + public: + virtual HRESULT STDMETHODCALLTYPE StartThread( + DWORD dwFlags, + HWND *phwnd) = 0; + + virtual HRESULT STDMETHODCALLTYPE WaitForThreadDone( + BOOL fForceStop, + HRESULT *phrThreadResult, + ULONG msTimeOut) = 0; + + virtual HRESULT STDMETHODCALLTYPE TerminateThread( void) = 0; + + virtual HANDLE STDMETHODCALLTYPE ThreadHandle( void) = 0; + + virtual DWORD STDMETHODCALLTYPE ThreadId( void) = 0; + + virtual HANDLE STDMETHODCALLTYPE NotifyEvent( void) = 0; + + virtual HWND STDMETHODCALLTYPE WindowHandle( void) = 0; + + virtual HANDLE STDMETHODCALLTYPE ThreadCompleteEvent( void) = 0; + + virtual HANDLE STDMETHODCALLTYPE ExitThreadEvent( void) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpThreadControlVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpThreadControl * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpThreadControl * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpThreadControl * This); + + HRESULT ( STDMETHODCALLTYPE *Notify )( + ISpThreadControl * This); + + HRESULT ( STDMETHODCALLTYPE *StartThread )( + ISpThreadControl * This, + DWORD dwFlags, + HWND *phwnd); + + HRESULT ( STDMETHODCALLTYPE *WaitForThreadDone )( + ISpThreadControl * This, + BOOL fForceStop, + HRESULT *phrThreadResult, + ULONG msTimeOut); + + HRESULT ( STDMETHODCALLTYPE *TerminateThread )( + ISpThreadControl * This); + + HANDLE ( STDMETHODCALLTYPE *ThreadHandle )( + ISpThreadControl * This); + + DWORD ( STDMETHODCALLTYPE *ThreadId )( + ISpThreadControl * This); + + HANDLE ( STDMETHODCALLTYPE *NotifyEvent )( + ISpThreadControl * This); + + HWND ( STDMETHODCALLTYPE *WindowHandle )( + ISpThreadControl * This); + + HANDLE ( STDMETHODCALLTYPE *ThreadCompleteEvent )( + ISpThreadControl * This); + + HANDLE ( STDMETHODCALLTYPE *ExitThreadEvent )( + ISpThreadControl * This); + + END_INTERFACE + } ISpThreadControlVtbl; + + interface ISpThreadControl + { + CONST_VTBL struct ISpThreadControlVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpThreadControl_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpThreadControl_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpThreadControl_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpThreadControl_Notify(This) \ + (This)->lpVtbl -> Notify(This) + + +#define ISpThreadControl_StartThread(This,dwFlags,phwnd) \ + (This)->lpVtbl -> StartThread(This,dwFlags,phwnd) + +#define ISpThreadControl_WaitForThreadDone(This,fForceStop,phrThreadResult,msTimeOut) \ + (This)->lpVtbl -> WaitForThreadDone(This,fForceStop,phrThreadResult,msTimeOut) + +#define ISpThreadControl_TerminateThread(This) \ + (This)->lpVtbl -> TerminateThread(This) + +#define ISpThreadControl_ThreadHandle(This) \ + (This)->lpVtbl -> ThreadHandle(This) + +#define ISpThreadControl_ThreadId(This) \ + (This)->lpVtbl -> ThreadId(This) + +#define ISpThreadControl_NotifyEvent(This) \ + (This)->lpVtbl -> NotifyEvent(This) + +#define ISpThreadControl_WindowHandle(This) \ + (This)->lpVtbl -> WindowHandle(This) + +#define ISpThreadControl_ThreadCompleteEvent(This) \ + (This)->lpVtbl -> ThreadCompleteEvent(This) + +#define ISpThreadControl_ExitThreadEvent(This) \ + (This)->lpVtbl -> ExitThreadEvent(This) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpThreadControl_StartThread_Proxy( + ISpThreadControl * This, + DWORD dwFlags, + HWND *phwnd); + + +void __RPC_STUB ISpThreadControl_StartThread_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpThreadControl_WaitForThreadDone_Proxy( + ISpThreadControl * This, + BOOL fForceStop, + HRESULT *phrThreadResult, + ULONG msTimeOut); + + +void __RPC_STUB ISpThreadControl_WaitForThreadDone_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpThreadControl_TerminateThread_Proxy( + ISpThreadControl * This); + + +void __RPC_STUB ISpThreadControl_TerminateThread_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HANDLE STDMETHODCALLTYPE ISpThreadControl_ThreadHandle_Proxy( + ISpThreadControl * This); + + +void __RPC_STUB ISpThreadControl_ThreadHandle_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +DWORD STDMETHODCALLTYPE ISpThreadControl_ThreadId_Proxy( + ISpThreadControl * This); + + +void __RPC_STUB ISpThreadControl_ThreadId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HANDLE STDMETHODCALLTYPE ISpThreadControl_NotifyEvent_Proxy( + ISpThreadControl * This); + + +void __RPC_STUB ISpThreadControl_NotifyEvent_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HWND STDMETHODCALLTYPE ISpThreadControl_WindowHandle_Proxy( + ISpThreadControl * This); + + +void __RPC_STUB ISpThreadControl_WindowHandle_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HANDLE STDMETHODCALLTYPE ISpThreadControl_ThreadCompleteEvent_Proxy( + ISpThreadControl * This); + + +void __RPC_STUB ISpThreadControl_ThreadCompleteEvent_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HANDLE STDMETHODCALLTYPE ISpThreadControl_ExitThreadEvent_Proxy( + ISpThreadControl * This); + + +void __RPC_STUB ISpThreadControl_ExitThreadEvent_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpThreadControl_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_sapiddk_0345 */ +/* [local] */ + +typedef /* [restricted] */ struct SPTMTHREADINFO + { + long lPoolSize; + long lPriority; + ULONG ulConcurrencyLimit; + ULONG ulMaxQuickAllocThreads; + } SPTMTHREADINFO; + + + +extern RPC_IF_HANDLE __MIDL_itf_sapiddk_0345_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_sapiddk_0345_v0_0_s_ifspec; + +#ifndef __ISpTaskManager_INTERFACE_DEFINED__ +#define __ISpTaskManager_INTERFACE_DEFINED__ + +/* interface ISpTaskManager */ +/* [object][restricted][unique][helpstring][uuid][local] */ + + +EXTERN_C const IID IID_ISpTaskManager; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("2BAEEF81-2CA3-4331-98F3-26EC5ABEFB03") + ISpTaskManager : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetThreadPoolInfo( + /* [in] */ const SPTMTHREADINFO *pPoolInfo) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetThreadPoolInfo( + /* [out] */ SPTMTHREADINFO *pPoolInfo) = 0; + + virtual HRESULT STDMETHODCALLTYPE QueueTask( + /* [in] */ ISpTask *pTask, + /* [in] */ void *pvTaskData, + /* [in] */ HANDLE hCompEvent, + /* [out][in] */ DWORD *pdwGroupId, + /* [out] */ DWORD *pTaskID) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateReoccurringTask( + /* [in] */ ISpTask *pTask, + /* [in] */ void *pvTaskData, + /* [in] */ HANDLE hCompEvent, + /* [out] */ ISpNotifySink **ppTaskCtrl) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateThreadControl( + /* [in] */ ISpThreadTask *pTask, + /* [in] */ void *pvTaskData, + /* [in] */ long nPriority, + /* [out] */ ISpThreadControl **ppTaskCtrl) = 0; + + virtual HRESULT STDMETHODCALLTYPE TerminateTask( + /* [in] */ DWORD dwTaskId, + /* [in] */ ULONG ulWaitPeriod) = 0; + + virtual HRESULT STDMETHODCALLTYPE TerminateTaskGroup( + /* [in] */ DWORD dwGroupId, + /* [in] */ ULONG ulWaitPeriod) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpTaskManagerVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpTaskManager * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpTaskManager * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpTaskManager * This); + + HRESULT ( STDMETHODCALLTYPE *SetThreadPoolInfo )( + ISpTaskManager * This, + /* [in] */ const SPTMTHREADINFO *pPoolInfo); + + HRESULT ( STDMETHODCALLTYPE *GetThreadPoolInfo )( + ISpTaskManager * This, + /* [out] */ SPTMTHREADINFO *pPoolInfo); + + HRESULT ( STDMETHODCALLTYPE *QueueTask )( + ISpTaskManager * This, + /* [in] */ ISpTask *pTask, + /* [in] */ void *pvTaskData, + /* [in] */ HANDLE hCompEvent, + /* [out][in] */ DWORD *pdwGroupId, + /* [out] */ DWORD *pTaskID); + + HRESULT ( STDMETHODCALLTYPE *CreateReoccurringTask )( + ISpTaskManager * This, + /* [in] */ ISpTask *pTask, + /* [in] */ void *pvTaskData, + /* [in] */ HANDLE hCompEvent, + /* [out] */ ISpNotifySink **ppTaskCtrl); + + HRESULT ( STDMETHODCALLTYPE *CreateThreadControl )( + ISpTaskManager * This, + /* [in] */ ISpThreadTask *pTask, + /* [in] */ void *pvTaskData, + /* [in] */ long nPriority, + /* [out] */ ISpThreadControl **ppTaskCtrl); + + HRESULT ( STDMETHODCALLTYPE *TerminateTask )( + ISpTaskManager * This, + /* [in] */ DWORD dwTaskId, + /* [in] */ ULONG ulWaitPeriod); + + HRESULT ( STDMETHODCALLTYPE *TerminateTaskGroup )( + ISpTaskManager * This, + /* [in] */ DWORD dwGroupId, + /* [in] */ ULONG ulWaitPeriod); + + END_INTERFACE + } ISpTaskManagerVtbl; + + interface ISpTaskManager + { + CONST_VTBL struct ISpTaskManagerVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpTaskManager_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpTaskManager_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpTaskManager_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpTaskManager_SetThreadPoolInfo(This,pPoolInfo) \ + (This)->lpVtbl -> SetThreadPoolInfo(This,pPoolInfo) + +#define ISpTaskManager_GetThreadPoolInfo(This,pPoolInfo) \ + (This)->lpVtbl -> GetThreadPoolInfo(This,pPoolInfo) + +#define ISpTaskManager_QueueTask(This,pTask,pvTaskData,hCompEvent,pdwGroupId,pTaskID) \ + (This)->lpVtbl -> QueueTask(This,pTask,pvTaskData,hCompEvent,pdwGroupId,pTaskID) + +#define ISpTaskManager_CreateReoccurringTask(This,pTask,pvTaskData,hCompEvent,ppTaskCtrl) \ + (This)->lpVtbl -> CreateReoccurringTask(This,pTask,pvTaskData,hCompEvent,ppTaskCtrl) + +#define ISpTaskManager_CreateThreadControl(This,pTask,pvTaskData,nPriority,ppTaskCtrl) \ + (This)->lpVtbl -> CreateThreadControl(This,pTask,pvTaskData,nPriority,ppTaskCtrl) + +#define ISpTaskManager_TerminateTask(This,dwTaskId,ulWaitPeriod) \ + (This)->lpVtbl -> TerminateTask(This,dwTaskId,ulWaitPeriod) + +#define ISpTaskManager_TerminateTaskGroup(This,dwGroupId,ulWaitPeriod) \ + (This)->lpVtbl -> TerminateTaskGroup(This,dwGroupId,ulWaitPeriod) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpTaskManager_SetThreadPoolInfo_Proxy( + ISpTaskManager * This, + /* [in] */ const SPTMTHREADINFO *pPoolInfo); + + +void __RPC_STUB ISpTaskManager_SetThreadPoolInfo_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpTaskManager_GetThreadPoolInfo_Proxy( + ISpTaskManager * This, + /* [out] */ SPTMTHREADINFO *pPoolInfo); + + +void __RPC_STUB ISpTaskManager_GetThreadPoolInfo_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpTaskManager_QueueTask_Proxy( + ISpTaskManager * This, + /* [in] */ ISpTask *pTask, + /* [in] */ void *pvTaskData, + /* [in] */ HANDLE hCompEvent, + /* [out][in] */ DWORD *pdwGroupId, + /* [out] */ DWORD *pTaskID); + + +void __RPC_STUB ISpTaskManager_QueueTask_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpTaskManager_CreateReoccurringTask_Proxy( + ISpTaskManager * This, + /* [in] */ ISpTask *pTask, + /* [in] */ void *pvTaskData, + /* [in] */ HANDLE hCompEvent, + /* [out] */ ISpNotifySink **ppTaskCtrl); + + +void __RPC_STUB ISpTaskManager_CreateReoccurringTask_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpTaskManager_CreateThreadControl_Proxy( + ISpTaskManager * This, + /* [in] */ ISpThreadTask *pTask, + /* [in] */ void *pvTaskData, + /* [in] */ long nPriority, + /* [out] */ ISpThreadControl **ppTaskCtrl); + + +void __RPC_STUB ISpTaskManager_CreateThreadControl_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpTaskManager_TerminateTask_Proxy( + ISpTaskManager * This, + /* [in] */ DWORD dwTaskId, + /* [in] */ ULONG ulWaitPeriod); + + +void __RPC_STUB ISpTaskManager_TerminateTask_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpTaskManager_TerminateTaskGroup_Proxy( + ISpTaskManager * This, + /* [in] */ DWORD dwGroupId, + /* [in] */ ULONG ulWaitPeriod); + + +void __RPC_STUB ISpTaskManager_TerminateTaskGroup_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpTaskManager_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_sapiddk_0346 */ +/* [local] */ + +typedef +enum SPVSKIPTYPE + { SPVST_SENTENCE = 1L << 0 + } SPVSKIPTYPE; + +typedef +enum SPVESACTIONS + { SPVES_CONTINUE = 0, + SPVES_ABORT = 1L << 0, + SPVES_SKIP = 1L << 1, + SPVES_RATE = 1L << 2, + SPVES_VOLUME = 1L << 3 + } SPVESACTIONS; + + + +extern RPC_IF_HANDLE __MIDL_itf_sapiddk_0346_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_sapiddk_0346_v0_0_s_ifspec; + +#ifndef __ISpTTSEngineSite_INTERFACE_DEFINED__ +#define __ISpTTSEngineSite_INTERFACE_DEFINED__ + +/* interface ISpTTSEngineSite */ +/* [unique][helpstring][uuid][local][object] */ + + +EXTERN_C const IID IID_ISpTTSEngineSite; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("9880499B-CCE9-11d2-B503-00C04F797396") + ISpTTSEngineSite : public ISpEventSink + { + public: + virtual DWORD STDMETHODCALLTYPE GetActions( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Write( + /* [in] */ const void *pBuff, + /* [in] */ ULONG cb, + /* [out] */ ULONG *pcbWritten) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetRate( + /* [out] */ long *pRateAdjust) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetVolume( + /* [out] */ USHORT *pusVolume) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSkipInfo( + /* [out] */ SPVSKIPTYPE *peType, + /* [out] */ long *plNumItems) = 0; + + virtual HRESULT STDMETHODCALLTYPE CompleteSkip( + /* [in] */ long ulNumSkipped) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpTTSEngineSiteVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpTTSEngineSite * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpTTSEngineSite * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpTTSEngineSite * This); + + HRESULT ( STDMETHODCALLTYPE *AddEvents )( + ISpTTSEngineSite * This, + /* [in] */ const SPEVENT *pEventArray, + /* [in] */ ULONG ulCount); + + HRESULT ( STDMETHODCALLTYPE *GetEventInterest )( + ISpTTSEngineSite * This, + /* [out] */ ULONGLONG *pullEventInterest); + + DWORD ( STDMETHODCALLTYPE *GetActions )( + ISpTTSEngineSite * This); + + HRESULT ( STDMETHODCALLTYPE *Write )( + ISpTTSEngineSite * This, + /* [in] */ const void *pBuff, + /* [in] */ ULONG cb, + /* [out] */ ULONG *pcbWritten); + + HRESULT ( STDMETHODCALLTYPE *GetRate )( + ISpTTSEngineSite * This, + /* [out] */ long *pRateAdjust); + + HRESULT ( STDMETHODCALLTYPE *GetVolume )( + ISpTTSEngineSite * This, + /* [out] */ USHORT *pusVolume); + + HRESULT ( STDMETHODCALLTYPE *GetSkipInfo )( + ISpTTSEngineSite * This, + /* [out] */ SPVSKIPTYPE *peType, + /* [out] */ long *plNumItems); + + HRESULT ( STDMETHODCALLTYPE *CompleteSkip )( + ISpTTSEngineSite * This, + /* [in] */ long ulNumSkipped); + + END_INTERFACE + } ISpTTSEngineSiteVtbl; + + interface ISpTTSEngineSite + { + CONST_VTBL struct ISpTTSEngineSiteVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpTTSEngineSite_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpTTSEngineSite_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpTTSEngineSite_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpTTSEngineSite_AddEvents(This,pEventArray,ulCount) \ + (This)->lpVtbl -> AddEvents(This,pEventArray,ulCount) + +#define ISpTTSEngineSite_GetEventInterest(This,pullEventInterest) \ + (This)->lpVtbl -> GetEventInterest(This,pullEventInterest) + + +#define ISpTTSEngineSite_GetActions(This) \ + (This)->lpVtbl -> GetActions(This) + +#define ISpTTSEngineSite_Write(This,pBuff,cb,pcbWritten) \ + (This)->lpVtbl -> Write(This,pBuff,cb,pcbWritten) + +#define ISpTTSEngineSite_GetRate(This,pRateAdjust) \ + (This)->lpVtbl -> GetRate(This,pRateAdjust) + +#define ISpTTSEngineSite_GetVolume(This,pusVolume) \ + (This)->lpVtbl -> GetVolume(This,pusVolume) + +#define ISpTTSEngineSite_GetSkipInfo(This,peType,plNumItems) \ + (This)->lpVtbl -> GetSkipInfo(This,peType,plNumItems) + +#define ISpTTSEngineSite_CompleteSkip(This,ulNumSkipped) \ + (This)->lpVtbl -> CompleteSkip(This,ulNumSkipped) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +DWORD STDMETHODCALLTYPE ISpTTSEngineSite_GetActions_Proxy( + ISpTTSEngineSite * This); + + +void __RPC_STUB ISpTTSEngineSite_GetActions_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpTTSEngineSite_Write_Proxy( + ISpTTSEngineSite * This, + /* [in] */ const void *pBuff, + /* [in] */ ULONG cb, + /* [out] */ ULONG *pcbWritten); + + +void __RPC_STUB ISpTTSEngineSite_Write_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpTTSEngineSite_GetRate_Proxy( + ISpTTSEngineSite * This, + /* [out] */ long *pRateAdjust); + + +void __RPC_STUB ISpTTSEngineSite_GetRate_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpTTSEngineSite_GetVolume_Proxy( + ISpTTSEngineSite * This, + /* [out] */ USHORT *pusVolume); + + +void __RPC_STUB ISpTTSEngineSite_GetVolume_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpTTSEngineSite_GetSkipInfo_Proxy( + ISpTTSEngineSite * This, + /* [out] */ SPVSKIPTYPE *peType, + /* [out] */ long *plNumItems); + + +void __RPC_STUB ISpTTSEngineSite_GetSkipInfo_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpTTSEngineSite_CompleteSkip_Proxy( + ISpTTSEngineSite * This, + /* [in] */ long ulNumSkipped); + + +void __RPC_STUB ISpTTSEngineSite_CompleteSkip_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpTTSEngineSite_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_sapiddk_0347 */ +/* [local] */ + +typedef struct SPVTEXTFRAG + { + struct SPVTEXTFRAG *pNext; + SPVSTATE State; + LPCWSTR pTextStart; + ULONG ulTextLen; + ULONG ulTextSrcOffset; + } SPVTEXTFRAG; + + + +extern RPC_IF_HANDLE __MIDL_itf_sapiddk_0347_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_sapiddk_0347_v0_0_s_ifspec; + +#ifndef __ISpTTSEngine_INTERFACE_DEFINED__ +#define __ISpTTSEngine_INTERFACE_DEFINED__ + +/* interface ISpTTSEngine */ +/* [unique][helpstring][uuid][local][object] */ + + +EXTERN_C const IID IID_ISpTTSEngine; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("A74D7C8E-4CC5-4f2f-A6EB-804DEE18500E") + ISpTTSEngine : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Speak( + /* [in] */ DWORD dwSpeakFlags, + /* [in] */ REFGUID rguidFormatId, + /* [in] */ const WAVEFORMATEX *pWaveFormatEx, + /* [in] */ const SPVTEXTFRAG *pTextFragList, + /* [in] */ ISpTTSEngineSite *pOutputSite) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetOutputFormat( + /* [in] */ const GUID *pTargetFmtId, + /* [in] */ const WAVEFORMATEX *pTargetWaveFormatEx, + /* [out] */ GUID *pOutputFormatId, + /* [out] */ WAVEFORMATEX **ppCoMemOutputWaveFormatEx) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpTTSEngineVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpTTSEngine * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpTTSEngine * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpTTSEngine * This); + + HRESULT ( STDMETHODCALLTYPE *Speak )( + ISpTTSEngine * This, + /* [in] */ DWORD dwSpeakFlags, + /* [in] */ REFGUID rguidFormatId, + /* [in] */ const WAVEFORMATEX *pWaveFormatEx, + /* [in] */ const SPVTEXTFRAG *pTextFragList, + /* [in] */ ISpTTSEngineSite *pOutputSite); + + HRESULT ( STDMETHODCALLTYPE *GetOutputFormat )( + ISpTTSEngine * This, + /* [in] */ const GUID *pTargetFmtId, + /* [in] */ const WAVEFORMATEX *pTargetWaveFormatEx, + /* [out] */ GUID *pOutputFormatId, + /* [out] */ WAVEFORMATEX **ppCoMemOutputWaveFormatEx); + + END_INTERFACE + } ISpTTSEngineVtbl; + + interface ISpTTSEngine + { + CONST_VTBL struct ISpTTSEngineVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpTTSEngine_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpTTSEngine_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpTTSEngine_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpTTSEngine_Speak(This,dwSpeakFlags,rguidFormatId,pWaveFormatEx,pTextFragList,pOutputSite) \ + (This)->lpVtbl -> Speak(This,dwSpeakFlags,rguidFormatId,pWaveFormatEx,pTextFragList,pOutputSite) + +#define ISpTTSEngine_GetOutputFormat(This,pTargetFmtId,pTargetWaveFormatEx,pOutputFormatId,ppCoMemOutputWaveFormatEx) \ + (This)->lpVtbl -> GetOutputFormat(This,pTargetFmtId,pTargetWaveFormatEx,pOutputFormatId,ppCoMemOutputWaveFormatEx) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpTTSEngine_Speak_Proxy( + ISpTTSEngine * This, + /* [in] */ DWORD dwSpeakFlags, + /* [in] */ REFGUID rguidFormatId, + /* [in] */ const WAVEFORMATEX *pWaveFormatEx, + /* [in] */ const SPVTEXTFRAG *pTextFragList, + /* [in] */ ISpTTSEngineSite *pOutputSite); + + +void __RPC_STUB ISpTTSEngine_Speak_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpTTSEngine_GetOutputFormat_Proxy( + ISpTTSEngine * This, + /* [in] */ const GUID *pTargetFmtId, + /* [in] */ const WAVEFORMATEX *pTargetWaveFormatEx, + /* [out] */ GUID *pOutputFormatId, + /* [out] */ WAVEFORMATEX **ppCoMemOutputWaveFormatEx); + + +void __RPC_STUB ISpTTSEngine_GetOutputFormat_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpTTSEngine_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_sapiddk_0348 */ +/* [local] */ + +typedef /* [restricted] */ struct SPWORDENTRY + { + SPWORDHANDLE hWord; + WORD LangID; + WCHAR *pszDisplayText; + WCHAR *pszLexicalForm; + SPPHONEID *aPhoneId; + void *pvClientContext; + } SPWORDENTRY; + +typedef /* [restricted] */ struct SPRULEENTRY + { + SPRULEHANDLE hRule; + SPSTATEHANDLE hInitialState; + DWORD Attributes; + void *pvClientRuleContext; + void *pvClientGrammarContext; + } SPRULEENTRY; + +typedef +enum SPTRANSITIONTYPE + { SPTRANSEPSILON = 0, + SPTRANSWORD = SPTRANSEPSILON + 1, + SPTRANSRULE = SPTRANSWORD + 1, + SPTRANSTEXTBUF = SPTRANSRULE + 1, + SPTRANSWILDCARD = SPTRANSTEXTBUF + 1, + SPTRANSDICTATION = SPTRANSWILDCARD + 1 + } SPTRANSITIONTYPE; + +typedef /* [restricted] */ struct SPTRANSITIONENTRY + { + SPTRANSITIONID ID; + SPSTATEHANDLE hNextState; + BYTE Type; + char RequiredConfidence; + struct + { + DWORD fHasProperty; + } ; + float Weight; + union + { + struct + { + SPSTATEHANDLE hRuleInitialState; + SPRULEHANDLE hRule; + void *pvClientRuleContext; + } ; + struct + { + SPWORDHANDLE hWord; + void *pvClientWordContext; + } ; + struct + { + void *pvGrammarCookie; + } ; + } ; + } SPTRANSITIONENTRY; + +typedef /* [restricted] */ struct SPTRANSITIONPROPERTY + { + const WCHAR *pszName; + ULONG ulId; + const WCHAR *pszValue; + VARIANT vValue; + } SPTRANSITIONPROPERTY; + +typedef /* [restricted] */ struct SPSTATEINFO + { + ULONG cAllocatedEntries; + SPTRANSITIONENTRY *pTransitions; + ULONG cEpsilons; + ULONG cRules; + ULONG cWords; + ULONG cSpecialTransitions; + } SPSTATEINFO; + +typedef /* [restricted] */ struct SPPATHENTRY + { + SPTRANSITIONID hTransition; + SPPHRASEELEMENT elem; + } SPPATHENTRY; + + + +extern RPC_IF_HANDLE __MIDL_itf_sapiddk_0348_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_sapiddk_0348_v0_0_s_ifspec; + +#ifndef __ISpCFGInterpreterSite_INTERFACE_DEFINED__ +#define __ISpCFGInterpreterSite_INTERFACE_DEFINED__ + +/* interface ISpCFGInterpreterSite */ +/* [restricted][local][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpCFGInterpreterSite; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("6A6FFAD8-78B6-473d-B844-98152E4FB16B") + ISpCFGInterpreterSite : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE AddTextReplacement( + /* [in] */ SPPHRASEREPLACEMENT *pReplace) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddProperty( + /* [in] */ const SPPHRASEPROPERTY *pProperty) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetResourceValue( + /* [in] */ const WCHAR *pszResourceName, + /* [out] */ WCHAR **ppCoMemResource) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpCFGInterpreterSiteVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpCFGInterpreterSite * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpCFGInterpreterSite * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpCFGInterpreterSite * This); + + HRESULT ( STDMETHODCALLTYPE *AddTextReplacement )( + ISpCFGInterpreterSite * This, + /* [in] */ SPPHRASEREPLACEMENT *pReplace); + + HRESULT ( STDMETHODCALLTYPE *AddProperty )( + ISpCFGInterpreterSite * This, + /* [in] */ const SPPHRASEPROPERTY *pProperty); + + HRESULT ( STDMETHODCALLTYPE *GetResourceValue )( + ISpCFGInterpreterSite * This, + /* [in] */ const WCHAR *pszResourceName, + /* [out] */ WCHAR **ppCoMemResource); + + END_INTERFACE + } ISpCFGInterpreterSiteVtbl; + + interface ISpCFGInterpreterSite + { + CONST_VTBL struct ISpCFGInterpreterSiteVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpCFGInterpreterSite_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpCFGInterpreterSite_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpCFGInterpreterSite_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpCFGInterpreterSite_AddTextReplacement(This,pReplace) \ + (This)->lpVtbl -> AddTextReplacement(This,pReplace) + +#define ISpCFGInterpreterSite_AddProperty(This,pProperty) \ + (This)->lpVtbl -> AddProperty(This,pProperty) + +#define ISpCFGInterpreterSite_GetResourceValue(This,pszResourceName,ppCoMemResource) \ + (This)->lpVtbl -> GetResourceValue(This,pszResourceName,ppCoMemResource) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpCFGInterpreterSite_AddTextReplacement_Proxy( + ISpCFGInterpreterSite * This, + /* [in] */ SPPHRASEREPLACEMENT *pReplace); + + +void __RPC_STUB ISpCFGInterpreterSite_AddTextReplacement_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpCFGInterpreterSite_AddProperty_Proxy( + ISpCFGInterpreterSite * This, + /* [in] */ const SPPHRASEPROPERTY *pProperty); + + +void __RPC_STUB ISpCFGInterpreterSite_AddProperty_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpCFGInterpreterSite_GetResourceValue_Proxy( + ISpCFGInterpreterSite * This, + /* [in] */ const WCHAR *pszResourceName, + /* [out] */ WCHAR **ppCoMemResource); + + +void __RPC_STUB ISpCFGInterpreterSite_GetResourceValue_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpCFGInterpreterSite_INTERFACE_DEFINED__ */ + + +#ifndef __ISpCFGInterpreter_INTERFACE_DEFINED__ +#define __ISpCFGInterpreter_INTERFACE_DEFINED__ + +/* interface ISpCFGInterpreter */ +/* [restricted][local][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpCFGInterpreter; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("F3D3F926-11FC-11d3-BB97-00C04F8EE6C0") + ISpCFGInterpreter : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE InitGrammar( + /* [in] */ const WCHAR *pszGrammarName, + /* [in] */ const void **pvGrammarData) = 0; + + virtual HRESULT STDMETHODCALLTYPE Interpret( + /* [in] */ ISpPhraseBuilder *pPhrase, + /* [in] */ const ULONG ulFirstElement, + /* [in] */ const ULONG ulCountOfElements, + /* [in] */ ISpCFGInterpreterSite *pSite) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpCFGInterpreterVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpCFGInterpreter * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpCFGInterpreter * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpCFGInterpreter * This); + + HRESULT ( STDMETHODCALLTYPE *InitGrammar )( + ISpCFGInterpreter * This, + /* [in] */ const WCHAR *pszGrammarName, + /* [in] */ const void **pvGrammarData); + + HRESULT ( STDMETHODCALLTYPE *Interpret )( + ISpCFGInterpreter * This, + /* [in] */ ISpPhraseBuilder *pPhrase, + /* [in] */ const ULONG ulFirstElement, + /* [in] */ const ULONG ulCountOfElements, + /* [in] */ ISpCFGInterpreterSite *pSite); + + END_INTERFACE + } ISpCFGInterpreterVtbl; + + interface ISpCFGInterpreter + { + CONST_VTBL struct ISpCFGInterpreterVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpCFGInterpreter_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpCFGInterpreter_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpCFGInterpreter_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpCFGInterpreter_InitGrammar(This,pszGrammarName,pvGrammarData) \ + (This)->lpVtbl -> InitGrammar(This,pszGrammarName,pvGrammarData) + +#define ISpCFGInterpreter_Interpret(This,pPhrase,ulFirstElement,ulCountOfElements,pSite) \ + (This)->lpVtbl -> Interpret(This,pPhrase,ulFirstElement,ulCountOfElements,pSite) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpCFGInterpreter_InitGrammar_Proxy( + ISpCFGInterpreter * This, + /* [in] */ const WCHAR *pszGrammarName, + /* [in] */ const void **pvGrammarData); + + +void __RPC_STUB ISpCFGInterpreter_InitGrammar_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpCFGInterpreter_Interpret_Proxy( + ISpCFGInterpreter * This, + /* [in] */ ISpPhraseBuilder *pPhrase, + /* [in] */ const ULONG ulFirstElement, + /* [in] */ const ULONG ulCountOfElements, + /* [in] */ ISpCFGInterpreterSite *pSite); + + +void __RPC_STUB ISpCFGInterpreter_Interpret_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpCFGInterpreter_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_sapiddk_0350 */ +/* [local] */ + +typedef +enum SPCFGNOTIFY + { SPCFGN_ADD = 0, + SPCFGN_REMOVE = SPCFGN_ADD + 1, + SPCFGN_INVALIDATE = SPCFGN_REMOVE + 1, + SPCFGN_ACTIVATE = SPCFGN_INVALIDATE + 1, + SPCFGN_DEACTIVATE = SPCFGN_ACTIVATE + 1 + } SPCFGNOTIFY; + +typedef +enum SPRESULTTYPE + { SPRT_CFG = 0, + SPRT_SLM = 1, + SPRT_PROPRIETARY = 2, + SPRT_FALSE_RECOGNITION = 1L << 2 + } SPRESULTTYPE; + +typedef struct tagSPPHRASEALT + { + ISpPhraseBuilder *pPhrase; + ULONG ulStartElementInParent; + ULONG cElementsInParent; + ULONG cElementsInAlternate; + void *pvAltExtra; + ULONG cbAltExtra; + } SPPHRASEALT; + +typedef struct SPRECORESULTINFO + { + ULONG cbSize; + SPRESULTTYPE eResultType; + BOOL fHypothesis; + BOOL fProprietaryAutoPause; + ULONGLONG ullStreamPosStart; + ULONGLONG ullStreamPosEnd; + SPGRAMMARHANDLE hGrammar; + ULONG ulSizeEngineData; + void *pvEngineData; + ISpPhraseBuilder *pPhrase; + SPPHRASEALT *aPhraseAlts; + ULONG ulNumAlts; + } SPRECORESULTINFO; + +typedef +enum SPWORDINFOOPT + { SPWIO_NONE = 0, + SPWIO_WANT_TEXT = 1 + } SPWORDINFOOPT; + +typedef +enum SPRULEINFOOPT + { SPRIO_NONE = 0 + } SPRULEINFOOPT; + +typedef struct SPPARSEINFO + { + ULONG cbSize; + SPRULEHANDLE hRule; + ULONGLONG ullAudioStreamPosition; + ULONG ulAudioSize; + ULONG cTransitions; + SPPATHENTRY *pPath; + GUID SREngineID; + ULONG ulSREnginePrivateDataSize; + const BYTE *pSREnginePrivateData; + BOOL fHypothesis; + } SPPARSEINFO; + + + +extern RPC_IF_HANDLE __MIDL_itf_sapiddk_0350_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_sapiddk_0350_v0_0_s_ifspec; + +#ifndef __ISpSREngineSite_INTERFACE_DEFINED__ +#define __ISpSREngineSite_INTERFACE_DEFINED__ + +/* interface ISpSREngineSite */ +/* [local][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpSREngineSite; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("3B414AEC-720C-4883-B9EF-178CD394FB3A") + ISpSREngineSite : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Read( + /* [in] */ void *pv, + /* [in] */ ULONG cb, + /* [out] */ ULONG *pcbRead) = 0; + + virtual HRESULT STDMETHODCALLTYPE DataAvailable( + ULONG *pcb) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetBufferNotifySize( + /* [in] */ ULONG cbSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE ParseFromTransitions( + /* [in] */ const SPPARSEINFO *pParseInfo, + /* [out] */ ISpPhraseBuilder **ppNewPhrase) = 0; + + virtual HRESULT STDMETHODCALLTYPE Recognition( + /* [in] */ const SPRECORESULTINFO *pResultInfo) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddEvent( + /* [in] */ const SPEVENT *pEvent, + /* [in] */ SPRECOCONTEXTHANDLE hSAPIRecoContext) = 0; + + virtual HRESULT STDMETHODCALLTYPE Synchronize( + /* [in] */ ULONGLONG ullProcessedThruPos) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetWordInfo( + /* [out][in] */ SPWORDENTRY *pWordEntry, + /* [in] */ SPWORDINFOOPT Options) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetWordClientContext( + SPWORDHANDLE hWord, + void *pvClientContext) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetRuleInfo( + /* [out][in] */ SPRULEENTRY *pRuleEntry, + /* [in] */ SPRULEINFOOPT Options) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetRuleClientContext( + SPRULEHANDLE hRule, + void *pvClientContext) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStateInfo( + SPSTATEHANDLE hState, + SPSTATEINFO *pStateInfo) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetResource( + /* [in] */ SPRULEHANDLE hRule, + /* [in] */ const WCHAR *pszResourceName, + /* [out] */ WCHAR **ppCoMemResource) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTransitionProperty( + /* [in] */ SPTRANSITIONID ID, + /* [out] */ SPTRANSITIONPROPERTY **ppCoMemProperty) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsAlternate( + /* [in] */ SPRULEHANDLE hRule, + /* [in] */ SPRULEHANDLE hAltRule) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMaxAlternates( + /* [in] */ SPRULEHANDLE hRule, + /* [out] */ ULONG *pulNumAlts) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetContextMaxAlternates( + /* [in] */ SPRECOCONTEXTHANDLE hContext, + /* [out] */ ULONG *pulNumAlts) = 0; + + virtual HRESULT STDMETHODCALLTYPE UpdateRecoPos( + /* [in] */ ULONGLONG ullCurrentRecoPos) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpSREngineSiteVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpSREngineSite * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpSREngineSite * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpSREngineSite * This); + + HRESULT ( STDMETHODCALLTYPE *Read )( + ISpSREngineSite * This, + /* [in] */ void *pv, + /* [in] */ ULONG cb, + /* [out] */ ULONG *pcbRead); + + HRESULT ( STDMETHODCALLTYPE *DataAvailable )( + ISpSREngineSite * This, + ULONG *pcb); + + HRESULT ( STDMETHODCALLTYPE *SetBufferNotifySize )( + ISpSREngineSite * This, + /* [in] */ ULONG cbSize); + + HRESULT ( STDMETHODCALLTYPE *ParseFromTransitions )( + ISpSREngineSite * This, + /* [in] */ const SPPARSEINFO *pParseInfo, + /* [out] */ ISpPhraseBuilder **ppNewPhrase); + + HRESULT ( STDMETHODCALLTYPE *Recognition )( + ISpSREngineSite * This, + /* [in] */ const SPRECORESULTINFO *pResultInfo); + + HRESULT ( STDMETHODCALLTYPE *AddEvent )( + ISpSREngineSite * This, + /* [in] */ const SPEVENT *pEvent, + /* [in] */ SPRECOCONTEXTHANDLE hSAPIRecoContext); + + HRESULT ( STDMETHODCALLTYPE *Synchronize )( + ISpSREngineSite * This, + /* [in] */ ULONGLONG ullProcessedThruPos); + + HRESULT ( STDMETHODCALLTYPE *GetWordInfo )( + ISpSREngineSite * This, + /* [out][in] */ SPWORDENTRY *pWordEntry, + /* [in] */ SPWORDINFOOPT Options); + + HRESULT ( STDMETHODCALLTYPE *SetWordClientContext )( + ISpSREngineSite * This, + SPWORDHANDLE hWord, + void *pvClientContext); + + HRESULT ( STDMETHODCALLTYPE *GetRuleInfo )( + ISpSREngineSite * This, + /* [out][in] */ SPRULEENTRY *pRuleEntry, + /* [in] */ SPRULEINFOOPT Options); + + HRESULT ( STDMETHODCALLTYPE *SetRuleClientContext )( + ISpSREngineSite * This, + SPRULEHANDLE hRule, + void *pvClientContext); + + HRESULT ( STDMETHODCALLTYPE *GetStateInfo )( + ISpSREngineSite * This, + SPSTATEHANDLE hState, + SPSTATEINFO *pStateInfo); + + HRESULT ( STDMETHODCALLTYPE *GetResource )( + ISpSREngineSite * This, + /* [in] */ SPRULEHANDLE hRule, + /* [in] */ const WCHAR *pszResourceName, + /* [out] */ WCHAR **ppCoMemResource); + + HRESULT ( STDMETHODCALLTYPE *GetTransitionProperty )( + ISpSREngineSite * This, + /* [in] */ SPTRANSITIONID ID, + /* [out] */ SPTRANSITIONPROPERTY **ppCoMemProperty); + + HRESULT ( STDMETHODCALLTYPE *IsAlternate )( + ISpSREngineSite * This, + /* [in] */ SPRULEHANDLE hRule, + /* [in] */ SPRULEHANDLE hAltRule); + + HRESULT ( STDMETHODCALLTYPE *GetMaxAlternates )( + ISpSREngineSite * This, + /* [in] */ SPRULEHANDLE hRule, + /* [out] */ ULONG *pulNumAlts); + + HRESULT ( STDMETHODCALLTYPE *GetContextMaxAlternates )( + ISpSREngineSite * This, + /* [in] */ SPRECOCONTEXTHANDLE hContext, + /* [out] */ ULONG *pulNumAlts); + + HRESULT ( STDMETHODCALLTYPE *UpdateRecoPos )( + ISpSREngineSite * This, + /* [in] */ ULONGLONG ullCurrentRecoPos); + + END_INTERFACE + } ISpSREngineSiteVtbl; + + interface ISpSREngineSite + { + CONST_VTBL struct ISpSREngineSiteVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpSREngineSite_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpSREngineSite_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpSREngineSite_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpSREngineSite_Read(This,pv,cb,pcbRead) \ + (This)->lpVtbl -> Read(This,pv,cb,pcbRead) + +#define ISpSREngineSite_DataAvailable(This,pcb) \ + (This)->lpVtbl -> DataAvailable(This,pcb) + +#define ISpSREngineSite_SetBufferNotifySize(This,cbSize) \ + (This)->lpVtbl -> SetBufferNotifySize(This,cbSize) + +#define ISpSREngineSite_ParseFromTransitions(This,pParseInfo,ppNewPhrase) \ + (This)->lpVtbl -> ParseFromTransitions(This,pParseInfo,ppNewPhrase) + +#define ISpSREngineSite_Recognition(This,pResultInfo) \ + (This)->lpVtbl -> Recognition(This,pResultInfo) + +#define ISpSREngineSite_AddEvent(This,pEvent,hSAPIRecoContext) \ + (This)->lpVtbl -> AddEvent(This,pEvent,hSAPIRecoContext) + +#define ISpSREngineSite_Synchronize(This,ullProcessedThruPos) \ + (This)->lpVtbl -> Synchronize(This,ullProcessedThruPos) + +#define ISpSREngineSite_GetWordInfo(This,pWordEntry,Options) \ + (This)->lpVtbl -> GetWordInfo(This,pWordEntry,Options) + +#define ISpSREngineSite_SetWordClientContext(This,hWord,pvClientContext) \ + (This)->lpVtbl -> SetWordClientContext(This,hWord,pvClientContext) + +#define ISpSREngineSite_GetRuleInfo(This,pRuleEntry,Options) \ + (This)->lpVtbl -> GetRuleInfo(This,pRuleEntry,Options) + +#define ISpSREngineSite_SetRuleClientContext(This,hRule,pvClientContext) \ + (This)->lpVtbl -> SetRuleClientContext(This,hRule,pvClientContext) + +#define ISpSREngineSite_GetStateInfo(This,hState,pStateInfo) \ + (This)->lpVtbl -> GetStateInfo(This,hState,pStateInfo) + +#define ISpSREngineSite_GetResource(This,hRule,pszResourceName,ppCoMemResource) \ + (This)->lpVtbl -> GetResource(This,hRule,pszResourceName,ppCoMemResource) + +#define ISpSREngineSite_GetTransitionProperty(This,ID,ppCoMemProperty) \ + (This)->lpVtbl -> GetTransitionProperty(This,ID,ppCoMemProperty) + +#define ISpSREngineSite_IsAlternate(This,hRule,hAltRule) \ + (This)->lpVtbl -> IsAlternate(This,hRule,hAltRule) + +#define ISpSREngineSite_GetMaxAlternates(This,hRule,pulNumAlts) \ + (This)->lpVtbl -> GetMaxAlternates(This,hRule,pulNumAlts) + +#define ISpSREngineSite_GetContextMaxAlternates(This,hContext,pulNumAlts) \ + (This)->lpVtbl -> GetContextMaxAlternates(This,hContext,pulNumAlts) + +#define ISpSREngineSite_UpdateRecoPos(This,ullCurrentRecoPos) \ + (This)->lpVtbl -> UpdateRecoPos(This,ullCurrentRecoPos) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpSREngineSite_Read_Proxy( + ISpSREngineSite * This, + /* [in] */ void *pv, + /* [in] */ ULONG cb, + /* [out] */ ULONG *pcbRead); + + +void __RPC_STUB ISpSREngineSite_Read_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngineSite_DataAvailable_Proxy( + ISpSREngineSite * This, + ULONG *pcb); + + +void __RPC_STUB ISpSREngineSite_DataAvailable_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngineSite_SetBufferNotifySize_Proxy( + ISpSREngineSite * This, + /* [in] */ ULONG cbSize); + + +void __RPC_STUB ISpSREngineSite_SetBufferNotifySize_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngineSite_ParseFromTransitions_Proxy( + ISpSREngineSite * This, + /* [in] */ const SPPARSEINFO *pParseInfo, + /* [out] */ ISpPhraseBuilder **ppNewPhrase); + + +void __RPC_STUB ISpSREngineSite_ParseFromTransitions_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngineSite_Recognition_Proxy( + ISpSREngineSite * This, + /* [in] */ const SPRECORESULTINFO *pResultInfo); + + +void __RPC_STUB ISpSREngineSite_Recognition_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngineSite_AddEvent_Proxy( + ISpSREngineSite * This, + /* [in] */ const SPEVENT *pEvent, + /* [in] */ SPRECOCONTEXTHANDLE hSAPIRecoContext); + + +void __RPC_STUB ISpSREngineSite_AddEvent_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngineSite_Synchronize_Proxy( + ISpSREngineSite * This, + /* [in] */ ULONGLONG ullProcessedThruPos); + + +void __RPC_STUB ISpSREngineSite_Synchronize_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngineSite_GetWordInfo_Proxy( + ISpSREngineSite * This, + /* [out][in] */ SPWORDENTRY *pWordEntry, + /* [in] */ SPWORDINFOOPT Options); + + +void __RPC_STUB ISpSREngineSite_GetWordInfo_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngineSite_SetWordClientContext_Proxy( + ISpSREngineSite * This, + SPWORDHANDLE hWord, + void *pvClientContext); + + +void __RPC_STUB ISpSREngineSite_SetWordClientContext_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngineSite_GetRuleInfo_Proxy( + ISpSREngineSite * This, + /* [out][in] */ SPRULEENTRY *pRuleEntry, + /* [in] */ SPRULEINFOOPT Options); + + +void __RPC_STUB ISpSREngineSite_GetRuleInfo_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngineSite_SetRuleClientContext_Proxy( + ISpSREngineSite * This, + SPRULEHANDLE hRule, + void *pvClientContext); + + +void __RPC_STUB ISpSREngineSite_SetRuleClientContext_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngineSite_GetStateInfo_Proxy( + ISpSREngineSite * This, + SPSTATEHANDLE hState, + SPSTATEINFO *pStateInfo); + + +void __RPC_STUB ISpSREngineSite_GetStateInfo_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngineSite_GetResource_Proxy( + ISpSREngineSite * This, + /* [in] */ SPRULEHANDLE hRule, + /* [in] */ const WCHAR *pszResourceName, + /* [out] */ WCHAR **ppCoMemResource); + + +void __RPC_STUB ISpSREngineSite_GetResource_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngineSite_GetTransitionProperty_Proxy( + ISpSREngineSite * This, + /* [in] */ SPTRANSITIONID ID, + /* [out] */ SPTRANSITIONPROPERTY **ppCoMemProperty); + + +void __RPC_STUB ISpSREngineSite_GetTransitionProperty_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngineSite_IsAlternate_Proxy( + ISpSREngineSite * This, + /* [in] */ SPRULEHANDLE hRule, + /* [in] */ SPRULEHANDLE hAltRule); + + +void __RPC_STUB ISpSREngineSite_IsAlternate_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngineSite_GetMaxAlternates_Proxy( + ISpSREngineSite * This, + /* [in] */ SPRULEHANDLE hRule, + /* [out] */ ULONG *pulNumAlts); + + +void __RPC_STUB ISpSREngineSite_GetMaxAlternates_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngineSite_GetContextMaxAlternates_Proxy( + ISpSREngineSite * This, + /* [in] */ SPRECOCONTEXTHANDLE hContext, + /* [out] */ ULONG *pulNumAlts); + + +void __RPC_STUB ISpSREngineSite_GetContextMaxAlternates_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngineSite_UpdateRecoPos_Proxy( + ISpSREngineSite * This, + /* [in] */ ULONGLONG ullCurrentRecoPos); + + +void __RPC_STUB ISpSREngineSite_UpdateRecoPos_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpSREngineSite_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_sapiddk_0351 */ +/* [local] */ + +typedef +enum SPPROPSRC + { SPPROPSRC_RECO_INST = 0, + SPPROPSRC_RECO_CTX = SPPROPSRC_RECO_INST + 1, + SPPROPSRC_RECO_GRAMMAR = SPPROPSRC_RECO_CTX + 1 + } SPPROPSRC; + + + +extern RPC_IF_HANDLE __MIDL_itf_sapiddk_0351_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_sapiddk_0351_v0_0_s_ifspec; + +#ifndef __ISpSREngine_INTERFACE_DEFINED__ +#define __ISpSREngine_INTERFACE_DEFINED__ + +/* interface ISpSREngine */ +/* [local][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpSREngine; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("2F472991-854B-4465-B613-FBAFB3AD8ED8") + ISpSREngine : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetSite( + /* [in] */ ISpSREngineSite *pSite) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInputAudioFormat( + /* [in] */ const GUID *pguidSourceFormatId, + /* [in] */ const WAVEFORMATEX *pSourceWaveFormatEx, + /* [out] */ GUID *pguidDesiredFormatId, + /* [out] */ WAVEFORMATEX **ppCoMemDesiredWaveFormatEx) = 0; + + virtual HRESULT STDMETHODCALLTYPE RecognizeStream( + /* [in] */ REFGUID rguidFmtId, + /* [in] */ const WAVEFORMATEX *pWaveFormatEx, + /* [in] */ HANDLE hRequestSync, + /* [in] */ HANDLE hDataAvailable, + /* [in] */ HANDLE hExit, + /* [in] */ BOOL fNewAudioStream, + /* [in] */ BOOL fRealTimeAudio, + /* [in] */ ISpObjectToken *pAudioObjectToken) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetRecoProfile( + ISpObjectToken *pProfile) = 0; + + virtual HRESULT STDMETHODCALLTYPE OnCreateGrammar( + /* [in] */ void *pvEngineRecoContext, + /* [in] */ SPGRAMMARHANDLE hSAPIGrammar, + /* [out] */ void **ppvEngineGrammarContext) = 0; + + virtual HRESULT STDMETHODCALLTYPE OnDeleteGrammar( + /* [in] */ void *pvEngineGrammar) = 0; + + virtual HRESULT STDMETHODCALLTYPE LoadProprietaryGrammar( + /* [in] */ void *pvEngineGrammar, + /* [in] */ REFGUID rguidParam, + /* [string][in] */ const WCHAR *pszStringParam, + /* [in] */ const void *pvDataParam, + /* [in] */ ULONG ulDataSize, + /* [in] */ SPLOADOPTIONS Options) = 0; + + virtual HRESULT STDMETHODCALLTYPE UnloadProprietaryGrammar( + /* [in] */ void *pvEngineGrammar) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetProprietaryRuleState( + /* [in] */ void *pvEngineGrammar, + /* [string][in] */ const WCHAR *pszName, + /* [in] */ void *pReserved, + /* [in] */ SPRULESTATE NewState, + /* [out] */ ULONG *pcRulesChanged) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetProprietaryRuleIdState( + /* [in] */ void *pvEngineGrammar, + /* [in] */ DWORD dwRuleId, + /* [in] */ SPRULESTATE NewState) = 0; + + virtual HRESULT STDMETHODCALLTYPE LoadSLM( + /* [in] */ void *pvEngineGrammar, + /* [string][in] */ const WCHAR *pszTopicName) = 0; + + virtual HRESULT STDMETHODCALLTYPE UnloadSLM( + /* [in] */ void *pvEngineGrammar) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetSLMState( + /* [in] */ void *pvEngineGrammar, + /* [in] */ SPRULESTATE NewState) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetWordSequenceData( + /* [in] */ void *pvEngineGrammar, + /* [in] */ const WCHAR *pText, + /* [in] */ ULONG cchText, + /* [in] */ const SPTEXTSELECTIONINFO *pInfo) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetTextSelection( + /* [in] */ void *pvEngineGrammar, + /* [in] */ const SPTEXTSELECTIONINFO *pInfo) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsPronounceable( + /* [in] */ void *pvEngineGrammar, + /* [string][in] */ const WCHAR *pszWord, + /* [out] */ SPWORDPRONOUNCEABLE *pWordPronounceable) = 0; + + virtual HRESULT STDMETHODCALLTYPE OnCreateRecoContext( + /* [in] */ SPRECOCONTEXTHANDLE hSAPIRecoContext, + /* [out] */ void **ppvEngineContext) = 0; + + virtual HRESULT STDMETHODCALLTYPE OnDeleteRecoContext( + /* [in] */ void *pvEngineContext) = 0; + + virtual HRESULT STDMETHODCALLTYPE PrivateCall( + /* [in] */ void *pvEngineContext, + /* [out][in] */ PVOID pCallFrame, + /* [in] */ ULONG ulCallFrameSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetAdaptationData( + /* [in] */ void *pvEngineContext, + const WCHAR *pAdaptationData, + const ULONG cch) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetPropertyNum( + /* [in] */ SPPROPSRC eSrc, + /* [in] */ void *pvSrcObj, + /* [in] */ const WCHAR *pName, + /* [in] */ LONG lValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPropertyNum( + /* [in] */ SPPROPSRC eSrc, + /* [in] */ void *pvSrcObj, + /* [in] */ const WCHAR *pName, + /* [out] */ LONG *lValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetPropertyString( + /* [in] */ SPPROPSRC eSrc, + /* [in] */ void *pvSrcObj, + /* [in] */ const WCHAR *pName, + /* [in] */ const WCHAR *pValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPropertyString( + /* [in] */ SPPROPSRC eSrc, + /* [in] */ void *pvSrcObj, + /* [in] */ const WCHAR *pName, + /* [out] */ WCHAR **ppCoMemValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetGrammarState( + /* [in] */ void *pvEngineGrammar, + /* [in] */ SPGRAMMARSTATE eGrammarState) = 0; + + virtual HRESULT STDMETHODCALLTYPE WordNotify( + SPCFGNOTIFY Action, + ULONG cWords, + const SPWORDENTRY *pWords) = 0; + + virtual HRESULT STDMETHODCALLTYPE RuleNotify( + SPCFGNOTIFY Action, + ULONG cRules, + const SPRULEENTRY *pRules) = 0; + + virtual HRESULT STDMETHODCALLTYPE PrivateCallEx( + /* [in] */ void *pvEngineContext, + /* [in] */ const void *pInCallFrame, + /* [in] */ ULONG ulInCallFrameSize, + /* [out] */ void **ppvCoMemResponse, + /* [out] */ ULONG *pulResponseSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetContextState( + /* [in] */ void *pvEngineContext, + /* [in] */ SPCONTEXTSTATE eContextState) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpSREngineVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpSREngine * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpSREngine * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpSREngine * This); + + HRESULT ( STDMETHODCALLTYPE *SetSite )( + ISpSREngine * This, + /* [in] */ ISpSREngineSite *pSite); + + HRESULT ( STDMETHODCALLTYPE *GetInputAudioFormat )( + ISpSREngine * This, + /* [in] */ const GUID *pguidSourceFormatId, + /* [in] */ const WAVEFORMATEX *pSourceWaveFormatEx, + /* [out] */ GUID *pguidDesiredFormatId, + /* [out] */ WAVEFORMATEX **ppCoMemDesiredWaveFormatEx); + + HRESULT ( STDMETHODCALLTYPE *RecognizeStream )( + ISpSREngine * This, + /* [in] */ REFGUID rguidFmtId, + /* [in] */ const WAVEFORMATEX *pWaveFormatEx, + /* [in] */ HANDLE hRequestSync, + /* [in] */ HANDLE hDataAvailable, + /* [in] */ HANDLE hExit, + /* [in] */ BOOL fNewAudioStream, + /* [in] */ BOOL fRealTimeAudio, + /* [in] */ ISpObjectToken *pAudioObjectToken); + + HRESULT ( STDMETHODCALLTYPE *SetRecoProfile )( + ISpSREngine * This, + ISpObjectToken *pProfile); + + HRESULT ( STDMETHODCALLTYPE *OnCreateGrammar )( + ISpSREngine * This, + /* [in] */ void *pvEngineRecoContext, + /* [in] */ SPGRAMMARHANDLE hSAPIGrammar, + /* [out] */ void **ppvEngineGrammarContext); + + HRESULT ( STDMETHODCALLTYPE *OnDeleteGrammar )( + ISpSREngine * This, + /* [in] */ void *pvEngineGrammar); + + HRESULT ( STDMETHODCALLTYPE *LoadProprietaryGrammar )( + ISpSREngine * This, + /* [in] */ void *pvEngineGrammar, + /* [in] */ REFGUID rguidParam, + /* [string][in] */ const WCHAR *pszStringParam, + /* [in] */ const void *pvDataParam, + /* [in] */ ULONG ulDataSize, + /* [in] */ SPLOADOPTIONS Options); + + HRESULT ( STDMETHODCALLTYPE *UnloadProprietaryGrammar )( + ISpSREngine * This, + /* [in] */ void *pvEngineGrammar); + + HRESULT ( STDMETHODCALLTYPE *SetProprietaryRuleState )( + ISpSREngine * This, + /* [in] */ void *pvEngineGrammar, + /* [string][in] */ const WCHAR *pszName, + /* [in] */ void *pReserved, + /* [in] */ SPRULESTATE NewState, + /* [out] */ ULONG *pcRulesChanged); + + HRESULT ( STDMETHODCALLTYPE *SetProprietaryRuleIdState )( + ISpSREngine * This, + /* [in] */ void *pvEngineGrammar, + /* [in] */ DWORD dwRuleId, + /* [in] */ SPRULESTATE NewState); + + HRESULT ( STDMETHODCALLTYPE *LoadSLM )( + ISpSREngine * This, + /* [in] */ void *pvEngineGrammar, + /* [string][in] */ const WCHAR *pszTopicName); + + HRESULT ( STDMETHODCALLTYPE *UnloadSLM )( + ISpSREngine * This, + /* [in] */ void *pvEngineGrammar); + + HRESULT ( STDMETHODCALLTYPE *SetSLMState )( + ISpSREngine * This, + /* [in] */ void *pvEngineGrammar, + /* [in] */ SPRULESTATE NewState); + + HRESULT ( STDMETHODCALLTYPE *SetWordSequenceData )( + ISpSREngine * This, + /* [in] */ void *pvEngineGrammar, + /* [in] */ const WCHAR *pText, + /* [in] */ ULONG cchText, + /* [in] */ const SPTEXTSELECTIONINFO *pInfo); + + HRESULT ( STDMETHODCALLTYPE *SetTextSelection )( + ISpSREngine * This, + /* [in] */ void *pvEngineGrammar, + /* [in] */ const SPTEXTSELECTIONINFO *pInfo); + + HRESULT ( STDMETHODCALLTYPE *IsPronounceable )( + ISpSREngine * This, + /* [in] */ void *pvEngineGrammar, + /* [string][in] */ const WCHAR *pszWord, + /* [out] */ SPWORDPRONOUNCEABLE *pWordPronounceable); + + HRESULT ( STDMETHODCALLTYPE *OnCreateRecoContext )( + ISpSREngine * This, + /* [in] */ SPRECOCONTEXTHANDLE hSAPIRecoContext, + /* [out] */ void **ppvEngineContext); + + HRESULT ( STDMETHODCALLTYPE *OnDeleteRecoContext )( + ISpSREngine * This, + /* [in] */ void *pvEngineContext); + + HRESULT ( STDMETHODCALLTYPE *PrivateCall )( + ISpSREngine * This, + /* [in] */ void *pvEngineContext, + /* [out][in] */ PVOID pCallFrame, + /* [in] */ ULONG ulCallFrameSize); + + HRESULT ( STDMETHODCALLTYPE *SetAdaptationData )( + ISpSREngine * This, + /* [in] */ void *pvEngineContext, + const WCHAR *pAdaptationData, + const ULONG cch); + + HRESULT ( STDMETHODCALLTYPE *SetPropertyNum )( + ISpSREngine * This, + /* [in] */ SPPROPSRC eSrc, + /* [in] */ void *pvSrcObj, + /* [in] */ const WCHAR *pName, + /* [in] */ LONG lValue); + + HRESULT ( STDMETHODCALLTYPE *GetPropertyNum )( + ISpSREngine * This, + /* [in] */ SPPROPSRC eSrc, + /* [in] */ void *pvSrcObj, + /* [in] */ const WCHAR *pName, + /* [out] */ LONG *lValue); + + HRESULT ( STDMETHODCALLTYPE *SetPropertyString )( + ISpSREngine * This, + /* [in] */ SPPROPSRC eSrc, + /* [in] */ void *pvSrcObj, + /* [in] */ const WCHAR *pName, + /* [in] */ const WCHAR *pValue); + + HRESULT ( STDMETHODCALLTYPE *GetPropertyString )( + ISpSREngine * This, + /* [in] */ SPPROPSRC eSrc, + /* [in] */ void *pvSrcObj, + /* [in] */ const WCHAR *pName, + /* [out] */ WCHAR **ppCoMemValue); + + HRESULT ( STDMETHODCALLTYPE *SetGrammarState )( + ISpSREngine * This, + /* [in] */ void *pvEngineGrammar, + /* [in] */ SPGRAMMARSTATE eGrammarState); + + HRESULT ( STDMETHODCALLTYPE *WordNotify )( + ISpSREngine * This, + SPCFGNOTIFY Action, + ULONG cWords, + const SPWORDENTRY *pWords); + + HRESULT ( STDMETHODCALLTYPE *RuleNotify )( + ISpSREngine * This, + SPCFGNOTIFY Action, + ULONG cRules, + const SPRULEENTRY *pRules); + + HRESULT ( STDMETHODCALLTYPE *PrivateCallEx )( + ISpSREngine * This, + /* [in] */ void *pvEngineContext, + /* [in] */ const void *pInCallFrame, + /* [in] */ ULONG ulInCallFrameSize, + /* [out] */ void **ppvCoMemResponse, + /* [out] */ ULONG *pulResponseSize); + + HRESULT ( STDMETHODCALLTYPE *SetContextState )( + ISpSREngine * This, + /* [in] */ void *pvEngineContext, + /* [in] */ SPCONTEXTSTATE eContextState); + + END_INTERFACE + } ISpSREngineVtbl; + + interface ISpSREngine + { + CONST_VTBL struct ISpSREngineVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpSREngine_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpSREngine_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpSREngine_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpSREngine_SetSite(This,pSite) \ + (This)->lpVtbl -> SetSite(This,pSite) + +#define ISpSREngine_GetInputAudioFormat(This,pguidSourceFormatId,pSourceWaveFormatEx,pguidDesiredFormatId,ppCoMemDesiredWaveFormatEx) \ + (This)->lpVtbl -> GetInputAudioFormat(This,pguidSourceFormatId,pSourceWaveFormatEx,pguidDesiredFormatId,ppCoMemDesiredWaveFormatEx) + +#define ISpSREngine_RecognizeStream(This,rguidFmtId,pWaveFormatEx,hRequestSync,hDataAvailable,hExit,fNewAudioStream,fRealTimeAudio,pAudioObjectToken) \ + (This)->lpVtbl -> RecognizeStream(This,rguidFmtId,pWaveFormatEx,hRequestSync,hDataAvailable,hExit,fNewAudioStream,fRealTimeAudio,pAudioObjectToken) + +#define ISpSREngine_SetRecoProfile(This,pProfile) \ + (This)->lpVtbl -> SetRecoProfile(This,pProfile) + +#define ISpSREngine_OnCreateGrammar(This,pvEngineRecoContext,hSAPIGrammar,ppvEngineGrammarContext) \ + (This)->lpVtbl -> OnCreateGrammar(This,pvEngineRecoContext,hSAPIGrammar,ppvEngineGrammarContext) + +#define ISpSREngine_OnDeleteGrammar(This,pvEngineGrammar) \ + (This)->lpVtbl -> OnDeleteGrammar(This,pvEngineGrammar) + +#define ISpSREngine_LoadProprietaryGrammar(This,pvEngineGrammar,rguidParam,pszStringParam,pvDataParam,ulDataSize,Options) \ + (This)->lpVtbl -> LoadProprietaryGrammar(This,pvEngineGrammar,rguidParam,pszStringParam,pvDataParam,ulDataSize,Options) + +#define ISpSREngine_UnloadProprietaryGrammar(This,pvEngineGrammar) \ + (This)->lpVtbl -> UnloadProprietaryGrammar(This,pvEngineGrammar) + +#define ISpSREngine_SetProprietaryRuleState(This,pvEngineGrammar,pszName,pReserved,NewState,pcRulesChanged) \ + (This)->lpVtbl -> SetProprietaryRuleState(This,pvEngineGrammar,pszName,pReserved,NewState,pcRulesChanged) + +#define ISpSREngine_SetProprietaryRuleIdState(This,pvEngineGrammar,dwRuleId,NewState) \ + (This)->lpVtbl -> SetProprietaryRuleIdState(This,pvEngineGrammar,dwRuleId,NewState) + +#define ISpSREngine_LoadSLM(This,pvEngineGrammar,pszTopicName) \ + (This)->lpVtbl -> LoadSLM(This,pvEngineGrammar,pszTopicName) + +#define ISpSREngine_UnloadSLM(This,pvEngineGrammar) \ + (This)->lpVtbl -> UnloadSLM(This,pvEngineGrammar) + +#define ISpSREngine_SetSLMState(This,pvEngineGrammar,NewState) \ + (This)->lpVtbl -> SetSLMState(This,pvEngineGrammar,NewState) + +#define ISpSREngine_SetWordSequenceData(This,pvEngineGrammar,pText,cchText,pInfo) \ + (This)->lpVtbl -> SetWordSequenceData(This,pvEngineGrammar,pText,cchText,pInfo) + +#define ISpSREngine_SetTextSelection(This,pvEngineGrammar,pInfo) \ + (This)->lpVtbl -> SetTextSelection(This,pvEngineGrammar,pInfo) + +#define ISpSREngine_IsPronounceable(This,pvEngineGrammar,pszWord,pWordPronounceable) \ + (This)->lpVtbl -> IsPronounceable(This,pvEngineGrammar,pszWord,pWordPronounceable) + +#define ISpSREngine_OnCreateRecoContext(This,hSAPIRecoContext,ppvEngineContext) \ + (This)->lpVtbl -> OnCreateRecoContext(This,hSAPIRecoContext,ppvEngineContext) + +#define ISpSREngine_OnDeleteRecoContext(This,pvEngineContext) \ + (This)->lpVtbl -> OnDeleteRecoContext(This,pvEngineContext) + +#define ISpSREngine_PrivateCall(This,pvEngineContext,pCallFrame,ulCallFrameSize) \ + (This)->lpVtbl -> PrivateCall(This,pvEngineContext,pCallFrame,ulCallFrameSize) + +#define ISpSREngine_SetAdaptationData(This,pvEngineContext,pAdaptationData,cch) \ + (This)->lpVtbl -> SetAdaptationData(This,pvEngineContext,pAdaptationData,cch) + +#define ISpSREngine_SetPropertyNum(This,eSrc,pvSrcObj,pName,lValue) \ + (This)->lpVtbl -> SetPropertyNum(This,eSrc,pvSrcObj,pName,lValue) + +#define ISpSREngine_GetPropertyNum(This,eSrc,pvSrcObj,pName,lValue) \ + (This)->lpVtbl -> GetPropertyNum(This,eSrc,pvSrcObj,pName,lValue) + +#define ISpSREngine_SetPropertyString(This,eSrc,pvSrcObj,pName,pValue) \ + (This)->lpVtbl -> SetPropertyString(This,eSrc,pvSrcObj,pName,pValue) + +#define ISpSREngine_GetPropertyString(This,eSrc,pvSrcObj,pName,ppCoMemValue) \ + (This)->lpVtbl -> GetPropertyString(This,eSrc,pvSrcObj,pName,ppCoMemValue) + +#define ISpSREngine_SetGrammarState(This,pvEngineGrammar,eGrammarState) \ + (This)->lpVtbl -> SetGrammarState(This,pvEngineGrammar,eGrammarState) + +#define ISpSREngine_WordNotify(This,Action,cWords,pWords) \ + (This)->lpVtbl -> WordNotify(This,Action,cWords,pWords) + +#define ISpSREngine_RuleNotify(This,Action,cRules,pRules) \ + (This)->lpVtbl -> RuleNotify(This,Action,cRules,pRules) + +#define ISpSREngine_PrivateCallEx(This,pvEngineContext,pInCallFrame,ulInCallFrameSize,ppvCoMemResponse,pulResponseSize) \ + (This)->lpVtbl -> PrivateCallEx(This,pvEngineContext,pInCallFrame,ulInCallFrameSize,ppvCoMemResponse,pulResponseSize) + +#define ISpSREngine_SetContextState(This,pvEngineContext,eContextState) \ + (This)->lpVtbl -> SetContextState(This,pvEngineContext,eContextState) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpSREngine_SetSite_Proxy( + ISpSREngine * This, + /* [in] */ ISpSREngineSite *pSite); + + +void __RPC_STUB ISpSREngine_SetSite_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngine_GetInputAudioFormat_Proxy( + ISpSREngine * This, + /* [in] */ const GUID *pguidSourceFormatId, + /* [in] */ const WAVEFORMATEX *pSourceWaveFormatEx, + /* [out] */ GUID *pguidDesiredFormatId, + /* [out] */ WAVEFORMATEX **ppCoMemDesiredWaveFormatEx); + + +void __RPC_STUB ISpSREngine_GetInputAudioFormat_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngine_RecognizeStream_Proxy( + ISpSREngine * This, + /* [in] */ REFGUID rguidFmtId, + /* [in] */ const WAVEFORMATEX *pWaveFormatEx, + /* [in] */ HANDLE hRequestSync, + /* [in] */ HANDLE hDataAvailable, + /* [in] */ HANDLE hExit, + /* [in] */ BOOL fNewAudioStream, + /* [in] */ BOOL fRealTimeAudio, + /* [in] */ ISpObjectToken *pAudioObjectToken); + + +void __RPC_STUB ISpSREngine_RecognizeStream_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngine_SetRecoProfile_Proxy( + ISpSREngine * This, + ISpObjectToken *pProfile); + + +void __RPC_STUB ISpSREngine_SetRecoProfile_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngine_OnCreateGrammar_Proxy( + ISpSREngine * This, + /* [in] */ void *pvEngineRecoContext, + /* [in] */ SPGRAMMARHANDLE hSAPIGrammar, + /* [out] */ void **ppvEngineGrammarContext); + + +void __RPC_STUB ISpSREngine_OnCreateGrammar_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngine_OnDeleteGrammar_Proxy( + ISpSREngine * This, + /* [in] */ void *pvEngineGrammar); + + +void __RPC_STUB ISpSREngine_OnDeleteGrammar_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngine_LoadProprietaryGrammar_Proxy( + ISpSREngine * This, + /* [in] */ void *pvEngineGrammar, + /* [in] */ REFGUID rguidParam, + /* [string][in] */ const WCHAR *pszStringParam, + /* [in] */ const void *pvDataParam, + /* [in] */ ULONG ulDataSize, + /* [in] */ SPLOADOPTIONS Options); + + +void __RPC_STUB ISpSREngine_LoadProprietaryGrammar_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngine_UnloadProprietaryGrammar_Proxy( + ISpSREngine * This, + /* [in] */ void *pvEngineGrammar); + + +void __RPC_STUB ISpSREngine_UnloadProprietaryGrammar_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngine_SetProprietaryRuleState_Proxy( + ISpSREngine * This, + /* [in] */ void *pvEngineGrammar, + /* [string][in] */ const WCHAR *pszName, + /* [in] */ void *pReserved, + /* [in] */ SPRULESTATE NewState, + /* [out] */ ULONG *pcRulesChanged); + + +void __RPC_STUB ISpSREngine_SetProprietaryRuleState_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngine_SetProprietaryRuleIdState_Proxy( + ISpSREngine * This, + /* [in] */ void *pvEngineGrammar, + /* [in] */ DWORD dwRuleId, + /* [in] */ SPRULESTATE NewState); + + +void __RPC_STUB ISpSREngine_SetProprietaryRuleIdState_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngine_LoadSLM_Proxy( + ISpSREngine * This, + /* [in] */ void *pvEngineGrammar, + /* [string][in] */ const WCHAR *pszTopicName); + + +void __RPC_STUB ISpSREngine_LoadSLM_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngine_UnloadSLM_Proxy( + ISpSREngine * This, + /* [in] */ void *pvEngineGrammar); + + +void __RPC_STUB ISpSREngine_UnloadSLM_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngine_SetSLMState_Proxy( + ISpSREngine * This, + /* [in] */ void *pvEngineGrammar, + /* [in] */ SPRULESTATE NewState); + + +void __RPC_STUB ISpSREngine_SetSLMState_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngine_SetWordSequenceData_Proxy( + ISpSREngine * This, + /* [in] */ void *pvEngineGrammar, + /* [in] */ const WCHAR *pText, + /* [in] */ ULONG cchText, + /* [in] */ const SPTEXTSELECTIONINFO *pInfo); + + +void __RPC_STUB ISpSREngine_SetWordSequenceData_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngine_SetTextSelection_Proxy( + ISpSREngine * This, + /* [in] */ void *pvEngineGrammar, + /* [in] */ const SPTEXTSELECTIONINFO *pInfo); + + +void __RPC_STUB ISpSREngine_SetTextSelection_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngine_IsPronounceable_Proxy( + ISpSREngine * This, + /* [in] */ void *pvEngineGrammar, + /* [string][in] */ const WCHAR *pszWord, + /* [out] */ SPWORDPRONOUNCEABLE *pWordPronounceable); + + +void __RPC_STUB ISpSREngine_IsPronounceable_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngine_OnCreateRecoContext_Proxy( + ISpSREngine * This, + /* [in] */ SPRECOCONTEXTHANDLE hSAPIRecoContext, + /* [out] */ void **ppvEngineContext); + + +void __RPC_STUB ISpSREngine_OnCreateRecoContext_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngine_OnDeleteRecoContext_Proxy( + ISpSREngine * This, + /* [in] */ void *pvEngineContext); + + +void __RPC_STUB ISpSREngine_OnDeleteRecoContext_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngine_PrivateCall_Proxy( + ISpSREngine * This, + /* [in] */ void *pvEngineContext, + /* [out][in] */ PVOID pCallFrame, + /* [in] */ ULONG ulCallFrameSize); + + +void __RPC_STUB ISpSREngine_PrivateCall_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngine_SetAdaptationData_Proxy( + ISpSREngine * This, + /* [in] */ void *pvEngineContext, + const WCHAR *pAdaptationData, + const ULONG cch); + + +void __RPC_STUB ISpSREngine_SetAdaptationData_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngine_SetPropertyNum_Proxy( + ISpSREngine * This, + /* [in] */ SPPROPSRC eSrc, + /* [in] */ void *pvSrcObj, + /* [in] */ const WCHAR *pName, + /* [in] */ LONG lValue); + + +void __RPC_STUB ISpSREngine_SetPropertyNum_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngine_GetPropertyNum_Proxy( + ISpSREngine * This, + /* [in] */ SPPROPSRC eSrc, + /* [in] */ void *pvSrcObj, + /* [in] */ const WCHAR *pName, + /* [out] */ LONG *lValue); + + +void __RPC_STUB ISpSREngine_GetPropertyNum_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngine_SetPropertyString_Proxy( + ISpSREngine * This, + /* [in] */ SPPROPSRC eSrc, + /* [in] */ void *pvSrcObj, + /* [in] */ const WCHAR *pName, + /* [in] */ const WCHAR *pValue); + + +void __RPC_STUB ISpSREngine_SetPropertyString_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngine_GetPropertyString_Proxy( + ISpSREngine * This, + /* [in] */ SPPROPSRC eSrc, + /* [in] */ void *pvSrcObj, + /* [in] */ const WCHAR *pName, + /* [out] */ WCHAR **ppCoMemValue); + + +void __RPC_STUB ISpSREngine_GetPropertyString_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngine_SetGrammarState_Proxy( + ISpSREngine * This, + /* [in] */ void *pvEngineGrammar, + /* [in] */ SPGRAMMARSTATE eGrammarState); + + +void __RPC_STUB ISpSREngine_SetGrammarState_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngine_WordNotify_Proxy( + ISpSREngine * This, + SPCFGNOTIFY Action, + ULONG cWords, + const SPWORDENTRY *pWords); + + +void __RPC_STUB ISpSREngine_WordNotify_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngine_RuleNotify_Proxy( + ISpSREngine * This, + SPCFGNOTIFY Action, + ULONG cRules, + const SPRULEENTRY *pRules); + + +void __RPC_STUB ISpSREngine_RuleNotify_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngine_PrivateCallEx_Proxy( + ISpSREngine * This, + /* [in] */ void *pvEngineContext, + /* [in] */ const void *pInCallFrame, + /* [in] */ ULONG ulInCallFrameSize, + /* [out] */ void **ppvCoMemResponse, + /* [out] */ ULONG *pulResponseSize); + + +void __RPC_STUB ISpSREngine_PrivateCallEx_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSREngine_SetContextState_Proxy( + ISpSREngine * This, + /* [in] */ void *pvEngineContext, + /* [in] */ SPCONTEXTSTATE eContextState); + + +void __RPC_STUB ISpSREngine_SetContextState_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpSREngine_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_sapiddk_0352 */ +/* [local] */ + +typedef struct tagSPPHRASEALTREQUEST + { + ULONG ulStartElement; + ULONG cElements; + ULONG ulRequestAltCount; + void *pvResultExtra; + ULONG cbResultExtra; + ISpPhrase *pPhrase; + ISpRecoContext *pRecoContext; + } SPPHRASEALTREQUEST; + + + +extern RPC_IF_HANDLE __MIDL_itf_sapiddk_0352_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_sapiddk_0352_v0_0_s_ifspec; + +#ifndef __ISpSRAlternates_INTERFACE_DEFINED__ +#define __ISpSRAlternates_INTERFACE_DEFINED__ + +/* interface ISpSRAlternates */ +/* [local][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_ISpSRAlternates; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("FECE8294-2BE1-408f-8E68-2DE377092F0E") + ISpSRAlternates : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetAlternates( + /* [in] */ SPPHRASEALTREQUEST *pAltRequest, + /* [out] */ SPPHRASEALT **ppAlts, + /* [out] */ ULONG *pcAlts) = 0; + + virtual HRESULT STDMETHODCALLTYPE Commit( + /* [in] */ SPPHRASEALTREQUEST *pAltRequest, + /* [in] */ SPPHRASEALT *pAlt, + /* [out] */ void **ppvResultExtra, + /* [out] */ ULONG *pcbResultExtra) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISpSRAlternatesVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ISpSRAlternates * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ISpSRAlternates * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ISpSRAlternates * This); + + HRESULT ( STDMETHODCALLTYPE *GetAlternates )( + ISpSRAlternates * This, + /* [in] */ SPPHRASEALTREQUEST *pAltRequest, + /* [out] */ SPPHRASEALT **ppAlts, + /* [out] */ ULONG *pcAlts); + + HRESULT ( STDMETHODCALLTYPE *Commit )( + ISpSRAlternates * This, + /* [in] */ SPPHRASEALTREQUEST *pAltRequest, + /* [in] */ SPPHRASEALT *pAlt, + /* [out] */ void **ppvResultExtra, + /* [out] */ ULONG *pcbResultExtra); + + END_INTERFACE + } ISpSRAlternatesVtbl; + + interface ISpSRAlternates + { + CONST_VTBL struct ISpSRAlternatesVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISpSRAlternates_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISpSRAlternates_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISpSRAlternates_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISpSRAlternates_GetAlternates(This,pAltRequest,ppAlts,pcAlts) \ + (This)->lpVtbl -> GetAlternates(This,pAltRequest,ppAlts,pcAlts) + +#define ISpSRAlternates_Commit(This,pAltRequest,pAlt,ppvResultExtra,pcbResultExtra) \ + (This)->lpVtbl -> Commit(This,pAltRequest,pAlt,ppvResultExtra,pcbResultExtra) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE ISpSRAlternates_GetAlternates_Proxy( + ISpSRAlternates * This, + /* [in] */ SPPHRASEALTREQUEST *pAltRequest, + /* [out] */ SPPHRASEALT **ppAlts, + /* [out] */ ULONG *pcAlts); + + +void __RPC_STUB ISpSRAlternates_GetAlternates_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE ISpSRAlternates_Commit_Proxy( + ISpSRAlternates * This, + /* [in] */ SPPHRASEALTREQUEST *pAltRequest, + /* [in] */ SPPHRASEALT *pAlt, + /* [out] */ void **ppvResultExtra, + /* [out] */ ULONG *pcbResultExtra); + + +void __RPC_STUB ISpSRAlternates_Commit_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __ISpSRAlternates_INTERFACE_DEFINED__ */ + + +#ifndef ___ISpPrivateEngineCall_INTERFACE_DEFINED__ +#define ___ISpPrivateEngineCall_INTERFACE_DEFINED__ + +/* interface _ISpPrivateEngineCall */ +/* [local][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID__ISpPrivateEngineCall; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("8E7C791E-4467-11d3-9723-00C04F72DB08") + _ISpPrivateEngineCall : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE CallEngine( + /* [out][in] */ void *pCallFrame, + /* [in] */ ULONG ulCallFrameSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE CallEngineEx( + /* [in] */ const void *pInFrame, + /* [in] */ ULONG ulInFrameSize, + /* [out] */ void **ppCoMemOutFrame, + /* [out] */ ULONG *pulOutFrameSize) = 0; + + }; + +#else /* C style interface */ + + typedef struct _ISpPrivateEngineCallVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + _ISpPrivateEngineCall * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + _ISpPrivateEngineCall * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + _ISpPrivateEngineCall * This); + + HRESULT ( STDMETHODCALLTYPE *CallEngine )( + _ISpPrivateEngineCall * This, + /* [out][in] */ void *pCallFrame, + /* [in] */ ULONG ulCallFrameSize); + + HRESULT ( STDMETHODCALLTYPE *CallEngineEx )( + _ISpPrivateEngineCall * This, + /* [in] */ const void *pInFrame, + /* [in] */ ULONG ulInFrameSize, + /* [out] */ void **ppCoMemOutFrame, + /* [out] */ ULONG *pulOutFrameSize); + + END_INTERFACE + } _ISpPrivateEngineCallVtbl; + + interface _ISpPrivateEngineCall + { + CONST_VTBL struct _ISpPrivateEngineCallVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define _ISpPrivateEngineCall_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define _ISpPrivateEngineCall_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define _ISpPrivateEngineCall_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define _ISpPrivateEngineCall_CallEngine(This,pCallFrame,ulCallFrameSize) \ + (This)->lpVtbl -> CallEngine(This,pCallFrame,ulCallFrameSize) + +#define _ISpPrivateEngineCall_CallEngineEx(This,pInFrame,ulInFrameSize,ppCoMemOutFrame,pulOutFrameSize) \ + (This)->lpVtbl -> CallEngineEx(This,pInFrame,ulInFrameSize,ppCoMemOutFrame,pulOutFrameSize) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +HRESULT STDMETHODCALLTYPE _ISpPrivateEngineCall_CallEngine_Proxy( + _ISpPrivateEngineCall * This, + /* [out][in] */ void *pCallFrame, + /* [in] */ ULONG ulCallFrameSize); + + +void __RPC_STUB _ISpPrivateEngineCall_CallEngine_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE _ISpPrivateEngineCall_CallEngineEx_Proxy( + _ISpPrivateEngineCall * This, + /* [in] */ const void *pInFrame, + /* [in] */ ULONG ulInFrameSize, + /* [out] */ void **ppCoMemOutFrame, + /* [out] */ ULONG *pulOutFrameSize); + + +void __RPC_STUB _ISpPrivateEngineCall_CallEngineEx_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* ___ISpPrivateEngineCall_INTERFACE_DEFINED__ */ + + + +#ifndef __SpeechDDKLib_LIBRARY_DEFINED__ +#define __SpeechDDKLib_LIBRARY_DEFINED__ + +/* library SpeechDDKLib */ +/* [version][uuid][helpstring] */ + + +EXTERN_C const IID LIBID_SpeechDDKLib; + +EXTERN_C const CLSID CLSID_SpDataKey; + +#ifdef __cplusplus + +class DECLSPEC_UUID("D9F6EE60-58C9-458b-88E1-2F908FD7F87C") +SpDataKey; +#endif + +EXTERN_C const CLSID CLSID_SpObjectTokenEnum; + +#ifdef __cplusplus + +class DECLSPEC_UUID("3918D75F-0ACB-41f2-B733-92AA15BCECF6") +SpObjectTokenEnum; +#endif + +EXTERN_C const CLSID CLSID_SpPhraseBuilder; + +#ifdef __cplusplus + +class DECLSPEC_UUID("777B6BBD-2FF2-11d3-88FE-00C04F8EF9B5") +SpPhraseBuilder; +#endif + +EXTERN_C const CLSID CLSID_SpITNProcessor; + +#ifdef __cplusplus + +class DECLSPEC_UUID("12D73610-A1C9-11d3-BC90-00C04F72DF9F") +SpITNProcessor; +#endif + +EXTERN_C const CLSID CLSID_SpGrammarCompiler; + +#ifdef __cplusplus + +class DECLSPEC_UUID("B1E29D59-A675-11D2-8302-00C04F8EE6C0") +SpGrammarCompiler; +#endif + +EXTERN_C const CLSID CLSID_SpGramCompBackend; + +#ifdef __cplusplus + +class DECLSPEC_UUID("DA93E903-C843-11D2-A084-00C04F8EF9B5") +SpGramCompBackend; +#endif +#endif /* __SpeechDDKLib_LIBRARY_DEFINED__ */ + +/* Additional Prototypes for ALL interfaces */ + +/* end of Additional Prototypes */ + +#ifdef __cplusplus +} +#endif + +#endif + + diff --git a/speech2/third_party/sapi5/include/spcollec.h b/speech2/third_party/sapi5/include/spcollec.h new file mode 100644 index 0000000..faee643 --- /dev/null +++ b/speech2/third_party/sapi5/include/spcollec.h @@ -0,0 +1,1432 @@ +/***************************************************************************** +* SPCollec.h * +*------------* +* This header file contains the SAPI5 collection class templates. These +* are a modified version of the MFC template classes without the dependencies. +*----------------------------------------------------------------------------- +* Copyright (c) Microsoft Corporation. All rights reserved. +*****************************************************************************/ +#ifndef SPCollec_h +#define SPCollec_h + +#ifndef _INC_LIMITS +#include +#endif + +#ifndef _INC_STRING +#include +#endif + +#ifndef _INC_STDLIB +#include +#endif + +#ifndef _WIN32_WCE +#ifndef _INC_SEARCH +#include +#endif +#endif + +///////////////////////////////////////////////////////////////////////////// +#define SPASSERT_VALID( a ) // This doesn't do anything right now + +typedef void* SPLISTPOS; +typedef DWORD SPLISTHANDLE; + +#define SP_BEFORE_START_POSITION ((void*)-1L) + +inline BOOL SPIsValidAddress(const void* lp, UINT nBytes, BOOL bReadWrite) +{ + // simple version using Win-32 APIs for pointer validation. + return (lp != NULL && !IsBadReadPtr(lp, nBytes) && + (!bReadWrite || !IsBadWritePtr((LPVOID)lp, nBytes))); +} + +///////////////////////////////////////////////////////////////////////////// +// global helpers (can be overridden) +template +inline HRESULT SPConstructElements(TYPE* pElements, int nCount) +{ + HRESULT hr = S_OK; + SPDBG_ASSERT( nCount == 0 || + SPIsValidAddress( pElements, nCount * sizeof(TYPE), TRUE ) ); + + // default is bit-wise zero initialization + memset((void*)pElements, 0, nCount * sizeof(TYPE)); + return hr; +} + +template +inline void SPDestructElements(TYPE* pElements, int nCount) +{ + SPDBG_ASSERT( ( nCount == 0 || + SPIsValidAddress( pElements, nCount * sizeof(TYPE), TRUE ) ) ); + pElements; // not used + nCount; // not used + + // default does nothing +} + +template +inline HRESULT SPCopyElements(TYPE* pDest, const TYPE* pSrc, int nCount) +{ + HRESULT hr = S_OK; + SPDBG_ASSERT( ( nCount == 0 || + SPIsValidAddress( pDest, nCount * sizeof(TYPE), TRUE )) ); + SPDBG_ASSERT( ( nCount == 0 || + SPIsValidAddress( pSrc, nCount * sizeof(TYPE), FALSE )) ); + + // default is bit-wise copy + memcpy(pDest, pSrc, nCount * sizeof(TYPE)); + return hr; +} + +template +BOOL SPCompareElements(const TYPE* pElement1, const ARG_TYPE* pElement2) +{ + SPDBG_ASSERT( SPIsValidAddress( pElement1, sizeof(TYPE), FALSE ) ); + SPDBG_ASSERT( SPIsValidAddress( pElement2, sizeof(ARG_TYPE), FALSE ) ); + return *pElement1 == *pElement2; +} + +template +inline UINT SPHashKey(ARG_KEY key) +{ + // default identity hash - works for most primitive values + return ((UINT)(void*)(DWORD)key) >> 4; +} + +///////////////////////////////////////////////////////////////////////////// +// CSPPlex + +struct CSPPlex // warning variable length structure +{ + CSPPlex* pNext; + UINT nMax; + UINT nCur; + /* BYTE data[maxNum*elementSize]; */ + void* data() { return this+1; } + + static CSPPlex* PASCAL Create( CSPPlex*& pHead, UINT nMax, UINT cbElement ) + { + CSPPlex* p = (CSPPlex*) new BYTE[sizeof(CSPPlex) + nMax * cbElement]; + SPDBG_ASSERT(p); + p->nMax = nMax; + p->nCur = 0; + p->pNext = pHead; + pHead = p; // change head (adds in reverse order for simplicity) + return p; + } + + void FreeDataChain() + { + CSPPlex* p = this; + while (p != NULL) + { + BYTE* bytes = (BYTE*) p; + CSPPlex* pNext = p->pNext; + delete[] bytes; + p = pNext; + } + } +}; + + +///////////////////////////////////////////////////////////////////////////// +// CSPArray + +template +class CSPArray +{ +public: +// Construction + CSPArray(); + +// Attributes + int GetSize() const; + int GetUpperBound() const; + HRESULT SetSize(int nNewSize, int nGrowBy = -1); + +// Operations + // Clean up + void FreeExtra(); + void RemoveAll(); + + // Accessing elements + TYPE GetAt(int nIndex) const; + void SetAt(int nIndex, ARG_TYPE newElement); + TYPE& ElementAt(int nIndex); + + // Direct Access to the element data (may return NULL) + const TYPE* GetData() const; + TYPE* GetData(); + + // Potentially growing the array + HRESULT SetAtGrow(int nIndex, ARG_TYPE newElement); + int Add(ARG_TYPE newElement); + int Append(const CSPArray& src); + HRESULT Copy(const CSPArray& src); + + // overloaded operator helpers + TYPE operator[](int nIndex) const; + TYPE& operator[](int nIndex); + + // Operations that move elements around + HRESULT InsertAt(int nIndex, ARG_TYPE newElement, int nCount = 1); + void RemoveAt(int nIndex, int nCount = 1); + HRESULT InsertAt(int nStartIndex, CSPArray* pNewArray); + void Sort(int (__cdecl *compare )(const void *elem1, const void *elem2 )); + +// Implementation +protected: + TYPE* m_pData; // the actual array of data + int m_nSize; // # of elements (upperBound - 1) + int m_nMaxSize; // max allocated + int m_nGrowBy; // grow amount + +public: + ~CSPArray(); +#ifdef _DEBUG +// void Dump(CDumpContext&) const; + void AssertValid() const; +#endif +}; + +///////////////////////////////////////////////////////////////////////////// +// CSPArray inline functions + +template +inline int CSPArray::GetSize() const + { return m_nSize; } +template +inline int CSPArray::GetUpperBound() const + { return m_nSize-1; } +template +inline void CSPArray::RemoveAll() + { SetSize(0, -1); } +template +inline TYPE CSPArray::GetAt(int nIndex) const + { SPDBG_ASSERT( (nIndex >= 0 && nIndex < m_nSize) ); + return m_pData[nIndex]; } +template +inline void CSPArray::SetAt(int nIndex, ARG_TYPE newElement) + { SPDBG_ASSERT( (nIndex >= 0 && nIndex < m_nSize) ); + m_pData[nIndex] = newElement; } +template +inline TYPE& CSPArray::ElementAt(int nIndex) + { SPDBG_ASSERT( (nIndex >= 0 && nIndex < m_nSize) ); + return m_pData[nIndex]; } +template +inline const TYPE* CSPArray::GetData() const + { return (const TYPE*)m_pData; } +template +inline TYPE* CSPArray::GetData() + { return (TYPE*)m_pData; } +template +inline int CSPArray::Add(ARG_TYPE newElement) + { int nIndex = m_nSize; + SetAtGrow(nIndex, newElement); + return nIndex; } +template +inline TYPE CSPArray::operator[](int nIndex) const + { return GetAt(nIndex); } +template +inline TYPE& CSPArray::operator[](int nIndex) + { return ElementAt(nIndex); } + +///////////////////////////////////////////////////////////////////////////// +// CSPArray out-of-line functions + +template +CSPArray::CSPArray() +{ + m_pData = NULL; + m_nSize = m_nMaxSize = m_nGrowBy = 0; +} + +template +CSPArray::~CSPArray() +{ + SPASSERT_VALID( this ); + + if (m_pData != NULL) + { + SPDestructElements(m_pData, m_nSize); + delete[] (BYTE*)m_pData; + } +} + +template +HRESULT CSPArray::SetSize(int nNewSize, int nGrowBy) +{ + SPASSERT_VALID( this ); + SPDBG_ASSERT( nNewSize >= 0 ); + HRESULT hr = S_OK; + + if (nGrowBy != -1) + m_nGrowBy = nGrowBy; // set new size + + if (nNewSize == 0) + { + // shrink to nothing + if (m_pData != NULL) + { + SPDestructElements(m_pData, m_nSize); + delete[] (BYTE*)m_pData; + m_pData = NULL; + } + m_nSize = m_nMaxSize = 0; + } + else if (m_pData == NULL) + { + // create one with exact size +#ifdef SIZE_T_MAX + SPDBG_ASSERT( nNewSize <= SIZE_T_MAX/sizeof(TYPE) ); // no overflow +#endif + m_pData = (TYPE*) new BYTE[nNewSize * sizeof(TYPE)]; + if( m_pData ) + { + hr = SPConstructElements(m_pData, nNewSize); + if( SUCCEEDED( hr ) ) + { + m_nSize = m_nMaxSize = nNewSize; + } + else + { + delete[] (BYTE*)m_pData; + m_pData = NULL; + } + } + else + { + hr = E_OUTOFMEMORY; + } + } + else if (nNewSize <= m_nMaxSize) + { + // it fits + if (nNewSize > m_nSize) + { + // initialize the new elements + hr = SPConstructElements(&m_pData[m_nSize], nNewSize-m_nSize); + } + else if (m_nSize > nNewSize) + { + // destroy the old elements + SPDestructElements(&m_pData[nNewSize], m_nSize-nNewSize); + } + + if( SUCCEEDED( hr ) ) + { + m_nSize = nNewSize; + } + } + else + { + // otherwise, grow array + int nGrowBy = m_nGrowBy; + if (nGrowBy == 0) + { + // heuristically determe growth when nGrowBy == 0 + // (this avoids heap fragmentation in many situations) + nGrowBy = min(1024, max(4, m_nSize / 8)); + } + int nNewMax; + if (nNewSize < m_nMaxSize + nGrowBy) + nNewMax = m_nMaxSize + nGrowBy; // granularity + else + nNewMax = nNewSize; // no slush + + SPDBG_ASSERT( nNewMax >= m_nMaxSize ); // no wrap around +#ifdef SIZE_T_MAX + SPDBG_ASSERT( nNewMax <= SIZE_T_MAX/sizeof(TYPE) ); // no overflow +#endif + TYPE* pNewData = (TYPE*) new BYTE[nNewMax * sizeof(TYPE)]; + + if( pNewData ) + { + // copy new data from old + memcpy(pNewData, m_pData, m_nSize * sizeof(TYPE)); + + // construct remaining elements + SPDBG_ASSERT( nNewSize > m_nSize ); + hr = SPConstructElements(&pNewData[m_nSize], nNewSize-m_nSize); + + // get rid of old stuff (note: no destructors called) + delete[] (BYTE*)m_pData; + m_pData = pNewData; + m_nSize = nNewSize; + m_nMaxSize = nNewMax; + } + else + { + hr = E_OUTOFMEMORY; + } + } + return hr; +} + +template +int CSPArray::Append(const CSPArray& src) +{ + SPASSERT_VALID( this ); + SPDBG_ASSERT( this != &src ); // cannot append to itself + + int nOldSize = m_nSize; + HRESULT hr = SetSize(m_nSize + src.m_nSize); + if( SUCCEEDED( hr ) ) + { + hr = SPCopyElements(m_pData + nOldSize, src.m_pData, src.m_nSize); + } + return ( SUCCEEDED( hr ) )?(nOldSize):(-1); +} + +template +HRESULT CSPArray::Copy(const CSPArray& src) +{ + SPASSERT_VALID( this ); + SPDBG_ASSERT( this != &src ); // cannot copy to itself + + HRESULT hr = SetSize(src.m_nSize); + if( SUCCEEDED( hr ) ) + { + hr = SPCopyElements(m_pData, src.m_pData, src.m_nSize); + } + return hr; +} + +template +void CSPArray::FreeExtra() +{ + SPASSERT_VALID( this ); + + if (m_nSize != m_nMaxSize) + { + // shrink to desired size +#ifdef SIZE_T_MAX + SPDBG_ASSERT( m_nSize <= SIZE_T_MAX/sizeof(TYPE)); // no overflow +#endif + TYPE* pNewData = NULL; + if (m_nSize != 0) + { + pNewData = (TYPE*) new BYTE[m_nSize * sizeof(TYPE)]; + SPDBG_ASSERT(pNewData); + // copy new data from old + memcpy(pNewData, m_pData, m_nSize * sizeof(TYPE)); + } + + // get rid of old stuff (note: no destructors called) + delete[] (BYTE*)m_pData; + m_pData = pNewData; + m_nMaxSize = m_nSize; + } +} + +template +HRESULT CSPArray::SetAtGrow(int nIndex, ARG_TYPE newElement) +{ + SPASSERT_VALID( this ); + SPDBG_ASSERT( nIndex >= 0 ); + HRESULT hr = S_OK; + + if (nIndex >= m_nSize) + { + hr = SetSize(nIndex+1, -1); + } + + if( SUCCEEDED( hr ) ) + { + m_pData[nIndex] = newElement; + } + return hr; +} + +template +HRESULT CSPArray::InsertAt(int nIndex, ARG_TYPE newElement, int nCount /*=1*/) +{ + SPASSERT_VALID( this ); + SPDBG_ASSERT( nIndex >= 0 ); // will expand to meet need + SPDBG_ASSERT( nCount > 0 ); // zero or negative size not allowed + HRESULT hr = S_OK; + + if (nIndex >= m_nSize) + { + // adding after the end of the array + hr = SetSize(nIndex + nCount, -1); // grow so nIndex is valid + } + else + { + // inserting in the middle of the array + int nOldSize = m_nSize; + hr = SetSize(m_nSize + nCount, -1); // grow it to new size + if( SUCCEEDED( hr ) ) + { + // shift old data up to fill gap + memmove(&m_pData[nIndex+nCount], &m_pData[nIndex], + (nOldSize-nIndex) * sizeof(TYPE)); + + // re-init slots we copied from + hr = SPConstructElements(&m_pData[nIndex], nCount); + } + } + + // insert new value in the gap + if( SUCCEEDED( hr ) ) + { + SPDBG_ASSERT( nIndex + nCount <= m_nSize ); + while (nCount--) + m_pData[nIndex++] = newElement; + } + return hr; +} + +template +void CSPArray::RemoveAt(int nIndex, int nCount) +{ + SPASSERT_VALID( this ); + SPDBG_ASSERT( nIndex >= 0 ); + SPDBG_ASSERT( nCount >= 0 ); + SPDBG_ASSERT( nIndex + nCount <= m_nSize ); + + // just remove a range + int nMoveCount = m_nSize - (nIndex + nCount); + SPDestructElements(&m_pData[nIndex], nCount); + if (nMoveCount) + memcpy(&m_pData[nIndex], &m_pData[nIndex + nCount], + nMoveCount * sizeof(TYPE)); + m_nSize -= nCount; +} + +template +HRESULT CSPArray::InsertAt(int nStartIndex, CSPArray* pNewArray) +{ + SPASSERT_VALID( this ); + SPASSERT_VALID( pNewArray ); + SPDBG_ASSERT( nStartIndex >= 0 ); + HRESULT hr = S_OK; + + if (pNewArray->GetSize() > 0) + { + hr = InsertAt(nStartIndex, pNewArray->GetAt(0), pNewArray->GetSize()); + for (int i = 0; SUCCEEDED( hr )&& (i < pNewArray->GetSize()); i++) + { + SetAt(nStartIndex + i, pNewArray->GetAt(i)); + } + } + return hr; +} + +template +void CSPArray::Sort(int (__cdecl *compare )(const void *elem1, const void *elem2 )) +{ + SPASSERT_VALID( this ); + SPDBG_ASSERT( m_pData != NULL ); + + qsort( m_pData, m_nSize, sizeof(TYPE), compare ); +} + +#ifdef _DEBUG +template +void CSPArray::AssertValid() const +{ + if (m_pData == NULL) + { + SPDBG_ASSERT( m_nSize == 0 ); + SPDBG_ASSERT( m_nMaxSize == 0 ); + } + else + { + SPDBG_ASSERT( m_nSize >= 0 ); + SPDBG_ASSERT( m_nMaxSize >= 0 ); + SPDBG_ASSERT( m_nSize <= m_nMaxSize ); + SPDBG_ASSERT( SPIsValidAddress(m_pData, m_nMaxSize * sizeof(TYPE), TRUE ) ); + } +} +#endif //_DEBUG + +///////////////////////////////////////////////////////////////////////////// +// CSPList + +template +class CSPList +{ +protected: + struct CNode + { + CNode* pNext; + CNode* pPrev; + TYPE data; + }; +public: + +// Construction + CSPList(int nBlockSize = 10); + +// Attributes (head and tail) + // count of elements + int GetCount() const; + BOOL IsEmpty() const; + + // peek at head or tail + TYPE& GetHead(); + TYPE GetHead() const; + TYPE& GetTail(); + TYPE GetTail() const; + +// Operations + // get head or tail (and remove it) - don't call on empty list ! + TYPE RemoveHead(); + TYPE RemoveTail(); + + // add before head or after tail + SPLISTPOS AddHead(ARG_TYPE newElement); + SPLISTPOS AddTail(ARG_TYPE newElement); + + // add another list of elements before head or after tail + void AddHead(CSPList* pNewList); + void AddTail(CSPList* pNewList); + + // remove all elements + void RemoveAll(); + + // iteration + SPLISTPOS GetHeadPosition() const; + SPLISTPOS GetTailPosition() const; + TYPE& GetNext(SPLISTPOS& rPosition); // return *Position++ + TYPE GetNext(SPLISTPOS& rPosition) const; // return *Position++ + TYPE& GetPrev(SPLISTPOS& rPosition); // return *Position-- + TYPE GetPrev(SPLISTPOS& rPosition) const; // return *Position-- + + // getting/modifying an element at a given position + TYPE& GetAt(SPLISTPOS position); + TYPE GetAt(SPLISTPOS position) const; + void SetAt(SPLISTPOS pos, ARG_TYPE newElement); + void RemoveAt(SPLISTPOS position); + + // inserting before or after a given position + SPLISTPOS InsertBefore(SPLISTPOS position, ARG_TYPE newElement); + SPLISTPOS InsertAfter(SPLISTPOS position, ARG_TYPE newElement); + + // helper functions (note: O(n) speed) + SPLISTPOS Find(ARG_TYPE searchValue, SPLISTPOS startAfter = NULL) const; + // defaults to starting at the HEAD, return NULL if not found + SPLISTPOS FindIndex(int nIndex) const; + // get the 'nIndex'th element (may return NULL) + +// Implementation +protected: + CNode* m_pNodeHead; + CNode* m_pNodeTail; + int m_nCount; + CNode* m_pNodeFree; + struct CSPPlex* m_pBlocks; + int m_nBlockSize; + + CNode* NewNode(CNode*, CNode*); + void FreeNode(CNode*); + +public: + ~CSPList(); +#ifdef _DEBUG + void AssertValid() const; +#endif +}; + +///////////////////////////////////////////////////////////////////////////// +// CSPList inline functions + +template +inline int CSPList::GetCount() const + { return m_nCount; } +template +inline BOOL CSPList::IsEmpty() const + { return m_nCount == 0; } +template +inline TYPE& CSPList::GetHead() + { SPDBG_ASSERT( m_pNodeHead != NULL ); + return m_pNodeHead->data; } +template +inline TYPE CSPList::GetHead() const + { SPDBG_ASSERT( m_pNodeHead != NULL ); + return m_pNodeHead->data; } +template +inline TYPE& CSPList::GetTail() + { SPDBG_ASSERT( m_pNodeTail != NULL ); + return m_pNodeTail->data; } +template +inline TYPE CSPList::GetTail() const + { SPDBG_ASSERT( m_pNodeTail != NULL ); + return m_pNodeTail->data; } +template +inline SPLISTPOS CSPList::GetHeadPosition() const + { return (SPLISTPOS) m_pNodeHead; } +template +inline SPLISTPOS CSPList::GetTailPosition() const + { return (SPLISTPOS) m_pNodeTail; } +template +inline TYPE& CSPList::GetNext(SPLISTPOS& rPosition) // return *Position++ + { CNode* pNode = (CNode*) rPosition; + SPDBG_ASSERT( SPIsValidAddress(pNode, sizeof(CNode), TRUE ) ); + rPosition = (SPLISTPOS) pNode->pNext; + return pNode->data; } +template +inline TYPE CSPList::GetNext(SPLISTPOS& rPosition) const // return *Position++ + { CNode* pNode = (CNode*) rPosition; + SPDBG_ASSERT( SPIsValidAddress(pNode, sizeof(CNode), TRUE ) ); + rPosition = (SPLISTPOS) pNode->pNext; + return pNode->data; } +template +inline TYPE& CSPList::GetPrev(SPLISTPOS& rPosition) // return *Position-- + { CNode* pNode = (CNode*) rPosition; + SPDBG_ASSERT( SPIsValidAddress(pNode, sizeof(CNode), TRUE ) ); + rPosition = (SPLISTPOS) pNode->pPrev; + return pNode->data; } +template +inline TYPE CSPList::GetPrev(SPLISTPOS& rPosition) const // return *Position-- + { CNode* pNode = (CNode*) rPosition; + SPDBG_ASSERT( SPIsValidAddress(pNode, sizeof(CNode), TRUE ) ); + rPosition = (SPLISTPOS) pNode->pPrev; + return pNode->data; } +template +inline TYPE& CSPList::GetAt(SPLISTPOS position) + { CNode* pNode = (CNode*) position; + SPDBG_ASSERT( SPIsValidAddress(pNode, sizeof(CNode), TRUE ) ); + return pNode->data; } +template +inline TYPE CSPList::GetAt(SPLISTPOS position) const + { CNode* pNode = (CNode*) position; + SPDBG_ASSERT( SPIsValidAddress(pNode, sizeof(CNode), TRUE ) ); + return pNode->data; } +template +inline void CSPList::SetAt(SPLISTPOS pos, ARG_TYPE newElement) + { CNode* pNode = (CNode*) pos; + SPDBG_ASSERT( SPIsValidAddress(pNode, sizeof(CNode), TRUE ) ); + pNode->data = newElement; } + +///////////////////////////////////////////////////////////////////////////// +// CSPList out-of-line functions + +template +CSPList::CSPList( int nBlockSize ) +{ + SPDBG_ASSERT( nBlockSize > 0 ); + + m_nCount = 0; + m_pNodeHead = m_pNodeTail = m_pNodeFree = NULL; + m_pBlocks = NULL; + m_nBlockSize = nBlockSize; +} + +template +void CSPList::RemoveAll() +{ + SPASSERT_VALID( this ); + + // destroy elements + CNode* pNode; + for (pNode = m_pNodeHead; pNode != NULL; pNode = pNode->pNext) + SPDestructElements(&pNode->data, 1); + + m_nCount = 0; + m_pNodeHead = m_pNodeTail = m_pNodeFree = NULL; + m_pBlocks->FreeDataChain(); + m_pBlocks = NULL; +} + +template +CSPList::~CSPList() +{ + RemoveAll(); + SPDBG_ASSERT( m_nCount == 0 ); +} + +///////////////////////////////////////////////////////////////////////////// +// Node helpers +// +// Implementation note: CNode's are stored in CSPPlex blocks and +// chained together. Free blocks are maintained in a singly linked list +// using the 'pNext' member of CNode with 'm_pNodeFree' as the head. +// Used blocks are maintained in a doubly linked list using both 'pNext' +// and 'pPrev' as links and 'm_pNodeHead' and 'm_pNodeTail' +// as the head/tail. +// +// We never free a CSPPlex block unless the List is destroyed or RemoveAll() +// is used - so the total number of CSPPlex blocks may grow large depending +// on the maximum past size of the list. +// + +template +CSPList::CNode* +CSPList::NewNode(CSPList::CNode* pPrev, CSPList::CNode* pNext) +{ + if (m_pNodeFree == NULL) + { + // add another block + CSPPlex* pNewBlock = CSPPlex::Create(m_pBlocks, m_nBlockSize,sizeof(CNode)); + + // chain them into free list + CNode* pNode = (CNode*) pNewBlock->data(); + // free in reverse order to make it easier to debug + pNode += m_nBlockSize - 1; + for (int i = m_nBlockSize-1; i >= 0; i--, pNode--) + { + pNode->pNext = m_pNodeFree; + m_pNodeFree = pNode; + } + } + + CSPList::CNode* pNode = m_pNodeFree; + if( pNode ) + { + if( SUCCEEDED( SPConstructElements(&pNode->data, 1) ) ) + { + m_pNodeFree = m_pNodeFree->pNext; + pNode->pPrev = pPrev; + pNode->pNext = pNext; + m_nCount++; + SPDBG_ASSERT( m_nCount > 0 ); // make sure we don't overflow + } + } + return pNode; +} + +template +void CSPList::FreeNode(CSPList::CNode* pNode) +{ + SPDestructElements(&pNode->data, 1); + pNode->pNext = m_pNodeFree; + m_pNodeFree = pNode; + m_nCount--; + SPDBG_ASSERT( m_nCount >= 0 ); // make sure we don't underflow +} + +template +SPLISTPOS CSPList::AddHead(ARG_TYPE newElement) +{ + SPASSERT_VALID( this ); + + CNode* pNewNode = NewNode(NULL, m_pNodeHead); + if( pNewNode ) + { + pNewNode->data = newElement; + if (m_pNodeHead != NULL) + m_pNodeHead->pPrev = pNewNode; + else + m_pNodeTail = pNewNode; + m_pNodeHead = pNewNode; + } + return (SPLISTPOS) pNewNode; +} + +template +SPLISTPOS CSPList::AddTail(ARG_TYPE newElement) +{ + SPASSERT_VALID( this ); + + CNode* pNewNode = NewNode(m_pNodeTail, NULL); + if( pNewNode ) + { + pNewNode->data = newElement; + if (m_pNodeTail != NULL) + m_pNodeTail->pNext = pNewNode; + else + m_pNodeHead = pNewNode; + m_pNodeTail = pNewNode; + } + return (SPLISTPOS) pNewNode; +} + +template +void CSPList::AddHead(CSPList* pNewList) +{ + SPASSERT_VALID( this ); + SPASSERT_VALID( pNewList ); + + // add a list of same elements to head (maintain order) + SPLISTPOS pos = pNewList->GetTailPosition(); + while (pos != NULL) + AddHead(pNewList->GetPrev(pos)); +} + +template +void CSPList::AddTail(CSPList* pNewList) +{ + SPASSERT_VALID( this ); + SPASSERT_VALID( pNewList ); + + // add a list of same elements + SPLISTPOS pos = pNewList->GetHeadPosition(); + while (pos != NULL) + AddTail(pNewList->GetNext(pos)); +} + +template +TYPE CSPList::RemoveHead() +{ + SPASSERT_VALID( this ); + SPDBG_ASSERT( m_pNodeHead != NULL ); // don't call on empty list !!! + SPDBG_ASSERT( SPIsValidAddress(m_pNodeHead, sizeof(CNode), TRUE ) ); + + CNode* pOldNode = m_pNodeHead; + TYPE returnValue = pOldNode->data; + + m_pNodeHead = pOldNode->pNext; + if (m_pNodeHead != NULL) + m_pNodeHead->pPrev = NULL; + else + m_pNodeTail = NULL; + FreeNode(pOldNode); + return returnValue; +} + +template +TYPE CSPList::RemoveTail() +{ + SPASSERT_VALID( this ); + SPDBG_ASSERT( m_pNodeTail != NULL ); // don't call on empty list !!! + SPDBG_ASSERT( SPIsValidAddress(m_pNodeTail, sizeof(CNode), TRUE ) ); + + CNode* pOldNode = m_pNodeTail; + TYPE returnValue = pOldNode->data; + + m_pNodeTail = pOldNode->pPrev; + if (m_pNodeTail != NULL) + m_pNodeTail->pNext = NULL; + else + m_pNodeHead = NULL; + FreeNode(pOldNode); + return returnValue; +} + +template +SPLISTPOS CSPList::InsertBefore(SPLISTPOS position, ARG_TYPE newElement) +{ + SPASSERT_VALID( this ); + + if (position == NULL) + return AddHead(newElement); // insert before nothing -> head of the list + + // Insert it before position + CNode* pOldNode = (CNode*) position; + CNode* pNewNode = NewNode(pOldNode->pPrev, pOldNode); + if( pNewNode ) + { + pNewNode->data = newElement; + + if (pOldNode->pPrev != NULL) + { + SPDBG_ASSERT( SPIsValidAddress(pOldNode->pPrev, sizeof(CNode), TRUE ) ); + pOldNode->pPrev->pNext = pNewNode; + } + else + { + SPDBG_ASSERT( pOldNode == m_pNodeHead ); + m_pNodeHead = pNewNode; + } + pOldNode->pPrev = pNewNode; + } + return (SPLISTPOS) pNewNode; +} + +template +SPLISTPOS CSPList::InsertAfter(SPLISTPOS position, ARG_TYPE newElement) +{ + SPASSERT_VALID( this ); + + if (position == NULL) + return AddTail(newElement); // insert after nothing -> tail of the list + + // Insert it before position + CNode* pOldNode = (CNode*) position; + SPDBG_ASSERT( SPIsValidAddress(pOldNode, sizeof(CNode), TRUE )); + CNode* pNewNode = NewNode(pOldNode, pOldNode->pNext); + if( pNewNode ) + { + pNewNode->data = newElement; + + if (pOldNode->pNext != NULL) + { + SPDBG_ASSERT( SPIsValidAddress(pOldNode->pNext, sizeof(CNode), TRUE )); + pOldNode->pNext->pPrev = pNewNode; + } + else + { + SPDBG_ASSERT( pOldNode == m_pNodeTail ); + m_pNodeTail = pNewNode; + } + pOldNode->pNext = pNewNode; + } + return (SPLISTPOS) pNewNode; +} + +template +void CSPList::RemoveAt(SPLISTPOS position) +{ + SPASSERT_VALID( this ); + + CNode* pOldNode = (CNode*) position; + SPDBG_ASSERT( SPIsValidAddress(pOldNode, sizeof(CNode), TRUE ) ); + + // remove pOldNode from list + if (pOldNode == m_pNodeHead) + { + m_pNodeHead = pOldNode->pNext; + } + else + { + SPDBG_ASSERT( SPIsValidAddress(pOldNode->pPrev, sizeof(CNode), TRUE ) ); + pOldNode->pPrev->pNext = pOldNode->pNext; + } + if (pOldNode == m_pNodeTail) + { + m_pNodeTail = pOldNode->pPrev; + } + else + { + SPDBG_ASSERT( SPIsValidAddress(pOldNode->pNext, sizeof(CNode), TRUE ) ); + pOldNode->pNext->pPrev = pOldNode->pPrev; + } + FreeNode(pOldNode); +} + +template +SPLISTPOS CSPList::FindIndex(int nIndex) const +{ + SPASSERT_VALID( this ); + SPDBG_ASSERT( nIndex >= 0 ); + + if (nIndex >= m_nCount) + return NULL; // went too far + + CNode* pNode = m_pNodeHead; + while (nIndex--) + { + SPDBG_ASSERT( SPIsValidAddress(pNode, sizeof(CNode), TRUE )); + pNode = pNode->pNext; + } + return (SPLISTPOS) pNode; +} + +template +SPLISTPOS CSPList::Find(ARG_TYPE searchValue, SPLISTPOS startAfter) const +{ + SPASSERT_VALID( this ); + + CNode* pNode = (CNode*) startAfter; + if (pNode == NULL) + { + pNode = m_pNodeHead; // start at head + } + else + { + SPDBG_ASSERT( SPIsValidAddress(pNode, sizeof(CNode), TRUE ) ); + pNode = pNode->pNext; // start after the one specified + } + + for (; pNode != NULL; pNode = pNode->pNext) + if (SPCompareElements(&pNode->data, &searchValue)) + return (SPLISTPOS)pNode; + return NULL; +} + +#ifdef _DEBUG +template +void CSPList::AssertValid() const +{ + if (m_nCount == 0) + { + // empty list + SPDBG_ASSERT( m_pNodeHead == NULL ); + SPDBG_ASSERT( m_pNodeTail == NULL ); + } + else + { + // non-empty list + SPDBG_ASSERT( SPIsValidAddress(m_pNodeHead, sizeof(CNode), TRUE )); + SPDBG_ASSERT( SPIsValidAddress(m_pNodeTail, sizeof(CNode), TRUE )); + } +} +#endif //_DEBUG + +///////////////////////////////////////////////////////////////////////////// +// CSPMap + +template +class CSPMap +{ +protected: + // Association + struct CAssoc + { + CAssoc* pNext; + UINT nHashValue; // needed for efficient iteration + KEY key; + VALUE value; + }; +public: +// Construction + CSPMap( int nBlockSize = 10 ); + +// Attributes + // number of elements + int GetCount() const; + BOOL IsEmpty() const; + + // Lookup + BOOL Lookup(ARG_KEY key, VALUE& rValue) const; + +// Operations + // Lookup and add if not there + VALUE& operator[](ARG_KEY key); + + // add a new (key, value) pair + void SetAt(ARG_KEY key, ARG_VALUE newValue); + + // removing existing (key, ?) pair + BOOL RemoveKey(ARG_KEY key); + void RemoveAll(); + + // iterating all (key, value) pairs + SPLISTPOS GetStartPosition() const; + void GetNextAssoc(SPLISTPOS& rNextPosition, KEY& rKey, VALUE& rValue) const; + + // advanced features for derived classes + UINT GetHashTableSize() const; + HRESULT InitHashTable(UINT hashSize, BOOL bAllocNow = TRUE); + +// Implementation +protected: + CAssoc** m_pHashTable; + UINT m_nHashTableSize; + int m_nCount; + CAssoc* m_pFreeList; + struct CSPPlex* m_pBlocks; + int m_nBlockSize; + + CAssoc* NewAssoc(); + void FreeAssoc(CAssoc*); + CAssoc* GetAssocAt(ARG_KEY, UINT&) const; + +public: + ~CSPMap(); +#ifdef _DEBUG +// void Dump(CDumpContext&) const; + void AssertValid() const; +#endif +}; + +///////////////////////////////////////////////////////////////////////////// +// CSPMap inline functions + +template +inline int CSPMap::GetCount() const + { return m_nCount; } +template +inline BOOL CSPMap::IsEmpty() const + { return m_nCount == 0; } +template +inline void CSPMap::SetAt(ARG_KEY key, ARG_VALUE newValue) + { (*this)[key] = newValue; } +template +inline SPLISTPOS CSPMap::GetStartPosition() const + { return (m_nCount == 0) ? NULL : SP_BEFORE_START_POSITION; } +template +inline UINT CSPMap::GetHashTableSize() const + { return m_nHashTableSize; } + +///////////////////////////////////////////////////////////////////////////// +// CSPMap out-of-line functions + +template +CSPMap::CSPMap( int nBlockSize ) +{ + SPDBG_ASSERT( nBlockSize > 0 ); + + m_pHashTable = NULL; + m_nHashTableSize = 17; // default size + m_nCount = 0; + m_pFreeList = NULL; + m_pBlocks = NULL; + m_nBlockSize = nBlockSize; +} + +template +HRESULT CSPMap::InitHashTable( + UINT nHashSize, BOOL bAllocNow) +// +// Used to force allocation of a hash table or to override the default +// hash table size of (which is fairly small) +{ + SPASSERT_VALID( this ); + SPDBG_ASSERT( m_nCount == 0 ); + SPDBG_ASSERT( nHashSize > 0 ); + HRESULT hr = S_OK; + + if (m_pHashTable != NULL) + { + // free hash table + delete[] m_pHashTable; + m_pHashTable = NULL; + } + + if (bAllocNow) + { + m_pHashTable = new CAssoc* [nHashSize]; + if( m_pHashTable ) + { + memset(m_pHashTable, 0, sizeof(CAssoc*) * nHashSize); + } + else + { + hr = E_OUTOFMEMORY; + } + } + + m_nHashTableSize = ( SUCCEEDED( hr ) )?(nHashSize):(0); + return hr; +} + +template +void CSPMap::RemoveAll() +{ + SPASSERT_VALID( this ); + + if (m_pHashTable != NULL) + { + // destroy elements (values and keys) + for (UINT nHash = 0; nHash < m_nHashTableSize; nHash++) + { + CAssoc* pAssoc; + for( pAssoc = m_pHashTable[nHash]; pAssoc != NULL; + pAssoc = pAssoc->pNext) + { + SPDestructElements(&pAssoc->value, 1); + SPDestructElements(&pAssoc->key, 1); + } + } + } + + // free hash table + delete[] m_pHashTable; + m_pHashTable = NULL; + + m_nCount = 0; + m_pFreeList = NULL; + m_pBlocks->FreeDataChain(); + m_pBlocks = NULL; +} + +template +CSPMap::~CSPMap() +{ + RemoveAll(); + SPDBG_ASSERT( m_nCount == 0 ); +} + +template +CSPMap::CAssoc* +CSPMap::NewAssoc() +{ + if (m_pFreeList == NULL) + { + // add another block + CSPPlex* newBlock = CSPPlex::Create(m_pBlocks, m_nBlockSize, sizeof(CSPMap::CAssoc)); + + if( newBlock ) + { + // chain them into free list + CSPMap::CAssoc* pAssoc = (CSPMap::CAssoc*) newBlock->data(); + // free in reverse order to make it easier to debug + pAssoc += m_nBlockSize - 1; + for (int i = m_nBlockSize-1; i >= 0; i--, pAssoc--) + { + pAssoc->pNext = m_pFreeList; + m_pFreeList = pAssoc; + } + } + } + + CSPMap::CAssoc* pAssoc = m_pFreeList; + if( pAssoc ) + { + if( SUCCEEDED( SPConstructElements(&pAssoc->key, 1 ) ) ) + { + if( SUCCEEDED( SPConstructElements(&pAssoc->value, 1 ) ) ) + { + m_pFreeList = m_pFreeList->pNext; + m_nCount++; + SPDBG_ASSERT( m_nCount > 0 ); // make sure we don't overflow + } + else + { + SPDestructElements( &pAssoc->key, 1 ); + } + } + else + { + pAssoc = NULL; + } + } + return pAssoc; +} + +template +void CSPMap::FreeAssoc(CSPMap::CAssoc* pAssoc) +{ + SPDestructElements(&pAssoc->value, 1); + SPDestructElements(&pAssoc->key, 1); + pAssoc->pNext = m_pFreeList; + m_pFreeList = pAssoc; + m_nCount--; + SPDBG_ASSERT( m_nCount >= 0 ); // make sure we don't underflow +} + +template +CSPMap::CAssoc* +CSPMap::GetAssocAt(ARG_KEY key, UINT& nHash) const +// find association (or return NULL) +{ + nHash = SPHashKey(key) % m_nHashTableSize; + + if (m_pHashTable == NULL) + return NULL; + + // see if it exists + CAssoc* pAssoc; + for (pAssoc = m_pHashTable[nHash]; pAssoc != NULL; pAssoc = pAssoc->pNext) + { + if (SPCompareElements(&pAssoc->key, &key)) + return pAssoc; + } + return NULL; +} + +template +BOOL CSPMap::Lookup(ARG_KEY key, VALUE& rValue) const +{ + SPASSERT_VALID( this ); + + UINT nHash; + CAssoc* pAssoc = GetAssocAt(key, nHash); + if (pAssoc == NULL) + return FALSE; // not in map + + rValue = pAssoc->value; + return TRUE; +} + +template +VALUE& CSPMap::operator[](ARG_KEY key) +{ + SPASSERT_VALID( this ); + HRESULT hr = S_OK; + static const CAssoc ErrAssoc = 0; + + UINT nHash; + CAssoc* pAssoc; + if ((pAssoc = GetAssocAt(key, nHash)) == NULL) + { + if( m_pHashTable == NULL ) + { + hr = InitHashTable(m_nHashTableSize); + } + + if( SUCCEEDED( hr ) ) + { + // it doesn't exist, add a new Association + pAssoc = NewAssoc(); + if( pAssoc ) + { + pAssoc->nHashValue = nHash; + pAssoc->key = key; + // 'pAssoc->value' is a constructed object, nothing more + + // put into hash table + pAssoc->pNext = m_pHashTable[nHash]; + m_pHashTable[nHash] = pAssoc; + } + else + { + pAssoc = &ErrAssoc; + } + } + } + return pAssoc->value; // return new reference +} + +template +BOOL CSPMap::RemoveKey(ARG_KEY key) +// remove key - return TRUE if removed +{ + SPASSERT_VALID( this ); + + if (m_pHashTable == NULL) + return FALSE; // nothing in the table + + CAssoc** ppAssocPrev; + ppAssocPrev = &m_pHashTable[SPHashKey(key) % m_nHashTableSize]; + + CAssoc* pAssoc; + for (pAssoc = *ppAssocPrev; pAssoc != NULL; pAssoc = pAssoc->pNext) + { + if (SPCompareElements(&pAssoc->key, &key)) + { + // remove it + *ppAssocPrev = pAssoc->pNext; // remove from list + FreeAssoc(pAssoc); + return TRUE; + } + ppAssocPrev = &pAssoc->pNext; + } + return FALSE; // not found +} + +template +void CSPMap::GetNextAssoc(SPLISTPOS& rNextPosition, + KEY& rKey, VALUE& rValue) const +{ + SPASSERT_VALID( this ); + SPDBG_ASSERT( m_pHashTable != NULL ); // never call on empty map + + CAssoc* pAssocRet = (CAssoc*)rNextPosition; + SPDBG_ASSERT( pAssocRet != NULL ); + + if (pAssocRet == (CAssoc*) SP_BEFORE_START_POSITION) + { + // find the first association + for (UINT nBucket = 0; nBucket < m_nHashTableSize; nBucket++) + if ((pAssocRet = m_pHashTable[nBucket]) != NULL) + break; + SPDBG_ASSERT( pAssocRet != NULL ); // must find something + } + + // find next association + SPDBG_ASSERT( SPIsValidAddress(pAssocRet, sizeof(CAssoc), TRUE )); + CAssoc* pAssocNext; + if ((pAssocNext = pAssocRet->pNext) == NULL) + { + // go to next bucket + for (UINT nBucket = pAssocRet->nHashValue + 1; + nBucket < m_nHashTableSize; nBucket++) + if ((pAssocNext = m_pHashTable[nBucket]) != NULL) + break; + } + + rNextPosition = (SPLISTPOS) pAssocNext; + + // fill in return data + rKey = pAssocRet->key; + rValue = pAssocRet->value; +} + +#ifdef _DEBUG +template +void CSPMap::AssertValid() const +{ + SPDBG_ASSERT( m_nHashTableSize > 0 ); + SPDBG_ASSERT( (m_nCount == 0 || m_pHashTable != NULL) ); + // non-empty map should have hash table +} +#endif //_DEBUG + +#endif //--- This must be the last line in the file diff --git a/speech2/third_party/sapi5/include/spdebug.h b/speech2/third_party/sapi5/include/spdebug.h new file mode 100644 index 0000000..da9a7ee --- /dev/null +++ b/speech2/third_party/sapi5/include/spdebug.h @@ -0,0 +1,636 @@ +/******************************************************************************* +* SPDebug.h * +*-----------* +* Description: +* This header file contains debug output services for SAPI5 +*------------------------------------------------------------------------------- +* Copyright (c) Microsoft Corporation. All rights reserved. +*******************************************************************************/ + +#pragma once + +#include +#include + +#ifdef ASSERT_WITH_STACK +#include "AssertWithStack.h" +#endif + +const TCHAR g_szSpDebugKey[] = _T("SPDebug"); +const TCHAR g_szSpDebugFuncTraceReportMode[] = _T("FuncTraceMode"); +const TCHAR g_szSpDebugFuncTraceReportFile[] = _T("FuncTraceFile"); +const TCHAR g_szSpDebugParamInfoReportMode[] = _T("ParamInfoMode"); +const TCHAR g_szSpDebugParamInfoReportFile[] = _T("ParamInfoFile"); +const TCHAR g_szSpDebugDumpInfoReportMode[] = _T("DumpInfoMode"); +const TCHAR g_szSpDebugDumpInfoReportFile[] = _T("DumpInfoFile"); +const TCHAR g_szSpDebugAssertReportMode[] = _T("AssertMode"); +const TCHAR g_szSpDebugAssertReportFile[] = _T("AssertFile"); +const TCHAR g_szSpDebugHRFailReportMode[] = _T("HRFailMode"); +const TCHAR g_szSpDebugHRFailReportFile[] = _T("HRFailFile"); + +const TCHAR g_szSpDebugAssertSettingsReReadEachTime[] = _T("AssertSettingsReReadEachTime"); +const TCHAR g_szSpDebugServerOnStart[] = _T("DebugServerOnStart"); +const TCHAR g_szSpDebugClientOnStart[] = _T("DebugClientOnStart"); + +const TCHAR g_szSpDebugLog[] = _T("c:\\spdebug.log"); + +#ifdef _DEBUG + +class CSpDebug +{ +public: + + CSpDebug() + { + m_mutex = NULL; + m_reportModePrev = -1; + m_hfilePrev = NULL; + Read(); + } + + ~CSpDebug() + { + if (m_mutex != NULL) + { + CloseHandle(m_mutex); + } + } + + BOOL FuncTrace(BOOL fEnter = TRUE) + { + return fEnter + ? Enter(_CRT_WARN, m_FuncTraceMode, m_szFuncTraceFile) + : Leave(); + } + + BOOL ParamInfo(BOOL fEnter = TRUE) + { + return fEnter + ? Enter(_CRT_WARN, m_ParamInfoMode, m_szParamInfoFile) + : Leave(); + } + + BOOL DumpInfo(BOOL fEnter = TRUE) + { + return fEnter + ? Enter(_CRT_WARN, m_DumpInfoMode, m_szDumpInfoFile) + : Leave(); + } + + BOOL Assert(BOOL fEnter = TRUE) + { + if (m_fAssertSettingsReReadEachTime) + Read(); + + return fEnter + ? Enter(_CRT_ASSERT, m_AssertMode, m_szAssertFile) + : Leave(); + } + + BOOL HRFail(BOOL fEnter = TRUE) + { + return fEnter + ? Enter(_CRT_WARN, m_HRFailMode, m_szHRFailFile) + : Leave(); + } + + BOOL DebugServerOnStart() + { + return m_fDebugServerOnStart; + } + + BOOL DebugClientOnStart() + { + return m_fDebugClientOnStart; + } + +private: + + void Read() + { + HKEY hkeyDebug; + RegCreateKeyEx( + HKEY_CLASSES_ROOT, + g_szSpDebugKey, + 0, + NULL, + 0, + KEY_READ | KEY_WRITE, + NULL, + &hkeyDebug, + NULL); + if (hkeyDebug == NULL) + { + RegCreateKeyEx( + HKEY_CLASSES_ROOT, + g_szSpDebugKey, + 0, + NULL, + 0, + KEY_READ, + NULL, + &hkeyDebug, + NULL); + } + + DWORD dw = sizeof(m_fAssertSettingsReReadEachTime); + if (RegQueryValueEx( + hkeyDebug, + g_szSpDebugAssertSettingsReReadEachTime, + NULL, + NULL, + LPBYTE(&m_fAssertSettingsReReadEachTime), + &dw) != ERROR_SUCCESS) + { + m_fAssertSettingsReReadEachTime = FALSE; + RegSetValueEx( + hkeyDebug, + g_szSpDebugAssertSettingsReReadEachTime, + NULL, + REG_DWORD, + LPBYTE(&m_fAssertSettingsReReadEachTime), + sizeof(m_fAssertSettingsReReadEachTime)); + } + + ReadFor( + hkeyDebug, + g_szSpDebugFuncTraceReportMode, + g_szSpDebugFuncTraceReportFile, + &m_FuncTraceMode, + m_szFuncTraceFile, + 0, + g_szSpDebugLog); + ReadFor( + hkeyDebug, + g_szSpDebugParamInfoReportMode, + g_szSpDebugParamInfoReportFile, + &m_ParamInfoMode, + m_szParamInfoFile, + 0, + g_szSpDebugLog); + ReadFor( + hkeyDebug, + g_szSpDebugDumpInfoReportMode, + g_szSpDebugDumpInfoReportFile, + &m_DumpInfoMode, + m_szDumpInfoFile, + _CRTDBG_MODE_DEBUG, + g_szSpDebugLog); + ReadFor( + hkeyDebug, + g_szSpDebugAssertReportMode, + g_szSpDebugAssertReportFile, + &m_AssertMode, + m_szAssertFile, + _CRTDBG_MODE_WNDW, + g_szSpDebugLog); + ReadFor( + hkeyDebug, + g_szSpDebugHRFailReportMode, + g_szSpDebugHRFailReportFile, + &m_HRFailMode, + m_szHRFailFile, + _CRTDBG_MODE_DEBUG, + g_szSpDebugLog); + + dw = sizeof(m_fDebugServerOnStart); + if (RegQueryValueEx( + hkeyDebug, + g_szSpDebugServerOnStart, + NULL, + NULL, + LPBYTE(&m_fDebugServerOnStart), + &dw) != ERROR_SUCCESS) + { + m_fDebugServerOnStart = FALSE; + RegSetValueEx( + hkeyDebug, + g_szSpDebugServerOnStart, + NULL, + REG_DWORD, + LPBYTE(&m_fDebugServerOnStart), + sizeof(m_fDebugServerOnStart)); + } + + dw = sizeof(m_fDebugClientOnStart); + if (RegQueryValueEx( + hkeyDebug, + g_szSpDebugClientOnStart, + NULL, + NULL, + LPBYTE(&m_fDebugClientOnStart), + &dw) != ERROR_SUCCESS) + { + m_fDebugClientOnStart = FALSE; + RegSetValueEx( + hkeyDebug, + g_szSpDebugClientOnStart, + NULL, + REG_DWORD, + LPBYTE(&m_fDebugClientOnStart), + sizeof(m_fDebugClientOnStart)); + } + + RegCloseKey(hkeyDebug); + } + + void ReadFor( + HKEY hkey, + const TCHAR * pszModeValueName, + const TCHAR * pszFileValueName, + DWORD * pdwModeValue, + TCHAR * pszFileValue, + DWORD dwDefaultModeValue, + const TCHAR * pszDefaultFileValue) + { + DWORD dw = sizeof(*pdwModeValue); + if (RegQueryValueEx( + hkey, + pszModeValueName, + NULL, + NULL, + LPBYTE(pdwModeValue), + &dw) != ERROR_SUCCESS) + { + *pdwModeValue = dwDefaultModeValue; + RegSetValueEx( + hkey, + pszModeValueName, + NULL, + REG_DWORD, + LPBYTE(pdwModeValue), + sizeof(*pdwModeValue)); + } + + dw = MAX_PATH; + if (RegQueryValueEx( + hkey, + pszFileValueName, + NULL, + NULL, + LPBYTE(pszFileValue), + &dw) != ERROR_SUCCESS) + { + _tcscpy(pszFileValue, pszDefaultFileValue); + RegSetValueEx( + hkey, + pszFileValueName, + NULL, + REG_SZ, + LPBYTE(pszFileValue), + MAX_PATH); + } + } + + BOOL Enter(int reportType, DWORD &reportMode, TCHAR * pszFile) + { + if (reportMode != 0) + { + // We'll hold the mutex, until the caller also calls Leave + if (m_mutex == NULL) + { + m_mutex = CreateMutex(NULL, FALSE, _T("SpDebug")); + } + WaitForSingleObject(m_mutex, INFINITE); + + m_reportType = reportType; + m_reportModePrev = _CrtSetReportMode(reportType, reportMode); + if (reportMode & _CRTDBG_MODE_FILE) + { + HANDLE hfile = CreateFile( + pszFile, + GENERIC_READ | GENERIC_WRITE, + FILE_SHARE_READ, + NULL, + OPEN_ALWAYS, + 0, + NULL); + SetFilePointer(hfile, 0, NULL, FILE_END); + m_hfilePrev = (_HFILE)_CrtSetReportFile(reportType, (_HFILE)hfile); + } + + return TRUE; + } + + return FALSE; + } + + BOOL Leave() + { + int reportMode = _CrtSetReportMode(m_reportType, m_reportModePrev); + if (reportMode & _CRTDBG_MODE_FILE) + { + CloseHandle((_HFILE)_CrtSetReportFile(m_reportType, (_HFILE)m_hfilePrev)); + } + + ReleaseMutex(m_mutex); + + return TRUE; + } + +private: + + HANDLE m_mutex; + + int m_reportType; + int m_reportModePrev; + _HFILE m_hfilePrev; + + BOOL m_fAssertSettingsReReadEachTime; + + DWORD m_FuncTraceMode; + TCHAR m_szFuncTraceFile[MAX_PATH + 1]; + DWORD m_ParamInfoMode; + TCHAR m_szParamInfoFile[MAX_PATH + 1]; + DWORD m_DumpInfoMode; + TCHAR m_szDumpInfoFile[MAX_PATH + 1]; + DWORD m_AssertMode; + TCHAR m_szAssertFile[MAX_PATH + 1]; + DWORD m_HRFailMode; + TCHAR m_szHRFailFile[MAX_PATH + 1]; + + BOOL m_fDebugServerOnStart; + BOOL m_fDebugClientOnStart; +}; + +inline CSpDebug *PSpDebug() +{ + static CSpDebug debug; + return &debug; +} + +class CSpFuncTrace +{ +public: + + CSpFuncTrace(PCHAR pFuncName) + { + m_pFuncName = pFuncName; + if (PSpDebug()->FuncTrace()) + { + _RPT1( _CRT_WARN, "\nEntering Function: %s\n", m_pFuncName ); + PSpDebug()->FuncTrace(FALSE); + } + } + + ~CSpFuncTrace() + { + if (PSpDebug()->FuncTrace()) + { + _RPT1( _CRT_WARN, "Leaving Function: %s\n", m_pFuncName ); + PSpDebug()->FuncTrace(FALSE); + } + } + +private: + + PCHAR m_pFuncName; +}; + +#endif // _DEBUG + +//=== User macros ============================================================== + +#ifdef _DEBUG + +#define SPDBG_FUNC(name) \ + CSpFuncTrace functrace(name) + +#if defined(ASSERT_WITH_STACK) && !defined(_WIN64) +#define SPDBG_REPORT_ON_FAIL(hr) \ + do \ + { \ + HRESULT _hr = (hr); \ + if (FAILED(_hr) && PSpDebug()->HRFail()) \ + { \ + SYSTEMTIME sysTime; \ + GetLocalTime(&sysTime); \ + CHAR pszHrWithTime[100]; \ + sprintf(pszHrWithTime, "%lX\n\n%d.%d.%d %02d:%02d:%02d", \ + _hr, \ + sysTime.wMonth,sysTime.wDay,sysTime.wYear, \ + sysTime.wHour,sysTime.wMinute,sysTime.wSecond); \ + PCHAR pszStack = \ + (PCHAR)_alloca( \ + cchMaxAssertStackLevelStringLen * \ + cfrMaxAssertStackLevels + 1); \ + GetStringFromStackLevels(0, 10, pszStack); \ + _RPT4(_CRT_WARN, \ + "%s(%d): Failed HR = %s\n\n%s\n", \ + __FILE__, \ + __LINE__, \ + pszHrWithTime, \ + pszStack); \ + PSpDebug()->HRFail(FALSE); \ + } \ + } while (0) +#else // ASSERT_WITH_STACK & !_WIN64 +#define SPDBG_REPORT_ON_FAIL(hr) \ + do \ + { \ + HRESULT _hr = (hr); \ + if (FAILED(_hr) && PSpDebug()->HRFail()) \ + { \ + _RPT3(_CRT_WARN, "%s(%d): Failed HR = %lX\n", __FILE__, __LINE__, (_hr) );\ + PSpDebug()->HRFail(FALSE); \ + } \ + } while (0) +#endif // ASSERT_WITH_STACK + +#define SPDBG_ASSERT(expr) \ + do \ + { \ + if (!(expr)) \ + { \ + if (PSpDebug()->Assert()) \ + { \ + _ASSERTE( expr ); \ + PSpDebug()->Assert(FALSE); \ + } \ + } \ + } \ + while (0) + +#define SPDBG_VERIFY(expr) \ + SPDBG_ASSERT(expr) + +#define SPDBG_PMSG0(format) \ + do \ + { \ + if (PSpDebug()->ParamInfo()) \ + { \ + _RPT0(_CRT_WARN, format); \ + PSpDebug()->ParamInfo(FALSE); \ + } \ + } while (0) +#define SPDBG_PMSG1(format, arg1) \ + do \ + { \ + if (PSpDebug()->ParamInfo()) \ + { \ + _RPT1(_CRT_WARN, format, arg1); \ + PSpDebug()->ParamInfo(FALSE); \ + } \ + } while (0) +#define SPDBG_PMSG2(format, arg1, arg2) \ + do \ + { \ + if (PSpDebug()->ParamInfo()) \ + { \ + _RPT2(_CRT_WARN, format, arg1, arg2); \ + PSpDebug()->ParamInfo(FALSE); \ + } \ + } while (0) +#define SPDBG_PMSG3(format, arg1, arg2, arg3) \ + do \ + { \ + if (PSpDebug()->ParamInfo()) \ + { \ + _RPT3(_CRT_WARN, format, arg1, arg2, arg3); \ + PSpDebug()->ParamInfo(FALSE); \ + } \ + } while (0) +#define SPDBG_PMSG4(format, arg1, arg2, arg3, arg4) \ + do \ + { \ + if (PSpDebug()->ParamInfo()) \ + { \ + _RPT4(_CRT_WARN, format, arg1, arg2, arg3, arg4); \ + PSpDebug()->ParamInfo(FALSE); \ + } \ + } while (0) + +#define SPDBG_DMSG0(format) \ + do \ + { \ + if (PSpDebug()->DumpInfo()) \ + { \ + _RPT0(_CRT_WARN, format); \ + PSpDebug()->DumpInfo(FALSE); \ + } \ + } while (0) +#define SPDBG_DMSG1(format, arg1) \ + do \ + { \ + if (PSpDebug()->DumpInfo()) \ + { \ + _RPT1(_CRT_WARN, format, arg1); \ + PSpDebug()->DumpInfo(FALSE); \ + } \ + } while (0) +#define SPDBG_DMSG2(format, arg1, arg2) \ + do \ + { \ + if (PSpDebug()->DumpInfo()) \ + { \ + _RPT2(_CRT_WARN, format, arg1, arg2); \ + PSpDebug()->DumpInfo(FALSE); \ + } \ + } while (0) +#define SPDBG_DMSG3(format, arg1, arg2, arg3) \ + do \ + { \ + if (PSpDebug()->DumpInfo()) \ + { \ + _RPT3(_CRT_WARN, format, arg1, arg2, arg3); \ + PSpDebug()->DumpInfo(FALSE); \ + } \ + } while (0) +#define SPDBG_DMSG4(format, arg1, arg2, arg3, arg4) \ + do \ + { \ + if (PSpDebug()->DumpInfo()) \ + { \ + _RPT4(_CRT_WARN, format, arg1, arg2, arg3, arg4); \ + PSpDebug()->DumpInfo(FALSE); \ + } \ + } while (0) + +#define SPDBG_RETURN(hr) \ + { \ + HRESULT __hr = (hr); \ + if (FAILED(__hr)) \ + { \ + SPDBG_REPORT_ON_FAIL(__hr); \ + } \ + return __hr; \ + } + +#define SPDBG_DEBUG_SERVER_ON_START() \ + { \ + if (PSpDebug()->DebugServerOnStart()) \ + { \ + if (MessageBox( \ + GetDesktopWindow(), \ + _T("Attach Debugger to the SAPI Server process?"), \ + _T("SAPI"), \ + MB_YESNO) == IDYES) \ + { \ + USES_CONVERSION; \ + TCHAR szCommand[MAX_PATH + 1]; \ + wsprintf( \ + szCommand, \ + _T("msdev -p %d"), \ + GetCurrentProcessId()); \ + system(T2A(szCommand)); \ + } \ + } \ + } + +#define SPDBG_DEBUG_CLIENT_ON_START() \ + { \ + if (PSpDebug()->DebugClientOnStart()) \ + { \ + TCHAR szModule[MAX_PATH + 1]; \ + szModule[0] = '\0'; \ + TCHAR * pszSapiServer = \ + _T("sapisvr.exe"); \ + GetModuleFileName( \ + NULL, \ + szModule, \ + MAX_PATH); \ + if ((_tcslen(szModule) <= \ + _tcslen(pszSapiServer) || \ + _tcsicmp( \ + szModule + \ + _tcslen(szModule) - \ + _tcslen(pszSapiServer), \ + pszSapiServer) != 0) && \ + MessageBox( \ + GetDesktopWindow(), \ + _T("Attach Debugger to the SAPI Client process?"), \ + _T("SAPI"), \ + MB_YESNO) == IDYES) \ + { \ + USES_CONVERSION; \ + TCHAR szCommand[MAX_PATH + 1]; \ + wsprintf( \ + szCommand, \ + _T("msdev -p %d"), \ + GetCurrentProcessId()); \ + system(T2A(szCommand)); \ + } \ + } \ + } + +#else // _DEBUG + +#define SPDBG_FUNC(name) +#define SPDBG_REPORT_ON_FAIL(hr) +#define SPDBG_ASSERT(expr) +#define SPDBG_VERIFY(expr) (expr) +#define SPDBG_PMSG0(format) +#define SPDBG_PMSG1(format, arg1) +#define SPDBG_PMSG2(format, arg1, arg2) +#define SPDBG_PMSG3(format, arg1, arg2, arg3) +#define SPDBG_PMSG4(format, arg1, arg2, arg3, arg4) +#define SPDBG_DMSG0(format) +#define SPDBG_DMSG1(format, arg1) +#define SPDBG_DMSG2(format, arg1, arg2) +#define SPDBG_DMSG3(format, arg1, arg2, arg3) +#define SPDBG_DMSG4(format, arg1, arg2, arg3, arg4) +#define SPDBG_RETURN(hr) return (hr) +#define SPDBG_DEBUG_SERVER_ON_START() +#define SPDBG_DEBUG_CLIENT_ON_START() + +#endif // _DEBUG diff --git a/speech2/third_party/sapi5/include/sperror.h b/speech2/third_party/sapi5/include/sperror.h new file mode 100644 index 0000000..95a4395 --- /dev/null +++ b/speech2/third_party/sapi5/include/sperror.h @@ -0,0 +1,559 @@ +/******************************************************************************* +* SPError.h * +*-----------* +* Description: +* This header file contains the custom error codes specific to SAPI5 +*------------------------------------------------------------------------------- +* Copyright (c) Microsoft Corporation. All rights reserved. +*******************************************************************************/ +#ifndef SPError_h +#define SPError_h + +#ifndef _WINERROR_ +#include +#endif + +#define FACILITY_SAPI FACILITY_ITF +#define SAPI_ERROR_BASE 0x5000 + +#define MAKE_SAPI_HRESULT(sev, err) MAKE_HRESULT(sev, FACILITY_SAPI, err) +#define MAKE_SAPI_ERROR(err) MAKE_SAPI_HRESULT(SEVERITY_ERROR, err + SAPI_ERROR_BASE) +#define MAKE_SAPI_SCODE(scode) MAKE_SAPI_HRESULT(SEVERITY_SUCCESS, scode + SAPI_ERROR_BASE) + +/*** SPERR_UNINITIALIZED 0x80045001 -2147201023 +* The object has not been properly initialized. +*/ +#define SPERR_UNINITIALIZED MAKE_SAPI_ERROR(0x001) + +/*** SPERR_ALREADY_INITIALIZED 0x80045002 -2147201022 +* The object has already been initialized. +*/ +#define SPERR_ALREADY_INITIALIZED MAKE_SAPI_ERROR(0x002) + +/*** SPERR_UNSUPPORTED_FORMAT 0x80045003 -2147201021 +* The caller has specified an unsupported format. +*/ +#define SPERR_UNSUPPORTED_FORMAT MAKE_SAPI_ERROR(0x003) + +/*** SPERR_INVALID_FLAGS 0x80045004 -2147201020 +* The caller has specified invalid flags for this operation. +*/ +#define SPERR_INVALID_FLAGS MAKE_SAPI_ERROR(0x004) + +/*** SP_END_OF_STREAM 0x00045005 282629 +* The operation has reached the end of stream. +*/ +#define SP_END_OF_STREAM MAKE_SAPI_SCODE(0x005) + +/*** SPERR_DEVICE_BUSY 0x80045006 -2147201018 +* The wave device is busy. +*/ +#define SPERR_DEVICE_BUSY MAKE_SAPI_ERROR(0x006) + +/*** SPERR_DEVICE_NOT_SUPPORTED 0x80045007 -2147201017 +* The wave device is not supported. +*/ +#define SPERR_DEVICE_NOT_SUPPORTED MAKE_SAPI_ERROR(0x007) + +/*** SPERR_DEVICE_NOT_ENABLED 0x80045008 -2147201016 +* The wave device is not enabled. +*/ +#define SPERR_DEVICE_NOT_ENABLED MAKE_SAPI_ERROR(0x008) + +/*** SPERR_NO_DRIVER 0x80045009 -2147201015 +* There is no wave driver installed. +*/ +#define SPERR_NO_DRIVER MAKE_SAPI_ERROR(0x009) + +/*** SPERR_FILEMUSTBEUNICODE 0x8004500a -2147201014 +* The file must be Unicode. +*/ +#define SPERR_FILE_MUST_BE_UNICODE MAKE_SAPI_ERROR(0x00a) + +/*** SP_INSUFFICIENTDATA 0x0004500b 282635 +* +*/ +#define SP_INSUFFICIENT_DATA MAKE_SAPI_SCODE(0x00b) + +/*** SPERR_INVALID_PHRASE_ID 0x8004500c -2147201012 +* The phrase ID specified does not exist or is out of range. +*/ +#define SPERR_INVALID_PHRASE_ID MAKE_SAPI_ERROR(0x00c) + +/*** SPERR_BUFFER_TOO_SMALL 0x8004500d -2147201011 +* The caller provided a buffer too small to return a result. +*/ +#define SPERR_BUFFER_TOO_SMALL MAKE_SAPI_ERROR(0x00d) + +/*** SPERR_FORMAT_NOT_SPECIFIED 0x8004500e -2147201010 +* Caller did not specify a format prior to opening a stream. +*/ +#define SPERR_FORMAT_NOT_SPECIFIED MAKE_SAPI_ERROR(0x00e) + +/*** SPERR_AUDIO_STOPPED 0x8004500f -2147201009 +* This method is deprecated. Use SP_AUDIO_STOPPED instead. +*/ +#define SPERR_AUDIO_STOPPED MAKE_SAPI_ERROR(0x00f) + +/*** SP_AUDIO_PAUSED 0x00045010 282640 +* This will be returned only on input (read) streams when the stream is paused. Reads on +* paused streams will not block, and this return code indicates that all of the data has been +* removed from the stream. +*/ +#define SP_AUDIO_PAUSED MAKE_SAPI_SCODE(0x010) + +/*** SPERR_RULE_NOT_FOUND 0x80045011 -2147201007 +* Invalid rule name passed to ActivateGrammar. +*/ +#define SPERR_RULE_NOT_FOUND MAKE_SAPI_ERROR(0x011) + +/*** SPERR_TTS_ENGINE_EXCEPTION 0x80045012 -2147201006 +* An exception was raised during a call to the current TTS driver. +*/ +#define SPERR_TTS_ENGINE_EXCEPTION MAKE_SAPI_ERROR(0x012) + +/*** SPERR_TTS_NLP_EXCEPTION 0x80045013 -2147201005 +* An exception was raised during a call to an application sentence filter. +*/ +#define SPERR_TTS_NLP_EXCEPTION MAKE_SAPI_ERROR(0x013) + +/*** SPERR_ENGINE_BUSY 0x80045014 -2147201004 +* In speech recognition, the current method can not be performed while +* a grammar rule is active. +*/ +#define SPERR_ENGINE_BUSY MAKE_SAPI_ERROR(0x014) + +/*** SP_AUDIO_CONVERSION_ENABLED 0x00045015 282645 +* The operation was successful, but only with automatic stream format conversion. +*/ +#define SP_AUDIO_CONVERSION_ENABLED MAKE_SAPI_SCODE(0x015) + +/*** SP_NO_HYPOTHESIS_AVAILABLE 0x00045016 282646 +* There is currently no hypothesis recognition available. +*/ +#define SP_NO_HYPOTHESIS_AVAILABLE MAKE_SAPI_SCODE(0x016) + +/*** SPERR_CANT_CREATE 0x80045017 -2147201001 +* Can not create a new object instance for the specified object category. +*/ +#define SPERR_CANT_CREATE MAKE_SAPI_ERROR(0x017) + +/*** SP_ALREADY_IN_LEX 0x00045018 282648 +* The word, pronunciation, or POS pair being added is already in lexicon. +*/ +#define SP_ALREADY_IN_LEX MAKE_SAPI_SCODE(0x018) + +/*** SPERR_NOT_IN_LEX 0x80045019 -2147200999 +* The word does not exist in the lexicon. +*/ +#define SPERR_NOT_IN_LEX MAKE_SAPI_ERROR(0x019) + +/*** SP_LEX_NOTHING_TO_SYNC 0x0004501a 282650 +* The client is currently synced with the lexicon. +*/ +#define SP_LEX_NOTHING_TO_SYNC MAKE_SAPI_SCODE(0x01a) + +/*** SPERR_LEX_VERY_OUT_OF_SYNC 0x8004501b -2147200997 +* The client is excessively out of sync with the lexicon. Mismatches may not be incrementally sync'd. +*/ +#define SPERR_LEX_VERY_OUT_OF_SYNC MAKE_SAPI_ERROR(0x01b) + +/*** SPERR_UNDEFINED_FORWARD_RULE_REF 0x8004501c -2147200996 +* A rule reference in a grammar was made to a named rule that was never defined. +*/ +#define SPERR_UNDEFINED_FORWARD_RULE_REF MAKE_SAPI_ERROR(0x01c) + +/*** SPERR_EMPTY_RULE 0x8004501d -2147200995 +* A non-dynamic grammar rule that has no body. +*/ +#define SPERR_EMPTY_RULE MAKE_SAPI_ERROR(0x01d) + +/*** SPERR_GRAMMAR_COMPILER_INTERNAL_ERROR 0x8004501e -2147200994 +* The grammar compiler failed due to an internal state error. +*/ +#define SPERR_GRAMMAR_COMPILER_INTERNAL_ERROR MAKE_SAPI_ERROR(0x01e) + + +/*** SPERR_RULE_NOT_DYNAMIC 0x8004501f -2147200993 +* An attempt was made to modify a non-dynamic rule. +*/ +#define SPERR_RULE_NOT_DYNAMIC MAKE_SAPI_ERROR(0x01f) + +/*** SPERR_DUPLICATE_RULE_NAME 0x80045020 -2147200992 +* A rule name was duplicated. +*/ +#define SPERR_DUPLICATE_RULE_NAME MAKE_SAPI_ERROR(0x020) + +/*** SPERR_DUPLICATE_RESOURCE_NAME 0x80045021 -2147200991 +* A resource name was duplicated for a given rule. +*/ +#define SPERR_DUPLICATE_RESOURCE_NAME MAKE_SAPI_ERROR(0x021) + + +/*** SPERR_TOO_MANY_GRAMMARS 0x80045022 -2147200990 +* Too many grammars have been loaded. +*/ +#define SPERR_TOO_MANY_GRAMMARS MAKE_SAPI_ERROR(0x022) + +/*** SPERR_CIRCULAR_REFERENCE 0x80045023 -2147200989 +* Circular reference in import rules of grammars. +*/ +#define SPERR_CIRCULAR_REFERENCE MAKE_SAPI_ERROR(0x023) + +/*** SPERR_INVALID_IMPORT 0x80045024 -2147200988 +* A rule reference to an imported grammar that could not be resolved. +*/ +#define SPERR_INVALID_IMPORT MAKE_SAPI_ERROR(0x024) + +/*** SPERR_INVALID_WAV_FILE 0x80045025 -2147200987 +* The format of the WAV file is not supported. +*/ +#define SPERR_INVALID_WAV_FILE MAKE_SAPI_ERROR(0x025) + +/*** SP_REQUEST_PENDING 0x00045026 282662 +* This success code indicates that an SR method called with the SPRIF_ASYNC flag is +* being processed. When it has finished processing, an SPFEI_ASYNC_COMPLETED event will be generated. +*/ +#define SP_REQUEST_PENDING MAKE_SAPI_SCODE(0x026) + +/*** SPERR_ALL_WORDS_OPTIONAL 0x80045027 -2147200985 +* A grammar rule was defined with a null path through the rule. That is, it is possible +* to satisfy the rule conditions with no words. +*/ +#define SPERR_ALL_WORDS_OPTIONAL MAKE_SAPI_ERROR(0x027) + +/*** SPERR_INSTANCE_CHANGE_INVALID 0x80045028 -2147200984 +* It is not possible to change the current engine or input. This occurs in the +* following cases: +* +* 1) SelectEngine called while a recognition context exists, or +* 2) SetInput called in the shared instance case. +*/ +#define SPERR_INSTANCE_CHANGE_INVALID MAKE_SAPI_ERROR(0x028) + +/*** SPERR_RULE_NAME_ID_CONFLICT 0x80045029 -2147200983 +* A rule exists with matching IDs (names) but different names (IDs). +*/ +#define SPERR_RULE_NAME_ID_CONFLICT MAKE_SAPI_ERROR(0x029) + +/*** SPERR_NO_RULES 0x8004502a -2147200982 +* A grammar contains no top-level, dynamic, or exported rules. There is no possible +* way to activate or otherwise use any rule in this grammar. +*/ +#define SPERR_NO_RULES MAKE_SAPI_ERROR(0x02a) + +/*** SPERR_CIRCULAR_RULE_REF 0x8004502b -2147200981 +* Rule 'A' refers to a second rule 'B' which, in turn, refers to rule 'A'. +*/ +#define SPERR_CIRCULAR_RULE_REF MAKE_SAPI_ERROR(0x02b) + +/*** SP_NO_PARSE_FOUND 0x0004502c 282668 +* Parse path cannot be parsed given the currently active rules. +*/ +#define SP_NO_PARSE_FOUND MAKE_SAPI_SCODE(0x02c) + +/*** SPERR_NO_PARSE_FOUND 0x8004502d -2147200979 +* Parse path cannot be parsed given the currently active rules. +*/ +#define SPERR_INVALID_HANDLE MAKE_SAPI_ERROR(0x02d) + +/*** SPERR_REMOTE_CALL_TIMED_OUT 0x8004502e -2147200978 +* A marshaled remote call failed to respond. +*/ +#define SPERR_REMOTE_CALL_TIMED_OUT MAKE_SAPI_ERROR(0x02e) + +/*** SPERR_AUDIO_BUFFER_OVERFLOW 0x8004502f -2147200977 +* This will only be returned on input (read) streams when the stream is paused because +* the SR driver has not retrieved data recently. +*/ +#define SPERR_AUDIO_BUFFER_OVERFLOW MAKE_SAPI_ERROR(0x02f) + + +/*** SPERR_NO_AUDIO_DATA 0x80045030 -2147200976 +* The result does not contain any audio, nor does the portion of the element chain of the result +* contain any audio. +*/ +#define SPERR_NO_AUDIO_DATA MAKE_SAPI_ERROR(0x030) + +/*** SPERR_DEAD_ALTERNATE 0x80045031 -2147200975 +* This alternate is no longer a valid alternate to the result it was obtained from. +* Returned from ISpPhraseAlt methods. +*/ +#define SPERR_DEAD_ALTERNATE MAKE_SAPI_ERROR(0x031) + +/*** SPERR_HIGH_LOW_CONFIDENCE 0x80045032 -2147200974 +* The result does not contain any audio, nor does the portion of the element chain of the result +* contain any audio. Returned from ISpResult::GetAudio and ISpResult::SpeakAudio. +*/ +#define SPERR_HIGH_LOW_CONFIDENCE MAKE_SAPI_ERROR(0x032) + +/*** SPERR_INVALID_FORMAT_STRING 0x80045033 -2147200973 +* The XML format string for this RULEREF is invalid, e.g. not a GUID or REFCLSID. +*/ +#define SPERR_INVALID_FORMAT_STRING MAKE_SAPI_ERROR(0x033) + +/*** SP_UNSUPPORTED_ON_STREAM_INPUT 0x00045034 282676 +* The operation is not supported for stream input. +*/ +#define SP_UNSUPPORTED_ON_STREAM_INPUT MAKE_SAPI_SCODE(0x034) + +/*** SPERR_APPLEX_READ_ONLY 0x80045035 -2147200971 +* The operation is invalid for all but newly created application lexicons. +*/ +#define SPERR_APPLEX_READ_ONLY MAKE_SAPI_ERROR(0x035) + +/*** SPERR_NO_TERMINATING_RULE_PATH 0x80045036 -2147200970 +* +*/ + +#define SPERR_NO_TERMINATING_RULE_PATH MAKE_SAPI_ERROR(0x036) + +/*** SP_WORD_EXISTS_WITHOUT_PRONUNCIATION 0x00045037 282679 +* The word exists but without pronunciation. +*/ +#define SP_WORD_EXISTS_WITHOUT_PRONUNCIATION MAKE_SAPI_SCODE(0x037) + +/*** SPERR_STREAM_CLOSED 0x80045038 -2147200968 +* An operation was attempted on a stream object that has been closed. +*/ +#define SPERR_STREAM_CLOSED MAKE_SAPI_ERROR(0x038) + +// --- The following error codes are taken directly from WIN32 --- + +/*** SPERR_NO_MORE_ITEMS 0x80045039 -2147200967 +* When enumerating items, the requested index is greater than the count of items. +*/ +#define SPERR_NO_MORE_ITEMS MAKE_SAPI_ERROR(0x039) + +/*** SPERR_NOT_FOUND 0x8004503a -2147200966 +* The requested data item (data key, value, etc.) was not found. +*/ +#define SPERR_NOT_FOUND MAKE_SAPI_ERROR(0x03a) + +/*** SPERR_INVALID_AUDIO_STATE 0x8004503b -2147200965 +* Audio state passed to SetState() is invalid. +*/ +#define SPERR_INVALID_AUDIO_STATE MAKE_SAPI_ERROR(0x03b) + +/*** SPERR_GENERIC_MMSYS_ERROR 0x8004503c -2147200964 +* A generic MMSYS error not caught by _MMRESULT_TO_HRESULT. +*/ +#define SPERR_GENERIC_MMSYS_ERROR MAKE_SAPI_ERROR(0x03c) + +/*** SPERR_MARSHALER_EXCEPTION 0x8004503d -2147200963 +* An exception was raised during a call to the marshaling code. +*/ +#define SPERR_MARSHALER_EXCEPTION MAKE_SAPI_ERROR(0x03d) + +/*** SPERR_NOT_DYNAMIC_GRAMMAR 0x8004503e -2147200962 +* Attempt was made to manipulate a non-dynamic grammar. +*/ +#define SPERR_NOT_DYNAMIC_GRAMMAR MAKE_SAPI_ERROR(0x03e) + +/*** SPERR_AMBIGUOUS_PROPERTY 0x8004503f -2147200961 +* Cannot add ambiguous property. +*/ +#define SPERR_AMBIGUOUS_PROPERTY MAKE_SAPI_ERROR(0x03f) + +/*** SPERR_INVALID_REGISTRY_KEY 0x80045040 -2147200960 +* The key specified is invalid. +*/ +#define SPERR_INVALID_REGISTRY_KEY MAKE_SAPI_ERROR(0x040) + +/*** SPERR_INVALID_TOKEN_ID 0x80045041 -2147200959 +* The token specified is invalid. +*/ +#define SPERR_INVALID_TOKEN_ID MAKE_SAPI_ERROR(0x041) + +/*** SPERR_XML_BAD_SYNTAX 0x80045042 -2147200958 +* The xml parser failed due to bad syntax. +*/ +#define SPERR_XML_BAD_SYNTAX MAKE_SAPI_ERROR(0x042) + +/*** SPERR_XML_RESOURCE_NOT_FOUND 0x80045043 -2147200957 +* The xml parser failed to load a required resource (e.g., voice, phoneconverter, etc.). +*/ +#define SPERR_XML_RESOURCE_NOT_FOUND MAKE_SAPI_ERROR(0x043) + +/*** SPERR_TOKEN_IN_USE 0x80045044 -2147200956 +* Attempted to remove registry data from a token that is already in use elsewhere. +*/ +#define SPERR_TOKEN_IN_USE MAKE_SAPI_ERROR(0x044) + +/*** SPERR_TOKEN_DELETED 0x80045045 -2147200955 +* Attempted to perform an action on an object token that has had associated registry key deleted. +*/ +#define SPERR_TOKEN_DELETED MAKE_SAPI_ERROR(0x045) + +/*** SPERR_MULTI_LINGUAL_NOT_SUPPORTED 0x80045046 -2147200954 +* The selected voice was registered as multi-lingual. SAPI does not support multi-lingual registration. +*/ +#define SPERR_MULTI_LINGUAL_NOT_SUPPORTED MAKE_SAPI_ERROR(0x046) + +/*** SPERR_EXPORT_DYNAMIC_RULE 0x80045047 -2147200953 +* Exported rules cannot refer directly or indirectly to a dynamic rule. +*/ +#define SPERR_EXPORT_DYNAMIC_RULE MAKE_SAPI_ERROR(0x047) + +/*** SPERR_STGF_ERROR 0x80045048 -2147200952 +* Error parsing the SAPI Text Grammar Format (XML grammar). +*/ +#define SPERR_STGF_ERROR MAKE_SAPI_ERROR(0x048) + +/*** SPERR_WORDFORMAT_ERROR 0x80045049 -2147200951 +* Incorrect word format, probably due to incorrect pronunciation string. +*/ +#define SPERR_WORDFORMAT_ERROR MAKE_SAPI_ERROR(0x049) + +/*** SPERR_STREAM_NOT_ACTIVE 0x8004504a -2147200950 +* Methods associated with active audio stream cannot be called unless stream is active. +*/ +#define SPERR_STREAM_NOT_ACTIVE MAKE_SAPI_ERROR(0x04a) + +/*** SPERR_ENGINE_RESPONSE_INVALID 0x8004504b -2147200949 +* Arguments or data supplied by the engine are in an invalid format or are inconsistent. +*/ +#define SPERR_ENGINE_RESPONSE_INVALID MAKE_SAPI_ERROR(0x04b) + +/*** SPERR_SR_ENGINE_EXCEPTION 0x8004504c -2147200948 +* An exception was raised during a call to the current SR engine. +*/ +#define SPERR_SR_ENGINE_EXCEPTION MAKE_SAPI_ERROR(0x04c) + +/*** SPERR_STREAM_POS_INVALID 0x8004504d -2147200947 +* Stream position information supplied from engine is inconsistent. +*/ +#define SPERR_STREAM_POS_INVALID MAKE_SAPI_ERROR(0x04d) + +/*** SP_RECOGNIZER_INACTIVE 0x0004504e 282702 +* Operation could not be completed because the recognizer is inactive. It is inactive either +* because the recognition state is currently inactive or because no rules are active . +*/ +#define SP_RECOGNIZER_INACTIVE MAKE_SAPI_SCODE(0x04e) + +/*** SPERR_REMOTE_CALL_ON_WRONG_THREAD 0x8004504f -2147200945 +* When making a remote call to the server, the call was made on the wrong thread. +*/ +#define SPERR_REMOTE_CALL_ON_WRONG_THREAD MAKE_SAPI_ERROR(0x04f) + +/*** SPERR_REMOTE_PROCESS_TERMINATED 0x80045050 -2147200944 +* The remote process terminated unexpectedly. +*/ +#define SPERR_REMOTE_PROCESS_TERMINATED MAKE_SAPI_ERROR(0x050) + +/*** SPERR_REMOTE_PROCESS_ALREADY_RUNNING 0x80045051 -2147200943 +* The remote process is already running; it cannot be started a second time. +*/ +#define SPERR_REMOTE_PROCESS_ALREADY_RUNNING MAKE_SAPI_ERROR(0x051) + +/*** SPERR_LANGID_MISMATCH 0x80045052 -2147200942 +* An attempt to load a CFG grammar with a LANGID different than other loaded grammars. +*/ +#define SPERR_LANGID_MISMATCH MAKE_SAPI_ERROR(0x052) + +/*** SP_PARTIAL_PARSE_FOUND 0x00045053 282707 +* A grammar-ending parse has been found that does not use all available words. +*/ +#define SP_PARTIAL_PARSE_FOUND MAKE_SAPI_SCODE(0x053) + +/*** SPERR_NOT_TOPLEVEL_RULE 0x80045054 -2147200940 +* An attempt to deactivate or activate a non-toplevel rule. +*/ +#define SPERR_NOT_TOPLEVEL_RULE MAKE_SAPI_ERROR(0x054) + +/*** SP_NO_RULE_ACTIVE 0x00045055 282709 +* An attempt to parse when no rule was active. +*/ +#define SP_NO_RULE_ACTIVE MAKE_SAPI_SCODE(0x055) + +/*** SPERR_LEX_REQUIRES_COOKIE 0x80045056 -2147200938 +* An attempt to ask a container lexicon for all words at once. +*/ +#define SPERR_LEX_REQUIRES_COOKIE MAKE_SAPI_ERROR(0x056) + +/*** SP_STREAM_UNINITIALIZED 0x00045057 282711 +* An attempt to activate a rule/dictation/etc without calling SetInput +* first in the inproc case. +*/ +#define SP_STREAM_UNINITIALIZED MAKE_SAPI_SCODE(0x057) + + +// Error x058 is not used in SAPI 5.0 + + +/*** SPERR_UNSUPPORTED_LANG 0x80045059 -2147200935 +* The requested language is not supported. +*/ +#define SPERR_UNSUPPORTED_LANG MAKE_SAPI_ERROR(0x059) + +/*** SPERR_VOICE_PAUSED 0x8004505a -2147200934 +* The operation cannot be performed because the voice is currently paused. +*/ +#define SPERR_VOICE_PAUSED MAKE_SAPI_ERROR(0x05a) + +/*** SPERR_AUDIO_BUFFER_UNDERFLOW 0x8004505b -2147200933 +* This will only be returned on input (read) streams when the real time audio device +* stops returning data for a long period of time. +*/ +#define SPERR_AUDIO_BUFFER_UNDERFLOW MAKE_SAPI_ERROR(0x05b) + +/*** SPERR_AUDIO_STOPPED_UNEXPECTEDLY 0x8004505c -2147200932 +* An audio device stopped returning data from the Read() method even though it was in +* the run state. This error is only returned in the END_SR_STREAM event. +*/ +#define SPERR_AUDIO_STOPPED_UNEXPECTEDLY MAKE_SAPI_ERROR(0x05c) + +/*** SPERR_NO_WORD_PRONUNCIATION 0x8004505d -2147200931 +* The SR engine is unable to add this word to a grammar. The application may need to supply +* an explicit pronunciation for this word. +*/ +#define SPERR_NO_WORD_PRONUNCIATION MAKE_SAPI_ERROR(0x05d) + +/*** SPERR_ALTERNATES_WOULD_BE_INCONSISTENT 0x8004505e -2147200930 +* An attempt to call ScaleAudio on a recognition result having previously +* called GetAlternates. Allowing the call to succeed would result in +* the previously created alternates located in incorrect audio stream positions. +*/ +#define SPERR_ALTERNATES_WOULD_BE_INCONSISTENT MAKE_SAPI_ERROR(0x05e) + +/*** SPERR_NOT_SUPPORTED_FOR_SHARED_RECOGNIZER 0x8004505f -2147200929 +* The method called is not supported for the shared recognizer. +* For example, ISpRecognizer::GetInputStream(). +*/ +#define SPERR_NOT_SUPPORTED_FOR_SHARED_RECOGNIZER MAKE_SAPI_ERROR(0x05f) + +/*** SPERR_TIMEOUT 0x80045060 -2147200928 +* A task could not complete because the SR engine had timed out. +*/ +#define SPERR_TIMEOUT MAKE_SAPI_ERROR(0x060) + + +/*** SPERR_REENTER_SYNCHRONIZE 0x80045061 -2147200927 +* A SR engine called synchronize while inside of a synchronize call. +*/ +#define SPERR_REENTER_SYNCHRONIZE MAKE_SAPI_ERROR(0x061) + +/*** SPERR_STATE_WITH_NO_ARCS 0x80045062 -2147200926 +* The grammar contains a node no arcs. +*/ +#define SPERR_STATE_WITH_NO_ARCS MAKE_SAPI_ERROR(0x062) + +/*** SPERR_NOT_ACTIVE_SESSION 0x80045063 -2147200925 +* Neither audio output and input is supported for non-active console sessions. +*/ +#define SPERR_NOT_ACTIVE_SESSION MAKE_SAPI_ERROR(0x063) + +/*** SPERR_ALREADY_DELETED 0x80045064 -2147200924 +* The object is a stale reference and is invalid to use. +* For example having a ISpeechGrammarRule object reference and then calling +* ISpeechRecoGrammar::Reset() will cause the rule object to be invalidated. +* Calling any methods after this will result in this error. +*/ +#define SPERR_ALREADY_DELETED MAKE_SAPI_ERROR(0x064) + +/*** SP_AUDIO_STOPPED 0x00045065 282725 +* This can be returned from Read or Write calls audio streams when the stream is stopped. +*/ +#define SP_AUDIO_STOPPED MAKE_SAPI_SCODE(0x065) + +#endif //--- This must be the last line in the file diff --git a/speech2/third_party/sapi5/include/speventq.h b/speech2/third_party/sapi5/include/speventq.h new file mode 100644 index 0000000..b0447dc --- /dev/null +++ b/speech2/third_party/sapi5/include/speventq.h @@ -0,0 +1,605 @@ +/******************************************************************************* +* SPEventQ.h * +*------------* +* Description: +* This is the header file for the SAPI5 event queue implementation. +*------------------------------------------------------------------------------- +* Copyright (c) Microsoft Corporation. All rights reserved. +*******************************************************************************/ +#ifndef SPEventQ_h +#define SPEventQ_h + +#ifndef SPHelper_h +#include +#endif + +#ifndef SPCollec_h +#include +#endif + +//=== Inline helpers for copying and deleting events ============================ + + +//=== Class definition ========================================================== + +class CSpEventNode : public CSpEvent +{ +public: + CSpEventNode * m_pNext; + static LONG Compare(const CSpEventNode * p1, const CSpEventNode *p2) + { + // Assumes offsets DO or DO NOT reset when stream number changes + if (p1->ulStreamNum < p2->ulStreamNum) + { + return -1; + } + else if (p1->ulStreamNum > p2->ulStreamNum) + { + return 1; + } + else if (p1->ullAudioStreamOffset < p2->ullAudioStreamOffset) + { + return -1; + } + else if (p1->ullAudioStreamOffset > p2->ullAudioStreamOffset) + { + return 1; + } + return 0; + } +}; + + +typedef CSpBasicQueue CSpEventList; + +#define DECLARE_SPNOTIFYSOURCE_METHODS(T) \ +STDMETHODIMP SetNotifySink(ISpNotifySink * pNotifySink) \ +{ return T._SetNotifySink(pNotifySink); } \ +STDMETHODIMP SetNotifyWindowMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam) \ +{ return T._SetNotifyWindowMessage(hWnd, Msg, wParam, lParam); } \ +STDMETHODIMP SetNotifyCallbackFunction(SPNOTIFYCALLBACK * pfnCallback, WPARAM wParam, LPARAM lParam) \ +{ return T._SetNotifyCallbackFunction(pfnCallback, wParam, lParam); } \ +STDMETHODIMP SetNotifyCallbackInterface(ISpNotifyCallback * pSpCallback, WPARAM wParam, LPARAM lParam) \ +{ return T._SetNotifyCallbackInterface(pSpCallback, wParam, lParam); } \ +STDMETHODIMP SetNotifyWin32Event() \ +{ return T._SetNotifyWin32Event(); } \ +STDMETHODIMP WaitForNotifyEvent(DWORD dwMilliseconds) \ +{ return T._WaitForNotifyEvent(dwMilliseconds); } \ +STDMETHODIMP_(HANDLE) GetNotifyEventHandle() \ +{ return T._GetNotifyEventHandle(); } + +#define DECLARE_SPEVENTSOURCE_METHODS(T) \ +DECLARE_SPNOTIFYSOURCE_METHODS(T) \ +STDMETHODIMP SetInterest(ULONGLONG ullEventInterest, ULONGLONG ullQueuedInterest) \ +{ return T._SetInterest(ullEventInterest, ullQueuedInterest); } \ +STDMETHODIMP GetEvents(ULONG ulCount, SPEVENT* pEventArray, ULONG * pulFetched) \ +{ return T._GetEvents(ulCount, pEventArray, pulFetched); } \ +STDMETHODIMP GetInfo(SPEVENTSOURCEINFO *pInfo) \ +{ return T._GetInfo(pInfo); } + + + +class CSpEventSource +{ + public: + CSpEventSource(CComObjectRootEx * pParent) : + m_pParent(pParent) + { + m_ullEventInterest = 0; m_ullQueuedInterest = 0; + m_ulStreamNum = 0; + } + HRESULT _SetNotifySink(ISpNotifySink * pNotifySink); + HRESULT _SetNotifyWindowMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam); + HRESULT _SetNotifyCallbackFunction(SPNOTIFYCALLBACK * pfnCallback, WPARAM wParam, LPARAM lParam); + HRESULT _SetNotifyCallbackInterface(ISpNotifyCallback * pSpCallback, WPARAM wParam, LPARAM lParam); + HRESULT _SetNotifyWin32Event(); + HRESULT _WaitForNotifyEvent(DWORD dwMilliseconds); + HANDLE _GetNotifyEventHandle(); + + HRESULT _SetInterest(ULONGLONG ullEventInterest , ULONGLONG ullQueuedInterest); + HRESULT _GetEvents( ULONG ulCount, SPEVENT* pEventArray, ULONG * pulFetched ); + HRESULT _GetInfo(SPEVENTSOURCEINFO *pInfo ); + + /*--- Non interface methods ---*/ + HRESULT _CompleteEvents( ULONGLONG ullPos = 0xFFFFFFFFFFFFFFFF ); + inline void _MoveAllToFreeList(CSpEventList * pList); + inline void _RemoveAllEvents(); + inline HRESULT _AddEvent(const SPEVENT & Event); + inline HRESULT _AddEvents(const SPEVENT* pEventArray, ULONG ulCount); + inline HRESULT _DeserializeAndAddEvent(const BYTE * pBuffer, ULONG * pcbUsed); + inline HRESULT _GetStreamNumber(const ULONGLONG ullAudioOffset, ULONG *pulStreamNum); + //=== Data members ============================== + public: + ULONGLONG m_ullEventInterest; + ULONGLONG m_ullQueuedInterest; + ULONG m_ulStreamNum; + CSpEventList m_PendingList; + CSpEventList m_CompletedList; + CSpEventList m_FreeList; + CComPtr m_cpNotifySink; + CComPtr m_cpEventTranslator; // If non-NULL then Win32 events being used + CComObjectRootEx * m_pParent; + CComAutoCriticalSection m_NotifyObjChangeCrit; // Critical section used to make sure that + // the notify object (m_cpNotifySink) not changed + // while waiting on it. + +}; + + +// +//=== Inlines ========================================================= +// + +// +// WARNING: If this logic changes, you will need to change the logic in SetNotifyWin32Event also. +// +inline HRESULT CSpEventSource::_SetNotifySink(ISpNotifySink * pNotifySink) +{ + if (SP_IS_BAD_OPTIONAL_INTERFACE_PTR(pNotifySink)) + { + return E_INVALIDARG; + } + else + { + m_pParent->Lock(); + m_NotifyObjChangeCrit.Lock(); + m_cpEventTranslator.Release(); + m_cpNotifySink = pNotifySink; + if (m_cpNotifySink && m_CompletedList.GetHead()) + { + m_cpNotifySink->Notify(); + } + m_NotifyObjChangeCrit.Unlock(); + m_pParent->Unlock(); + return S_OK; + } +} + +/**************************************************************************** +* CSpEventSource::_SetNotifyWindowMessage * +*-----------------------------------------* +* Description: +* +* Returns: +* +********************************************************************* RAL ***/ + +inline HRESULT CSpEventSource::_SetNotifyWindowMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam) +{ + SPDBG_FUNC("CSpEventSource::_SetNotifyWindowMessage"); + HRESULT hr = S_OK; + CComPtr cpTranslator; + hr = cpTranslator.CoCreateInstance(CLSID_SpNotifyTranslator); + if (SUCCEEDED(hr)) + { + hr = cpTranslator->InitWindowMessage(hWnd, Msg, wParam, lParam); + } + if (SUCCEEDED(hr)) + { + hr = _SetNotifySink(cpTranslator); + } + return hr; +} +/**************************************************************************** +* CSpEventSource::_SetNotifyCallbackFunction * +*--------------------------------------------* +* Description: +* +* Returns: +* +********************************************************************* RAL ***/ + +inline HRESULT CSpEventSource::_SetNotifyCallbackFunction(SPNOTIFYCALLBACK * pfnCallback, WPARAM wParam, LPARAM lParam) +{ + SPDBG_FUNC("CSpEventSource::_SetNotifyCallbackFunction"); + HRESULT hr = S_OK; + CComPtr cpTranslator; + hr = cpTranslator.CoCreateInstance(CLSID_SpNotifyTranslator); + if (SUCCEEDED(hr)) + { + hr = cpTranslator->InitCallback(pfnCallback, wParam, lParam); + } + if (SUCCEEDED(hr)) + { + hr = _SetNotifySink(cpTranslator); + } + return hr; +} +/**************************************************************************** +* CSpEventSource::_SetNotifyCallbackInterface * +*---------------------------------------------* +* Description: +* +* Returns: +* +********************************************************************* RAL ***/ + +inline HRESULT CSpEventSource::_SetNotifyCallbackInterface(ISpNotifyCallback * pSpCallback, WPARAM wParam, LPARAM lParam) +{ + SPDBG_FUNC("CSpEventSource::_SetNotifyCallbackInterface"); + HRESULT hr = S_OK; + CComPtr cpTranslator; + hr = cpTranslator.CoCreateInstance(CLSID_SpNotifyTranslator); + if (SUCCEEDED(hr)) + { + hr = cpTranslator->InitSpNotifyCallback(pSpCallback, wParam, lParam); + } + if (SUCCEEDED(hr)) + { + hr = _SetNotifySink(cpTranslator); + } + return hr; +} +/**************************************************************************** +* CSpEventSource::_SetNotifyWin32Event * +*--------------------------------------* +* Description: +* +* Returns: +* +********************************************************************* RAL ***/ + +inline HRESULT CSpEventSource::_SetNotifyWin32Event(void) +{ + SPDBG_FUNC("CSpEventSource::_SetNotifyWin32Event"); + HRESULT hr = S_OK; + CComPtr cpTranslator; + hr = cpTranslator.CoCreateInstance(CLSID_SpNotifyTranslator); + if (SUCCEEDED(hr)) + { + hr = cpTranslator->InitWin32Event(NULL, TRUE); + } + if (SUCCEEDED(hr)) + { + // + // In this case we do NOT call _SetNotify sink since we want to set the cpEventTranslator + // + m_pParent->Lock(); + m_NotifyObjChangeCrit.Lock(); + m_cpEventTranslator = cpTranslator; + m_cpNotifySink = cpTranslator; + if (m_cpNotifySink && m_CompletedList.GetHead()) + { + m_cpNotifySink->Notify(); + } + m_NotifyObjChangeCrit.Unlock(); + m_pParent->Unlock(); + } + return hr; +} +/**************************************************************************** +* CSpEventSource::_WaitForNotifyEvent * +*-------------------------------------* +* Description: +* +* Returns: +* +********************************************************************* RAL ***/ + +inline HRESULT CSpEventSource::_WaitForNotifyEvent(DWORD dwMilliseconds) +{ + SPDBG_FUNC("CSpEventSource::_WaitForNotifyEvent"); + HRESULT hr = S_OK; + m_NotifyObjChangeCrit.Lock(); + if (m_cpEventTranslator) + { + hr = m_cpEventTranslator->Wait(dwMilliseconds); + } + else + { + if (m_cpNotifySink) + { + hr = SPERR_ALREADY_INITIALIZED; + } + else + { + hr = _SetNotifyWin32Event(); + if (SUCCEEDED(hr)) + { + hr = m_cpEventTranslator->Wait(dwMilliseconds); + } + } + } + m_NotifyObjChangeCrit.Unlock(); + return hr; +} +/**************************************************************************** +* CSpEventSource::_GetNotifyEventHandle * +*---------------------------------------* +* Description: +* +* Returns: +* +********************************************************************* RAL ***/ + +inline HANDLE CSpEventSource::_GetNotifyEventHandle() +{ + HANDLE h = NULL; + SPDBG_FUNC("CSpEventSource::_GetNotifyEventHandle"); + m_NotifyObjChangeCrit.Lock(); + if (!m_cpNotifySink) + { + _SetNotifyWin32Event(); + } + if (m_cpEventTranslator) + { + h = m_cpEventTranslator->GetEventHandle(); + } + m_NotifyObjChangeCrit.Unlock(); + return h; +} + + +inline HRESULT CSpEventSource::_SetInterest( ULONGLONG ullEventInterest, ULONGLONG ullQueuedInterest ) +{ + HRESULT hr = S_OK; + m_pParent->Lock(); + + if(ullEventInterest && SPFEI_FLAGCHECK != (ullEventInterest & SPFEI_FLAGCHECK)) + { + hr = E_INVALIDARG; + } + else if(ullQueuedInterest && SPFEI_FLAGCHECK != (ullQueuedInterest & SPFEI_FLAGCHECK)) + { + hr = E_INVALIDARG; + } + else if ((ullQueuedInterest | ullEventInterest) != ullEventInterest) + { + hr = E_INVALIDARG; + } + else + { + m_ullEventInterest = ullEventInterest; + m_ullQueuedInterest = ullQueuedInterest; + } + m_pParent->Unlock(); + return hr; +} + + +// +// Same as AddEvents except: No param validation, and caller must take the critical section +// prior to calling. +// +inline HRESULT CSpEventSource::_AddEvents( const SPEVENT* pEventArray, ULONG ulCount ) +{ + HRESULT hr = S_OK; + for( ULONG i = 0; i < ulCount && SUCCEEDED(hr = _AddEvent(pEventArray[i])); ++i ) {} + return hr; +} + +inline HRESULT CSpEventSource::_AddEvent(const SPEVENT & Event) +{ + SPDBG_ASSERT(Event.eEventId < 64); + SPDBG_ASSERT(Event.elParamType == SPET_LPARAM_IS_UNDEFINED || + Event.elParamType == SPET_LPARAM_IS_TOKEN || + Event.elParamType == SPET_LPARAM_IS_OBJECT || + Event.elParamType == SPET_LPARAM_IS_POINTER || + Event.elParamType == SPET_LPARAM_IS_STRING); +#ifdef _DEBUG + if (Event.eEventId == SPEI_VOICE_CHANGE) + { + SPDBG_ASSERT(Event.elParamType == SPET_LPARAM_IS_TOKEN); + } + else if (Event.eEventId == SPEI_RECOGNITION || Event.eEventId == SPEI_FALSE_RECOGNITION || Event.eEventId == SPEI_HYPOTHESIS) + { + SPDBG_ASSERT(Event.elParamType == SPET_LPARAM_IS_OBJECT); + } + else if (Event.eEventId ==SPEI_REQUEST_UI || Event.eEventId == SPEI_TTS_BOOKMARK) + { + SPDBG_ASSERT(Event.elParamType == SPET_LPARAM_IS_STRING); + } +#endif + + if ( (1i64 << Event.eEventId) & m_ullEventInterest ) + { + CSpEventNode *pNode = m_FreeList.RemoveHead(); + if (pNode == NULL) + { + pNode = new CSpEventNode(); + if (pNode == NULL) + { + return E_OUTOFMEMORY; + } + } + pNode->CopyFrom(&Event); + m_PendingList.InsertSorted(pNode); + } + return S_OK; +} + +inline HRESULT CSpEventSource:: + _DeserializeAndAddEvent(const BYTE *pBuffer, ULONG * pcbUsed) +{ + HRESULT hr = S_OK; + const SPEVENT * pSrcEvent = (const SPEVENT *)pBuffer; + SPDBG_ASSERT(pSrcEvent->eEventId < 64); + if ( (1i64 << pSrcEvent->eEventId) & m_ullEventInterest ) + { + CSpEventNode *pNode = m_FreeList.RemoveHead(); + if (pNode == NULL) + { + pNode = new CSpEventNode(); + if (pNode == NULL) + { + hr = E_OUTOFMEMORY; + } + } + if (SUCCEEDED(hr)) + { + hr = pNode->Deserialize(((const SPSERIALIZEDEVENT64 *)(pBuffer)), pcbUsed); + if (SUCCEEDED(hr)) + { + m_PendingList.InsertSorted(pNode); + } + else + { + m_FreeList.InsertHead(pNode); + } + } + } + else + { +// WCE compiler does not work propertly with template +#ifndef _WIN32_WCE + *pcbUsed = SpEventSerializeSize(pSrcEvent); +#else + *pcbUsed = SpEventSerializeSize(pSrcEvent, sizeof(SPSERIALIZEDEVENT64)); +#endif + } + return hr; +} + +inline HRESULT CSpEventSource::_GetEvents( ULONG ulCount, SPEVENT* pEventArray, ULONG *pulFetched ) +{ + HRESULT hr = S_OK; + m_pParent->Lock(); + if( SPIsBadWritePtr( pEventArray, sizeof( SPEVENT ) * ulCount ) || + SP_IS_BAD_OPTIONAL_WRITE_PTR(pulFetched) ) + { + hr = E_INVALIDARG; + } + else + { + ULONG ulCopied = 0; + ULONG ulRemaining = ulCount; + CSpEventNode * pCur = m_CompletedList.m_pHead; + CSpEventNode * pLastCopied = NULL; + while (ulRemaining && pCur) + { + pCur->Detach(pEventArray + ulCopied); + pLastCopied = pCur; + ulCopied++; + pCur = pCur->m_pNext; + ulRemaining--; + } + if (ulCopied) + { + if (m_FreeList.m_pHead == NULL) + { + m_FreeList.m_pTail = pLastCopied; + } + pLastCopied->m_pNext = m_FreeList.m_pHead; + m_FreeList.m_pHead = m_CompletedList.m_pHead; + m_CompletedList.m_pHead = pCur; + m_CompletedList.m_cElements -= ulCopied; + m_FreeList.m_cElements += ulCopied; + } + if (ulCopied < ulCount) + { + hr = S_FALSE; + } + if (pulFetched) + { + *pulFetched = ulCopied; + } + } + m_pParent->Unlock(); + return hr; +} + + +inline HRESULT CSpEventSource::_GetInfo( SPEVENTSOURCEINFO * pInfo ) +{ + HRESULT hr = S_OK; + m_pParent->Lock(); + if( SP_IS_BAD_WRITE_PTR( pInfo ) ) + { + hr = E_POINTER; + } + else + { + pInfo->ulCount = m_CompletedList.GetCount(); + pInfo->ullEventInterest = m_ullEventInterest; + pInfo->ullQueuedInterest= m_ullQueuedInterest; + } + m_pParent->Unlock(); + return hr; +} + + + +// +// The caller must call this function with the critical section owned +// +inline HRESULT CSpEventSource::_CompleteEvents( ULONGLONG ullPos ) +{ + HRESULT hr = S_OK; + + if (m_PendingList.m_pHead && m_PendingList.m_pHead->ullAudioStreamOffset <= ullPos) + { + BOOL bNotify = FALSE; + while (m_PendingList.m_pHead && + m_PendingList.m_pHead->ullAudioStreamOffset <= ullPos) + { + CSpEventNode *pNode = m_PendingList.RemoveHead(); + if(pNode->ulStreamNum != m_ulStreamNum) + { + m_ulStreamNum = pNode->ulStreamNum; + } + if ( (1i64 << pNode->eEventId) & m_ullEventInterest ) + { + bNotify = TRUE; + // + // NOTE: If we're forwarding events to an event sink then we'll only + // pay attention to the Interest flags. If we're going to notify, then + // we'll only queue completed events that the user has explicitly asked + // us to store as completed events. + // + if ( (1i64 << pNode->eEventId) & m_ullQueuedInterest ) + { + m_CompletedList.InsertSorted(pNode); + } + else + { + pNode->Clear(); + m_FreeList.InsertHead(pNode); + } + } + else + { + pNode->Clear(); + m_FreeList.InsertHead(pNode); + } + } + if (bNotify && m_cpNotifySink) + { + hr = m_cpNotifySink->Notify(); + } + } + return hr; +}; + + +inline void CSpEventSource::_MoveAllToFreeList(CSpEventList * pList) +{ + CSpEventNode * pNode; + while ((pNode = pList->RemoveHead()) != NULL) + { + pNode->Clear(); + m_FreeList.InsertHead(pNode); + } +} +inline void CSpEventSource::_RemoveAllEvents( ) +{ + m_pParent->Lock(); + + _MoveAllToFreeList(&m_CompletedList); + _MoveAllToFreeList(&m_PendingList); + m_pParent->Unlock(); +} + +inline HRESULT CSpEventSource::_GetStreamNumber(const ULONGLONG ullAudioOffset, ULONG *pulStreamNum) +{ + CSpEventNode *pNode = m_PendingList.m_pHead; + *pulStreamNum = m_ulStreamNum; + for(;pNode && pNode->ullAudioStreamOffset <= ullAudioOffset; pNode = pNode->m_pNext) + { + *pulStreamNum = pNode->ulStreamNum; + } + return S_OK; +} + + + +#endif //--- This must be the last line in this file diff --git a/speech2/third_party/sapi5/include/sphelper.h b/speech2/third_party/sapi5/include/sphelper.h new file mode 100644 index 0000000..fae6a45 --- /dev/null +++ b/speech2/third_party/sapi5/include/sphelper.h @@ -0,0 +1,2753 @@ +/******************************************************************************* +* SPHelper.h * +*------------* +* Description: +* This is the header file for core helper functions implementation. +*------------------------------------------------------------------------------- +* Copyright (c) Microsoft Corporation. All rights reserved. +*******************************************************************************/ +#ifndef SPHelper_h +#define SPHelper_h + +#ifndef _INC_MALLOC +#include +#endif + +#ifndef _INC_CRTDBG +#include +#endif + +#ifndef __sapi_h__ +#include +#endif + +#ifndef __sapiddk_h__ +#include +#endif + +#ifndef SPError_h +#include +#endif + +#ifndef SPDebug_h +#include +#endif + +#ifndef _INC_LIMITS +#include +#endif + +#ifndef _INC_MMSYSTEM +#include +#endif + +#ifndef __comcat_h__ +#include +#endif + +#ifndef _INC_MMREG +#include +#endif + +#ifndef __ATLBASE_H__ +#include +#endif + +//=== Constants ============================================================== +#define sp_countof(x) ((sizeof(x) / sizeof(*(x)))) + +/*** CSpDynamicString helper class +* +*/ +class CSpDynamicString +{ +public: + + WCHAR * m_psz; + CSpDynamicString() + { + m_psz = NULL; + } + CSpDynamicString(ULONG cchReserve) + { + m_psz = (WCHAR *)::CoTaskMemAlloc(cchReserve * sizeof(WCHAR)); + } + WCHAR * operator=(const CSpDynamicString& src) + { + if (m_psz != src.m_psz) + { + ::CoTaskMemFree(m_psz); + m_psz = src.Copy(); + } + return m_psz; + } + WCHAR * operator=(const WCHAR * pSrc) + { + Clear(); + if (pSrc) + { + ULONG cbNeeded = (wcslen(pSrc) + 1) * sizeof(WCHAR); + m_psz = (WCHAR *)::CoTaskMemAlloc(cbNeeded); + SPDBG_ASSERT(m_psz); + if (m_psz) + { + memcpy(m_psz, pSrc, cbNeeded); + } + } + return m_psz; + } + + WCHAR * operator=(const char * pSrc) + { + Clear(); + if (pSrc) + { + ULONG cbNeeded = (lstrlenA(pSrc) + 1) * sizeof(WCHAR); + m_psz = (WCHAR *)::CoTaskMemAlloc(cbNeeded); + SPDBG_ASSERT(m_psz); + if (m_psz) + { + ::MultiByteToWideChar(CP_ACP, 0, pSrc, -1, m_psz, cbNeeded/sizeof(WCHAR)); + } + } + return m_psz; + } + + WCHAR * operator=(REFGUID rguid) + { + Clear(); + ::StringFromCLSID(rguid, &m_psz); + return m_psz; + } + + + /*explicit*/ CSpDynamicString(const WCHAR * pSrc) + { + m_psz = NULL; + operator=(pSrc); + } + /*explicit*/ CSpDynamicString(const char * pSrc) + { + m_psz = NULL; + operator=(pSrc); + } + /*explicit*/ CSpDynamicString(const CSpDynamicString& src) + { + m_psz = src.Copy(); + } + /*explicit*/ CSpDynamicString(REFGUID rguid) + { + ::StringFromCLSID(rguid, &m_psz); + } + + + ~CSpDynamicString() + { + ::CoTaskMemFree(m_psz); + } + unsigned int Length() const + { + return (m_psz == NULL)? 0 : wcslen(m_psz); + } + + operator WCHAR * () const + { + return m_psz; + } + //The assert on operator& usually indicates a bug. If this is really + //what is needed, however, take the address of the m_psz member explicitly. + WCHAR ** operator&() + { + SPDBG_ASSERT(m_psz == NULL); + return &m_psz; + } + + WCHAR * Append(const WCHAR * pszSrc) + { + if (pszSrc) + { + ULONG lenSrc = wcslen(pszSrc); + if (lenSrc) + { + ULONG lenMe = Length(); + WCHAR *pszNew = (WCHAR *)::CoTaskMemAlloc((lenMe + lenSrc + 1) * sizeof(WCHAR)); + if (pszNew) + { + if (m_psz) // Could append to an empty string so check... + { + if (lenMe) + { + memcpy(pszNew, m_psz, lenMe * sizeof(WCHAR)); + } + ::CoTaskMemFree(m_psz); + } + memcpy(pszNew + lenMe, pszSrc, (lenSrc + 1) * sizeof(WCHAR)); + m_psz = pszNew; + } + else + { + SPDBG_ASSERT(FALSE); + } + } + } + return m_psz; + } + + WCHAR * Append(const WCHAR * pszSrc, const ULONG lenSrc) + { + if (pszSrc && lenSrc) + { + ULONG lenMe = Length(); + WCHAR *pszNew = (WCHAR *)::CoTaskMemAlloc((lenMe + lenSrc + 1) * sizeof(WCHAR)); + if (pszNew) + { + if (m_psz) // Could append to an empty string so check... + { + if (lenMe) + { + memcpy(pszNew, m_psz, lenMe * sizeof(WCHAR)); + } + ::CoTaskMemFree(m_psz); + } + memcpy(pszNew + lenMe, pszSrc, lenSrc * sizeof(WCHAR)); + *(pszNew + lenMe + lenSrc) = L'\0'; + m_psz = pszNew; + } + else + { + SPDBG_ASSERT(FALSE); + } + } + return m_psz; + } + + WCHAR * Append2(const WCHAR * pszSrc1, const WCHAR * pszSrc2) + { + ULONG lenSrc1 = pszSrc1 ? wcslen(pszSrc1) : 0; + ULONG lenSrc2 = pszSrc2 ? wcslen(pszSrc2) : 0; + + if (lenSrc1 || lenSrc2) + { + ULONG lenMe = Length(); + WCHAR *pszNew = (WCHAR *)::CoTaskMemAlloc((lenMe + lenSrc1 + lenSrc2 + 1) * sizeof(WCHAR)); + if (pszNew) + { + if (m_psz) // Could append to an empty string so check... + { + if (lenMe) + { + memcpy(pszNew, m_psz, lenMe * sizeof(WCHAR)); + } + ::CoTaskMemFree(m_psz); + } + // In both of these cases, we copy the trailing NULL so that we're sure it gets + // there (if lenSrc2 is 0 then we better copy it from pszSrc1). + if (lenSrc1) + { + memcpy(pszNew + lenMe, pszSrc1, (lenSrc1 + 1) * sizeof(WCHAR)); + } + if (lenSrc2) + { + memcpy(pszNew + lenMe + lenSrc1, pszSrc2, (lenSrc2 + 1) * sizeof(WCHAR)); + } + m_psz = pszNew; + } + else + { + SPDBG_ASSERT(FALSE); + } + } + return m_psz; + } + WCHAR * Copy() const + { + if (m_psz) + { + CSpDynamicString szNew(m_psz); + return szNew.Detach(); + } + return NULL; + } + CHAR * CopyToChar() const + { + if (m_psz) + { + CHAR* psz; + ULONG cbNeeded = ::WideCharToMultiByte(CP_ACP, 0, m_psz, -1, NULL, NULL, NULL, NULL); + psz = (CHAR *)::CoTaskMemAlloc(cbNeeded); + SPDBG_ASSERT(psz); + if (psz) + { + ::WideCharToMultiByte(CP_ACP, 0, m_psz, -1, psz, cbNeeded/sizeof(CHAR), NULL, NULL); + } + return psz; + } + return NULL; + } + void Attach(WCHAR * pszSrc) + { + SPDBG_ASSERT(m_psz == NULL); + m_psz = pszSrc; + } + WCHAR * Detach() + { + WCHAR * s = m_psz; + m_psz = NULL; + return s; + } + void Clear() + { + ::CoTaskMemFree(m_psz); + m_psz = NULL; + } + bool operator!() const + { + return (m_psz == NULL); + } + HRESULT CopyToBSTR(BSTR * pbstr) + { + if (m_psz) + { + *pbstr = ::SysAllocString(m_psz); + if (*pbstr == NULL) + { + return E_OUTOFMEMORY; + } + } + else + { + *pbstr = NULL; + } + return S_OK; + } + void TrimToSize(ULONG ulNumChars) + { + if (m_psz && ulNumChars < Length()) + { + m_psz[ulNumChars] = 0; + } + } + WCHAR * Compact() + { + if (m_psz) + { + ULONG cch = wcslen(m_psz); + m_psz = (WCHAR *)::CoTaskMemRealloc(m_psz, (cch + 1) * sizeof(WCHAR)); + } + return m_psz; + } + WCHAR * ClearAndGrowTo(ULONG cch) + { + if (m_psz) + { + Clear(); + } + m_psz = (WCHAR *)::CoTaskMemAlloc(cch * sizeof(WCHAR)); + return m_psz; + } + WCHAR * LTrim() + { + if (m_psz) + { + WCHAR * pszRead = m_psz; + while (iswspace(*pszRead)) + { + pszRead++; + } + if (pszRead != m_psz) + { + WCHAR * pszWrite = m_psz; + while (*pszRead) + { + *pszWrite++ = *pszRead++; + } + *pszWrite = '\0'; + } + } + return m_psz; + } + WCHAR * RTrim() + { + if (m_psz) + { + WCHAR * pszTail = m_psz + wcslen(m_psz); + WCHAR * pszZeroTerm = pszTail; + while (pszZeroTerm > m_psz && iswspace(pszZeroTerm[-1])) + { + pszZeroTerm--; + } + if (pszZeroTerm != pszTail) + { + *pszZeroTerm = '\0'; + } + } + return m_psz; + } + WCHAR * TrimBoth() + { + RTrim(); + return LTrim(); + } +}; + + + +// +// Simple inline function converts a ulong to a hex string. +// +inline void SpHexFromUlong(WCHAR * psz, ULONG ul) +{ + const static WCHAR szHexChars[] = L"0123456789ABCDEF"; + if (ul == 0) + { + psz[0] = L'0'; + psz[1] = 0; + } + else + { + ULONG ulChars = 1; + psz[0] = 0; + while (ul) + { + memmove(psz + 1, psz, ulChars * sizeof(WCHAR)); + psz[0] = szHexChars[ul % 16]; + ul /= 16; + ulChars++; + } + } +} + + +//=== Token helpers + +inline HRESULT SpGetTokenFromId( + const WCHAR * pszTokenId, + ISpObjectToken ** ppToken, + BOOL fCreateIfNotExist = FALSE) +{ + SPDBG_FUNC("SpGetTokenFromId"); + HRESULT hr; + + CComPtr cpToken; + hr = cpToken.CoCreateInstance(CLSID_SpObjectToken); + + if (SUCCEEDED(hr)) + { + hr = cpToken->SetId(NULL, pszTokenId, fCreateIfNotExist); + } + + if (SUCCEEDED(hr)) + { + *ppToken = cpToken.Detach(); + } + + if (hr != SPERR_NOT_FOUND) + { + SPDBG_REPORT_ON_FAIL(hr); + } + + return hr; +} + +inline HRESULT SpGetCategoryFromId( + const WCHAR * pszCategoryId, + ISpObjectTokenCategory ** ppCategory, + BOOL fCreateIfNotExist = FALSE) +{ + SPDBG_FUNC("SpGetCategoryFromId"); + HRESULT hr; + + CComPtr cpTokenCategory; + hr = cpTokenCategory.CoCreateInstance(CLSID_SpObjectTokenCategory); + + if (SUCCEEDED(hr)) + { + hr = cpTokenCategory->SetId(pszCategoryId, fCreateIfNotExist); + } + + if (SUCCEEDED(hr)) + { + *ppCategory = cpTokenCategory.Detach(); + } + + SPDBG_REPORT_ON_FAIL(hr); + return hr; +} + +inline HRESULT SpGetDefaultTokenIdFromCategoryId( + const WCHAR * pszCategoryId, + WCHAR ** ppszTokenId) +{ + SPDBG_FUNC("SpGetDefaultTokenFromCategoryId"); + HRESULT hr; + + CComPtr cpCategory; + hr = SpGetCategoryFromId(pszCategoryId, &cpCategory); + + if (SUCCEEDED(hr)) + { + hr = cpCategory->GetDefaultTokenId(ppszTokenId); + } + + return hr; +} + +inline HRESULT SpSetDefaultTokenIdForCategoryId( + const WCHAR * pszCategoryId, + const WCHAR * pszTokenId) +{ + SPDBG_FUNC("SpSetDefaultTokenIdForCategoryId"); + HRESULT hr; + + CComPtr cpCategory; + hr = SpGetCategoryFromId(pszCategoryId, &cpCategory); + + if (SUCCEEDED(hr)) + { + hr = cpCategory->SetDefaultTokenId(pszTokenId); + } + + return hr; +} + +inline HRESULT SpGetDefaultTokenFromCategoryId( + const WCHAR * pszCategoryId, + ISpObjectToken ** ppToken, + BOOL fCreateCategoryIfNotExist = TRUE) +{ + SPDBG_FUNC("SpGetDefaultTokenFromCategoryId"); + HRESULT hr; + + CComPtr cpCategory; + hr = SpGetCategoryFromId(pszCategoryId, &cpCategory, fCreateCategoryIfNotExist); + + if (SUCCEEDED(hr)) + { + WCHAR * pszTokenId; + hr = cpCategory->GetDefaultTokenId(&pszTokenId); + if (SUCCEEDED(hr)) + { + hr = SpGetTokenFromId(pszTokenId, ppToken); + ::CoTaskMemFree(pszTokenId); + } + } + + return hr; +} + +inline HRESULT SpSetDefaultTokenForCategoryId( + const WCHAR * pszCategoryId, + ISpObjectToken * pToken) +{ + SPDBG_FUNC("SpSetDefaultTokenForCategoryId"); + HRESULT hr; + + WCHAR * pszTokenId; + hr = pToken->GetId(&pszTokenId); + + if (SUCCEEDED(hr)) + { + hr = SpSetDefaultTokenIdForCategoryId(pszCategoryId, pszTokenId); + ::CoTaskMemFree(pszTokenId); + } + + return hr; +} + +inline HRESULT SpSetCommonTokenData( + ISpObjectToken * pToken, + const CLSID * pclsid, + const WCHAR * pszLangIndependentName, + LANGID langid, + const WCHAR * pszLangDependentName, + ISpDataKey ** ppDataKeyAttribs) +{ + SPDBG_FUNC("SpSetCommonTokenData"); + HRESULT hr = S_OK; + + // Set the new token's CLSID (if specified) + if (SUCCEEDED(hr) && pclsid) + { + CSpDynamicString dstrClsid; + hr = StringFromCLSID(*pclsid, &dstrClsid); + + if (SUCCEEDED(hr)) + { + hr = pToken->SetStringValue(SPTOKENVALUE_CLSID, dstrClsid); + } + } + + // Set the token's lang independent name + if (SUCCEEDED(hr) && pszLangIndependentName) + { + hr = pToken->SetStringValue(NULL, pszLangIndependentName); + } + + // Set the token's lang dependent name + if (SUCCEEDED(hr) && pszLangDependentName) + { + USES_CONVERSION; + + TCHAR szLangId[10]; + wsprintf(szLangId, _T("%x"), langid); + + hr = pToken->SetStringValue(T2W(szLangId), pszLangDependentName); + } + + // Open the attributes key if requested + if (SUCCEEDED(hr) && ppDataKeyAttribs) + { + hr = pToken->CreateKey(L"Attributes", ppDataKeyAttribs); + } + + SPDBG_REPORT_ON_FAIL(hr); + return hr; +} + +inline HRESULT SpCreateNewToken( + const WCHAR * pszTokenId, + ISpObjectToken ** ppToken) +{ + SPDBG_FUNC("SpCreateNewToken"); + HRESULT hr; + + // Forcefully create the token + hr = SpGetTokenFromId(pszTokenId, ppToken, TRUE); + + SPDBG_REPORT_ON_FAIL(hr); + return hr; +} + +inline HRESULT SpCreateNewToken( + const WCHAR * pszCategoryId, + const WCHAR * pszTokenKeyName, + ISpObjectToken ** ppToken) +{ + SPDBG_FUNC("SpCreateNewToken"); + HRESULT hr; + + // Forcefully create the category + CComPtr cpCategory; + hr = SpGetCategoryFromId(pszCategoryId, &cpCategory, TRUE); + + // Come up with a token key name if one wasn't specified + CSpDynamicString dstrTokenKeyName; + if (SUCCEEDED(hr)) + { + if (pszTokenKeyName == NULL) + { + GUID guidTokenKeyName; + hr = CoCreateGuid(&guidTokenKeyName); + + if (SUCCEEDED(hr)) + { + hr = StringFromCLSID(guidTokenKeyName, &dstrTokenKeyName); + } + + if (SUCCEEDED(hr)) + { + pszTokenKeyName = dstrTokenKeyName; + } + } + } + + // Build the token id + CSpDynamicString dstrTokenId; + if (SUCCEEDED(hr)) + { + dstrTokenId = pszCategoryId; + dstrTokenId.Append2(L"\\Tokens\\", pszTokenKeyName); + } + + // Forcefully create the token + if (SUCCEEDED(hr)) + { + hr = SpGetTokenFromId(dstrTokenId, ppToken, TRUE); + } + + SPDBG_REPORT_ON_FAIL(hr); + return hr; +} + +inline HRESULT SpCreateNewTokenEx( + const WCHAR * pszCategoryId, + const WCHAR * pszTokenKeyName, + const CLSID * pclsid, + const WCHAR * pszLangIndependentName, + LANGID langid, + const WCHAR * pszLangDependentName, + ISpObjectToken ** ppToken, + ISpDataKey ** ppDataKeyAttribs) +{ + SPDBG_FUNC("SpCreateNewTokenEx"); + HRESULT hr; + + // Create the new token + hr = SpCreateNewToken(pszCategoryId, pszTokenKeyName, ppToken); + + // Now set the extra data + if (SUCCEEDED(hr)) + { + hr = SpSetCommonTokenData( + *ppToken, + pclsid, + pszLangIndependentName, + langid, + pszLangDependentName, + ppDataKeyAttribs); + } + + SPDBG_REPORT_ON_FAIL(hr); + return hr; +} + +inline HRESULT SpCreateNewTokenEx( + const WCHAR * pszTokenId, + const CLSID * pclsid, + const WCHAR * pszLangIndependentName, + LANGID langid, + const WCHAR * pszLangDependentName, + ISpObjectToken ** ppToken, + ISpDataKey ** ppDataKeyAttribs) +{ + SPDBG_FUNC("SpCreateNewTokenEx"); + HRESULT hr; + + // Create the new token + hr = SpCreateNewToken(pszTokenId, ppToken); + + // Now set the extra data + if (SUCCEEDED(hr)) + { + hr = SpSetCommonTokenData( + *ppToken, + pclsid, + pszLangIndependentName, + langid, + pszLangDependentName, + ppDataKeyAttribs); + } + + SPDBG_REPORT_ON_FAIL(hr); + return hr; +} + +inline HRESULT SpEnumTokens( + const WCHAR * pszCategoryId, + const WCHAR * pszReqAttribs, + const WCHAR * pszOptAttribs, + IEnumSpObjectTokens ** ppEnum) +{ + SPDBG_FUNC("SpEnumTokens"); + HRESULT hr = S_OK; + + CComPtr cpCategory; + hr = SpGetCategoryFromId(pszCategoryId, &cpCategory); + + if (SUCCEEDED(hr)) + { + hr = cpCategory->EnumTokens( + pszReqAttribs, + pszOptAttribs, + ppEnum); + } + + SPDBG_REPORT_ON_FAIL(hr); + return hr; +} + +inline HRESULT SpFindBestToken( + const WCHAR * pszCategoryId, + const WCHAR * pszReqAttribs, + const WCHAR * pszOptAttribs, + ISpObjectToken **ppObjectToken) +{ + SPDBG_FUNC("SpFindBestToken"); + HRESULT hr = S_OK; + + const WCHAR *pszVendorPreferred = L"VendorPreferred"; + const ulLenVendorPreferred = wcslen(pszVendorPreferred); + + // append VendorPreferred to the end of pszOptAttribs to force this preference + ULONG ulLen = pszOptAttribs ? wcslen(pszOptAttribs) + ulLenVendorPreferred + 1 : ulLenVendorPreferred; + WCHAR *pszOptAttribsVendorPref = (WCHAR*)_alloca((ulLen+1)*sizeof(WCHAR)); + if (pszOptAttribsVendorPref) + { + if (pszOptAttribs) + { + wcscpy(pszOptAttribsVendorPref, pszOptAttribs); + wcscat(pszOptAttribsVendorPref, L";"); + wcscat(pszOptAttribsVendorPref, pszVendorPreferred); + } + else + { + wcscpy(pszOptAttribsVendorPref, pszVendorPreferred); + } + } + else + { + hr = E_OUTOFMEMORY; + } + + CComPtr cpEnum; + if (SUCCEEDED(hr)) + { + hr = SpEnumTokens(pszCategoryId, pszReqAttribs, pszOptAttribsVendorPref, &cpEnum); + } + + if (SUCCEEDED(hr)) + { + hr = cpEnum->Next(1, ppObjectToken, NULL); + if (hr == S_FALSE) + { + *ppObjectToken = NULL; + hr = SPERR_NOT_FOUND; + } + } + + if (hr != SPERR_NOT_FOUND) + { + SPDBG_REPORT_ON_FAIL(hr); + } + + return hr; +} + +template +HRESULT SpCreateObjectFromToken(ISpObjectToken * pToken, T ** ppObject, + IUnknown * pUnkOuter = NULL, DWORD dwClsCtxt = CLSCTX_ALL) +{ + SPDBG_FUNC("SpCreateObjectFromToken"); + HRESULT hr; + + hr = pToken->CreateInstance(pUnkOuter, dwClsCtxt, __uuidof(T), (void **)ppObject); + + SPDBG_REPORT_ON_FAIL(hr); + return hr; +} + +template +HRESULT SpCreateObjectFromTokenId(const WCHAR * pszTokenId, T ** ppObject, + IUnknown * pUnkOuter = NULL, DWORD dwClsCtxt = CLSCTX_ALL) +{ + SPDBG_FUNC("SpCreateObjectFromTokenId"); + + ISpObjectToken * pToken; + HRESULT hr = SpGetTokenFromId(pszTokenId, &pToken); + if (SUCCEEDED(hr)) + { + hr = SpCreateObjectFromToken(pToken, ppObject, pUnkOuter, dwClsCtxt); + pToken->Release(); + } + + SPDBG_REPORT_ON_FAIL(hr); + return hr; +} + +template +HRESULT SpCreateDefaultObjectFromCategoryId(const WCHAR * pszCategoryId, T ** ppObject, + IUnknown * pUnkOuter = NULL, DWORD dwClsCtxt = CLSCTX_ALL) +{ + SPDBG_FUNC("SpCreateObjectFromTokenId"); + + ISpObjectToken * pToken; + HRESULT hr = SpGetDefaultTokenFromCategoryId(pszCategoryId, &pToken); + if (SUCCEEDED(hr)) + { + hr = SpCreateObjectFromToken(pToken, ppObject, pUnkOuter, dwClsCtxt); + pToken->Release(); + } + + SPDBG_REPORT_ON_FAIL(hr); + return hr; +} + +template +HRESULT SpCreateBestObject( + const WCHAR * pszCategoryId, + const WCHAR * pszReqAttribs, + const WCHAR * pszOptAttribs, + T ** ppObject, + IUnknown * pUnkOuter = NULL, + DWORD dwClsCtxt = CLSCTX_ALL) +{ + SPDBG_FUNC("SpCreateBestObject"); + HRESULT hr; + + CComPtr cpToken; + hr = SpFindBestToken(pszCategoryId, pszReqAttribs, pszOptAttribs, &cpToken); + + if (SUCCEEDED(hr)) + { + hr = SpCreateObjectFromToken(cpToken, ppObject, pUnkOuter, dwClsCtxt); + } + + if (hr != SPERR_NOT_FOUND) + { + SPDBG_REPORT_ON_FAIL(hr); + } + + return hr; +} + +inline HRESULT SpCreatePhoneConverter( + LANGID LangID, + const WCHAR * pszReqAttribs, + const WCHAR * pszOptAttribs, + ISpPhoneConverter ** ppPhoneConverter) +{ + SPDBG_FUNC("SpCreatePhoneConverter"); + HRESULT hr; + + if (LangID == 0) + { + hr = E_INVALIDARG; + } + else + { + CSpDynamicString dstrReqAttribs; + if (pszReqAttribs) + { + dstrReqAttribs = pszReqAttribs; + dstrReqAttribs.Append(L";"); + } + + WCHAR szLang[MAX_PATH]; + + SpHexFromUlong(szLang, LangID); + + WCHAR szLangCondition[MAX_PATH]; + wcscpy(szLangCondition, L"Language="); + wcscat(szLangCondition, szLang); + + dstrReqAttribs.Append(szLangCondition); + + hr = SpCreateBestObject(SPCAT_PHONECONVERTERS, dstrReqAttribs, pszOptAttribs, ppPhoneConverter); + } + + if (hr != SPERR_NOT_FOUND) + { + SPDBG_REPORT_ON_FAIL(hr); + } + + return hr; +} + +/**************************************************************************** +* SpHrFromWin32 * +*---------------* +* Description: +* This inline function works around a basic problem with the macro +* HRESULT_FROM_WIN32. The macro forces the expresion in ( ) to be evaluated +* two times. By using this inline function, the expression will only be +* evaluated once. +* +* Returns: +* HRESULT of converted Win32 error code +* +*****************************************************************************/ + +inline HRESULT SpHrFromWin32(DWORD dwErr) +{ + return HRESULT_FROM_WIN32(dwErr); +} + + +/**************************************************************************** +* SpHrFromLastWin32Error * +*------------------------* +* Description: +* This simple inline function is used to return a converted HRESULT +* from the Win32 function ::GetLastError. Note that using HRESULT_FROM_WIN32 +* will evaluate the error code twice so we don't want to use: +* +* HRESULT_FROM_WIN32(::GetLastError()) +* +* since that will call GetLastError twice. +* On Win98 and WinMe ::GetLastError() returns 0 for some functions (see MSDN). +* We therefore check for that and return E_FAIL. This function should only be +* called in an error case since it will always return an error code! +* +* Returns: +* HRESULT for ::GetLastError() +* +*****************************************************************************/ + +inline HRESULT SpHrFromLastWin32Error() +{ + DWORD dw = ::GetLastError(); + return (dw == 0) ? E_FAIL : SpHrFromWin32(dw); +} + + +/**************************************************************************** +* SpGetUserDefaultUILanguage * +*----------------------------* +* Description: +* Returns the default user interface language, using a method +* appropriate to the platform (Windows 9x, Windows NT, or Windows 2000) +* +* Returns: +* Default UI language +* +*****************************************************************************/ + +inline LANGID SpGetUserDefaultUILanguage(void) +{ + HRESULT hr = S_OK; + LANGID wUILang = 0; + + OSVERSIONINFO Osv ; + Osv.dwOSVersionInfoSize = sizeof(Osv) ; + if(!GetVersionEx(&Osv)) + { + hr = SpHrFromLastWin32Error(); + } + // Get the UI language by one of three methods, depending on the system + else if(Osv.dwPlatformId != VER_PLATFORM_WIN32_NT) + { + // Case 1: Running on Windows 9x. Get the system UI language from registry: + CHAR szData[32]; + DWORD dwSize = sizeof(szData) ; + HKEY hKey; + + long lRet = RegOpenKeyEx( + HKEY_USERS, + _T(".Default\\Control Panel\\desktop\\ResourceLocale"), + 0, + KEY_READ, + &hKey); + +#ifdef _WIN32_WCE_BUG_10655 + if (lRet == ERROR_INVALID_PARAMETER) + { + lRet = ERROR_FILE_NOT_FOUND; + } +#endif // _WIN32_WCE_BUG_10655 + + hr = SpHrFromWin32(lRet); + + if (SUCCEEDED(hr)) + { + lRet = RegQueryValueEx( + hKey, + _T(""), + NULL, + NULL, + (BYTE *)szData, + &dwSize); + +#ifdef _WIN32_WCE_BUG_10655 + if(lRet == ERROR_INVALID_PARAMETER) + { + lRet = ERROR_FILE_NOT_FOUND; + } +#endif //_WIN32_WCE_BUG_10655 + + hr = SpHrFromWin32(lRet); + ::RegCloseKey(hKey) ; + } + if (SUCCEEDED(hr)) + { + // Convert string to number + wUILang = (LANGID) strtol(szData, NULL, 16) ; + } + } + else if (Osv.dwMajorVersion >= 5.0) + { + // Case 2: Running on Windows 2000 or later. Use GetUserDefaultUILanguage to find + // the user's prefered UI language + + + HMODULE hMKernel32 = ::LoadLibraryW(L"kernel32.dll") ; + if (hMKernel32 == NULL) + { + hr = SpHrFromLastWin32Error(); + } + else + { + + LANGID (WINAPI *pfnGetUserDefaultUILanguage) () = + (LANGID (WINAPI *)(void)) +#ifdef _WIN32_WCE + GetProcAddress(hMKernel32, L"GetUserDefaultUILanguage") ; +#else + GetProcAddress(hMKernel32, "GetUserDefaultUILanguage") ; +#endif + + if(NULL != pfnGetUserDefaultUILanguage) + { + wUILang = pfnGetUserDefaultUILanguage() ; + } + else + { // GetProcAddress failed + hr = SpHrFromLastWin32Error(); + } + ::FreeLibrary(hMKernel32); + } + } + else { + // Case 3: Running on Windows NT 4.0 or earlier. Get UI language + // from locale of .default user in registry: + // HKEY_USERS\.DEFAULT\Control Panel\International\Locale + + WCHAR szData[32] ; + DWORD dwSize = sizeof(szData) ; + HKEY hKey ; + + LONG lRet = RegOpenKeyEx(HKEY_USERS, + _T(".DEFAULT\\Control Panel\\International"), + 0, + KEY_READ, + &hKey); +#ifdef _WIN32_WCE_BUG_10655 + if(lRet == ERROR_INVALID_PARAMETER) + { + lRet = ERROR_FILE_NOT_FOUND; + } +#endif //_WIN32_WCE_BUG_10655 + + hr = SpHrFromWin32(lRet); + + if (SUCCEEDED(hr)) + { + lRet = RegQueryValueEx( + hKey, + _T("Locale"), + NULL, + NULL, + (BYTE *)szData, + &dwSize); + +#ifdef _WIN32_WCE_BUG_10655 + if(lRet == ERROR_INVALID_PARAMETER) + { + lRet = ERROR_FILE_NOT_FOUND; + } +#endif //_WIN32_WCE_BUG_10655 + + hr = SpHrFromWin32(lRet); + ::RegCloseKey(hKey); + } + + if (SUCCEEDED(hr)) + { + // Convert string to number + wUILang = (LANGID) wcstol(szData, NULL, 16) ; + + if(0x0401 == wUILang || // Arabic + 0x040d == wUILang || // Hebrew + 0x041e == wUILang // Thai + ) + { + // Special case these to the English UI. + // These versions of Windows NT 4.0 were enabled only, i.e., the + // UI was English. However, the registry setting + // HKEY_USERS\.DEFAULT\Control Panel\International\Locale was set + // to the respective locale for application compatibility. + wUILang = MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US) ; + } + } + } + + return (wUILang ? wUILang : ::GetUserDefaultLangID()); // In failure case, try our best! +} + + +inline HRESULT SpGetDescription(ISpObjectToken * pObjToken, WCHAR ** ppszDescription, LANGID Language = SpGetUserDefaultUILanguage()) +{ + WCHAR szLangId[10]; + SpHexFromUlong(szLangId, Language); + HRESULT hr = pObjToken->GetStringValue(szLangId, ppszDescription); + if (hr == SPERR_NOT_FOUND) + { + hr = pObjToken->GetStringValue(NULL, ppszDescription); + } + return hr; +} + + +inline HRESULT SpSetDescription(ISpObjectToken * pObjToken, const WCHAR * pszDescription, LANGID Language = SpGetUserDefaultUILanguage(), BOOL fSetLangIndependentId = TRUE) +{ + WCHAR szLangId[10]; + SpHexFromUlong(szLangId, Language); + HRESULT hr = pObjToken->SetStringValue(szLangId, pszDescription); + if (SUCCEEDED(hr) && fSetLangIndependentId) + { + hr = pObjToken->SetStringValue(NULL, pszDescription); + } + return hr; +} + +/**************************************************************************** +* SpConvertStreamFormatEnum * +*---------------------------* +* Description: +* This method converts the specified stream format into a wave format +* structure. +* +*****************************************************************************/ +inline HRESULT SpConvertStreamFormatEnum(SPSTREAMFORMAT eFormat, GUID * pFormatId, WAVEFORMATEX ** ppCoMemWaveFormatEx) +{ + HRESULT hr = S_OK; + + if(pFormatId==NULL || ::IsBadWritePtr(pFormatId, sizeof(*pFormatId)) + || ppCoMemWaveFormatEx==NULL || ::IsBadWritePtr(ppCoMemWaveFormatEx, sizeof(*ppCoMemWaveFormatEx))) + { + return E_INVALIDARG; + } + + const GUID * pFmtGuid = &GUID_NULL; // Assume failure case + if( eFormat >= SPSF_8kHz8BitMono && eFormat <= SPSF_48kHz16BitStereo ) + { + WAVEFORMATEX * pwfex = (WAVEFORMATEX *)::CoTaskMemAlloc(sizeof(WAVEFORMATEX)); + *ppCoMemWaveFormatEx = pwfex; + if (pwfex) + { + DWORD dwIndex = eFormat - SPSF_8kHz8BitMono; + BOOL bIsStereo = dwIndex & 0x1; + BOOL bIs16 = dwIndex & 0x2; + DWORD dwKHZ = (dwIndex & 0x3c) >> 2; + static const DWORD adwKHZ[] = { 8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000 }; + pwfex->wFormatTag = WAVE_FORMAT_PCM; + pwfex->nChannels = pwfex->nBlockAlign = (WORD)(bIsStereo ? 2 : 1); + pwfex->nSamplesPerSec = adwKHZ[dwKHZ]; + pwfex->wBitsPerSample = 8; + if (bIs16) + { + pwfex->wBitsPerSample *= 2; + pwfex->nBlockAlign *= 2; + } + pwfex->nAvgBytesPerSec = pwfex->nSamplesPerSec * pwfex->nBlockAlign; + pwfex->cbSize = 0; + pFmtGuid = &SPDFID_WaveFormatEx; + } + else + { + hr = E_OUTOFMEMORY; + } + } + else if( eFormat == SPSF_TrueSpeech_8kHz1BitMono ) + { + int NumBytes = sizeof( WAVEFORMATEX ) + 32; + WAVEFORMATEX * pwfex = (WAVEFORMATEX *)::CoTaskMemAlloc( NumBytes ); + *ppCoMemWaveFormatEx = pwfex; + if( pwfex ) + { + memset( pwfex, 0, NumBytes ); + pwfex->wFormatTag = WAVE_FORMAT_DSPGROUP_TRUESPEECH; + pwfex->nChannels = 1; + pwfex->nSamplesPerSec = 8000; + pwfex->nAvgBytesPerSec = 1067; + pwfex->nBlockAlign = 32; + pwfex->wBitsPerSample = 1; + pwfex->cbSize = 32; + BYTE* pExtra = ((BYTE*)pwfex) + sizeof( WAVEFORMATEX ); + pExtra[0] = 1; + pExtra[2] = 0xF0; + pFmtGuid = &SPDFID_WaveFormatEx; + } + else + { + hr = E_OUTOFMEMORY; + } + } + else if( (eFormat >= SPSF_CCITT_ALaw_8kHzMono ) && + (eFormat <= SPSF_CCITT_ALaw_44kHzStereo ) ) + { + WAVEFORMATEX * pwfex = (WAVEFORMATEX *)::CoTaskMemAlloc( sizeof(WAVEFORMATEX) ); + *ppCoMemWaveFormatEx = pwfex; + if( pwfex ) + { + memset( pwfex, 0, sizeof(WAVEFORMATEX) ); + DWORD dwIndex = eFormat - SPSF_CCITT_ALaw_8kHzMono; + DWORD dwKHZ = dwIndex / 2; + static const DWORD adwKHZ[] = { 8000, 11025, 22050, 44100 }; + BOOL bIsStereo = dwIndex & 0x1; + pwfex->wFormatTag = WAVE_FORMAT_ALAW; + pwfex->nChannels = pwfex->nBlockAlign = (WORD)(bIsStereo ? 2 : 1); + pwfex->nSamplesPerSec = adwKHZ[dwKHZ]; + pwfex->wBitsPerSample = 8; + pwfex->nAvgBytesPerSec = pwfex->nSamplesPerSec * pwfex->nBlockAlign; + pwfex->cbSize = 0; + pFmtGuid = &SPDFID_WaveFormatEx; + } + else + { + hr = E_OUTOFMEMORY; + } + } + else if( (eFormat >= SPSF_CCITT_uLaw_8kHzMono ) && + (eFormat <= SPSF_CCITT_uLaw_44kHzStereo ) ) + { + WAVEFORMATEX * pwfex = (WAVEFORMATEX *)::CoTaskMemAlloc( sizeof(WAVEFORMATEX) ); + *ppCoMemWaveFormatEx = pwfex; + if( pwfex ) + { + memset( pwfex, 0, sizeof(WAVEFORMATEX) ); + DWORD dwIndex = eFormat - SPSF_CCITT_uLaw_8kHzMono; + DWORD dwKHZ = dwIndex / 2; + static const DWORD adwKHZ[] = { 8000, 11025, 22050, 44100 }; + BOOL bIsStereo = dwIndex & 0x1; + pwfex->wFormatTag = WAVE_FORMAT_MULAW; + pwfex->nChannels = pwfex->nBlockAlign = (WORD)(bIsStereo ? 2 : 1); + pwfex->nSamplesPerSec = adwKHZ[dwKHZ]; + pwfex->wBitsPerSample = 8; + pwfex->nAvgBytesPerSec = pwfex->nSamplesPerSec * pwfex->nBlockAlign; + pwfex->cbSize = 0; + pFmtGuid = &SPDFID_WaveFormatEx; + } + else + { + hr = E_OUTOFMEMORY; + } + } + else if( (eFormat >= SPSF_ADPCM_8kHzMono ) && + (eFormat <= SPSF_ADPCM_44kHzStereo ) ) + { + int NumBytes = sizeof( WAVEFORMATEX ) + 32; + WAVEFORMATEX * pwfex = (WAVEFORMATEX *)::CoTaskMemAlloc( NumBytes ); + *ppCoMemWaveFormatEx = pwfex; + if( pwfex ) + { + //--- Some of these values seem odd. We used what the codec told us. + static const DWORD adwKHZ[] = { 8000, 11025, 22050, 44100 }; + static const DWORD BytesPerSec[] = { 4096, 8192, 5644, 11289, 11155, 22311, 22179, 44359 }; + static const DWORD BlockAlign[] = { 256, 256, 512, 1024 }; + static const BYTE Extra811[32] = + { + 0xF4, 0x01, 0x07, 0x00, 0x00, 0x01, 0x00, 0x00, + 0x00, 0x02, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0x40, 0x00, 0xF0, 0x00, 0x00, 0x00, + 0xCC, 0x01, 0x30, 0xFF, 0x88, 0x01, 0x18, 0xFF + }; + + static const BYTE Extra22[32] = + { + 0xF4, 0x03, 0x07, 0x00, 0x00, 0x01, 0x00, 0x00, + 0x00, 0x02, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0x40, 0x00, 0xF0, 0x00, 0x00, 0x00, + 0xCC, 0x01, 0x30, 0xFF, 0x88, 0x01, 0x18, 0xFF + }; + + static const BYTE Extra44[32] = + { + 0xF4, 0x07, 0x07, 0x00, 0x00, 0x01, 0x00, 0x00, + 0x00, 0x02, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0x40, 0x00, 0xF0, 0x00, 0x00, 0x00, + 0xCC, 0x01, 0x30, 0xFF, 0x88, 0x01, 0x18, 0xFF + }; + + static const BYTE* Extra[4] = { Extra811, Extra811, Extra22, Extra44 }; + memset( pwfex, 0, NumBytes ); + DWORD dwIndex = eFormat - SPSF_ADPCM_8kHzMono; + DWORD dwKHZ = dwIndex / 2; + BOOL bIsStereo = dwIndex & 0x1; + pwfex->wFormatTag = WAVE_FORMAT_ADPCM; + pwfex->nChannels = (WORD)(bIsStereo ? 2 : 1); + pwfex->nSamplesPerSec = adwKHZ[dwKHZ]; + pwfex->nAvgBytesPerSec = BytesPerSec[dwIndex]; + pwfex->nBlockAlign = (WORD)(BlockAlign[dwKHZ] * pwfex->nChannels); + pwfex->wBitsPerSample = 4; + pwfex->cbSize = 32; + BYTE* pExtra = ((BYTE*)pwfex) + sizeof( WAVEFORMATEX ); + memcpy( pExtra, Extra[dwKHZ], 32 ); + pFmtGuid = &SPDFID_WaveFormatEx; + } + else + { + hr = E_OUTOFMEMORY; + } + } + else if( (eFormat >= SPSF_GSM610_8kHzMono ) && + (eFormat <= SPSF_GSM610_44kHzMono ) ) + { + int NumBytes = sizeof( WAVEFORMATEX ) + 2; + WAVEFORMATEX * pwfex = (WAVEFORMATEX *)::CoTaskMemAlloc( NumBytes ); + *ppCoMemWaveFormatEx = pwfex; + if( pwfex ) + { + //--- Some of these values seem odd. We used what the codec told us. + static const DWORD adwKHZ[] = { 8000, 11025, 22050, 44100 }; + static const DWORD BytesPerSec[] = { 1625, 2239, 4478, 8957 }; + memset( pwfex, 0, NumBytes ); + DWORD dwIndex = eFormat - SPSF_GSM610_8kHzMono; + pwfex->wFormatTag = WAVE_FORMAT_GSM610; + pwfex->nChannels = 1; + pwfex->nSamplesPerSec = adwKHZ[dwIndex]; + pwfex->nAvgBytesPerSec = BytesPerSec[dwIndex]; + pwfex->nBlockAlign = 65; + pwfex->wBitsPerSample = 0; + pwfex->cbSize = 2; + BYTE* pExtra = ((BYTE*)pwfex) + sizeof( WAVEFORMATEX ); + pExtra[0] = 0x40; + pExtra[1] = 0x01; + pFmtGuid = &SPDFID_WaveFormatEx; + } + else + { + hr = E_OUTOFMEMORY; + } + } + else + { + *ppCoMemWaveFormatEx = NULL; + switch (eFormat) + { + case SPSF_NoAssignedFormat: + break; + case SPSF_Text: + pFmtGuid = &SPDFID_Text; + break; + default: + hr = E_INVALIDARG; + break; + } + } + *pFormatId = *pFmtGuid; + return hr; +} + +class CSpStreamFormat +{ +public: + GUID m_guidFormatId; + WAVEFORMATEX * m_pCoMemWaveFormatEx; + + + static CoMemCopyWFEX(const WAVEFORMATEX * pSrc, WAVEFORMATEX ** ppCoMemWFEX) + { + ULONG cb = sizeof(WAVEFORMATEX) + pSrc->cbSize; + *ppCoMemWFEX = (WAVEFORMATEX *)::CoTaskMemAlloc(cb); + if (*ppCoMemWFEX) + { + memcpy(*ppCoMemWFEX, pSrc, cb); + return S_OK; + } + else + { + return E_OUTOFMEMORY; + } + } + + + CSpStreamFormat() + { + m_guidFormatId = GUID_NULL; + m_pCoMemWaveFormatEx = NULL; + } + + CSpStreamFormat(SPSTREAMFORMAT eFormat, HRESULT * phr) + { + *phr = SpConvertStreamFormatEnum(eFormat, &m_guidFormatId, &m_pCoMemWaveFormatEx); + } + + CSpStreamFormat(const WAVEFORMATEX * pWaveFormatEx, HRESULT * phr) + { + SPDBG_ASSERT(pWaveFormatEx); + *phr = CoMemCopyWFEX(pWaveFormatEx, &m_pCoMemWaveFormatEx); + m_guidFormatId = SUCCEEDED(*phr) ? SPDFID_WaveFormatEx : GUID_NULL; + } + + ~CSpStreamFormat() + { + ::CoTaskMemFree(m_pCoMemWaveFormatEx); + } + + void Clear() + { + ::CoTaskMemFree(m_pCoMemWaveFormatEx); + m_pCoMemWaveFormatEx = NULL; + memset(&m_guidFormatId, 0, sizeof(m_guidFormatId)); + } + + const GUID & FormatId() const + { + return m_guidFormatId; + } + + const WAVEFORMATEX * WaveFormatExPtr() const + { + return m_pCoMemWaveFormatEx; + } + + + HRESULT AssignFormat(SPSTREAMFORMAT eFormat) + { + ::CoTaskMemFree(m_pCoMemWaveFormatEx); + return SpConvertStreamFormatEnum(eFormat, &m_guidFormatId, &m_pCoMemWaveFormatEx); + } + + HRESULT AssignFormat(ISpStreamFormat * pStream) + { + ::CoTaskMemFree(m_pCoMemWaveFormatEx); + m_pCoMemWaveFormatEx = NULL; + return pStream->GetFormat(&m_guidFormatId, &m_pCoMemWaveFormatEx); + } + + HRESULT AssignFormat(const WAVEFORMATEX * pWaveFormatEx) + { + ::CoTaskMemFree(m_pCoMemWaveFormatEx); + HRESULT hr = CoMemCopyWFEX(pWaveFormatEx, &m_pCoMemWaveFormatEx); + m_guidFormatId = SUCCEEDED(hr) ? SPDFID_WaveFormatEx : GUID_NULL; + return hr; + } + + HRESULT AssignFormat(REFGUID rguidFormatId, const WAVEFORMATEX * pWaveFormatEx) + { + HRESULT hr = S_OK; + + m_guidFormatId = rguidFormatId; + ::CoTaskMemFree(m_pCoMemWaveFormatEx); + m_pCoMemWaveFormatEx = NULL; + + if (rguidFormatId == SPDFID_WaveFormatEx) + { + if (::IsBadReadPtr(pWaveFormatEx, sizeof(*pWaveFormatEx))) + { + hr = E_INVALIDARG; + } + else + { + hr = CoMemCopyWFEX(pWaveFormatEx, &m_pCoMemWaveFormatEx); + } + + if (FAILED(hr)) + { + m_guidFormatId = GUID_NULL; + } + } + + return hr; + } + + + BOOL IsEqual(REFGUID rguidFormatId, const WAVEFORMATEX * pwfex) const + { + if (rguidFormatId == m_guidFormatId) + { + if (m_pCoMemWaveFormatEx) + { + if (pwfex && + pwfex->cbSize == m_pCoMemWaveFormatEx->cbSize && + memcmp(m_pCoMemWaveFormatEx, pwfex, sizeof(WAVEFORMATEX) + pwfex->cbSize) == 0) + { + return TRUE; + } + } + else + { + return (pwfex == NULL); + } + } + return FALSE; + } + + + + HRESULT ParamValidateAssignFormat(REFGUID rguidFormatId, const WAVEFORMATEX * pWaveFormatEx, BOOL fRequireWaveFormat = FALSE) + { + if ((pWaveFormatEx && (::IsBadReadPtr(pWaveFormatEx, sizeof(*pWaveFormatEx)) || rguidFormatId != SPDFID_WaveFormatEx)) || + (fRequireWaveFormat && pWaveFormatEx == NULL)) + { + return E_INVALIDARG; + } + return AssignFormat(rguidFormatId, pWaveFormatEx); + } + + SPSTREAMFORMAT ComputeFormatEnum() + { + if (m_guidFormatId == GUID_NULL) + { + return SPSF_NoAssignedFormat; + } + if (m_guidFormatId == SPDFID_Text) + { + return SPSF_Text; + } + if (m_guidFormatId != SPDFID_WaveFormatEx) + { + return SPSF_NonStandardFormat; + } + // + // It is a WAVEFORMATEX. Now determine which type it is and convert. + // + DWORD dwIndex = 0; + switch (m_pCoMemWaveFormatEx->wFormatTag) + { + case WAVE_FORMAT_PCM: + { + switch (m_pCoMemWaveFormatEx->nChannels) + { + case 1: + break; + case 2: + dwIndex |= 1; + break; + default: + return SPSF_ExtendedAudioFormat; + } + + switch (m_pCoMemWaveFormatEx->wBitsPerSample) + { + case 8: + break; + case 16: + dwIndex |= 2; + break; + default: + return SPSF_ExtendedAudioFormat; + } + + switch (m_pCoMemWaveFormatEx->nSamplesPerSec) + { + case 48000: + dwIndex += 4; // Fall through + case 44100: + dwIndex += 4; // Fall through + case 32000: + dwIndex += 4; // Fall through + case 24000: + dwIndex += 4; // Fall through + case 22050: + dwIndex += 4; // Fall through + case 16000: + dwIndex += 4; // Fall through + case 12000: + dwIndex += 4; // Fall through + case 11025: + dwIndex += 4; // Fall through + case 8000: + break; + default: + return SPSF_ExtendedAudioFormat; + } + + return static_cast(SPSF_8kHz8BitMono + dwIndex); + } + + case WAVE_FORMAT_DSPGROUP_TRUESPEECH: + { + return SPSF_TrueSpeech_8kHz1BitMono; + } + + case WAVE_FORMAT_ALAW: // fall through + case WAVE_FORMAT_MULAW: + case WAVE_FORMAT_ADPCM: + { + switch (m_pCoMemWaveFormatEx->nChannels) + { + case 1: + break; + case 2: + dwIndex |= 1; + break; + default: + return SPSF_ExtendedAudioFormat; + } + + if(m_pCoMemWaveFormatEx->wFormatTag == WAVE_FORMAT_ADPCM) + { + if(m_pCoMemWaveFormatEx->wBitsPerSample != 4) + { + return SPSF_ExtendedAudioFormat; + } + } + else if(m_pCoMemWaveFormatEx->wBitsPerSample != 8) + { + return SPSF_ExtendedAudioFormat; + } + + switch (m_pCoMemWaveFormatEx->nSamplesPerSec) + { + case 44100: + dwIndex += 2; // Fall through + case 22050: + dwIndex += 2; // Fall through + case 11025: + dwIndex += 2; // Fall through + case 8000: + break; + default: + return SPSF_ExtendedAudioFormat; + } + + switch( m_pCoMemWaveFormatEx->wFormatTag ) + { + case WAVE_FORMAT_ALAW: + return static_cast(SPSF_CCITT_ALaw_8kHzMono + dwIndex); + case WAVE_FORMAT_MULAW: + return static_cast(SPSF_CCITT_uLaw_8kHzMono + dwIndex); + case WAVE_FORMAT_ADPCM: + return static_cast(SPSF_ADPCM_8kHzMono + dwIndex); + } + } + + case WAVE_FORMAT_GSM610: + { + if( m_pCoMemWaveFormatEx->nChannels != 1 ) + { + return SPSF_ExtendedAudioFormat; + } + + switch (m_pCoMemWaveFormatEx->nSamplesPerSec) + { + case 44100: + dwIndex = 3; + break; + case 22050: + dwIndex = 2; + break; + case 11025: + dwIndex = 1; + break; + case 8000: + dwIndex = 0; + break; + default: + return SPSF_ExtendedAudioFormat; + } + + return static_cast(SPSF_GSM610_8kHzMono + dwIndex); + } + + default: + return SPSF_ExtendedAudioFormat; + break; + } + } + + void DetachTo(CSpStreamFormat & Other) + { + ::CoTaskMemFree(Other.m_pCoMemWaveFormatEx); + Other.m_guidFormatId = m_guidFormatId; + Other.m_pCoMemWaveFormatEx = m_pCoMemWaveFormatEx; + m_pCoMemWaveFormatEx = NULL; + memset(&m_guidFormatId, 0, sizeof(m_guidFormatId)); + } + + void DetachTo(GUID * pFormatId, WAVEFORMATEX ** ppCoMemWaveFormatEx) + { + *pFormatId = m_guidFormatId; + *ppCoMemWaveFormatEx = m_pCoMemWaveFormatEx; + m_pCoMemWaveFormatEx = NULL; + memset(&m_guidFormatId, 0, sizeof(m_guidFormatId)); + } + + HRESULT CopyTo(GUID * pFormatId, WAVEFORMATEX ** ppCoMemWFEX) const + { + HRESULT hr = S_OK; + *pFormatId = m_guidFormatId; + if (m_pCoMemWaveFormatEx) + { + hr = CoMemCopyWFEX(m_pCoMemWaveFormatEx, ppCoMemWFEX); + if (FAILED(hr)) + { + memset(pFormatId, 0, sizeof(*pFormatId)); + } + } + else + { + *ppCoMemWFEX = NULL; + } + return hr; + } + + HRESULT CopyTo(CSpStreamFormat & Other) const + { + ::CoTaskMemFree(Other.m_pCoMemWaveFormatEx); + return CopyTo(&Other.m_guidFormatId, &Other.m_pCoMemWaveFormatEx); + } + + HRESULT AssignFormat(const CSpStreamFormat & Src) + { + return Src.CopyTo(*this); + } + + + HRESULT ParamValidateCopyTo(GUID * pFormatId, WAVEFORMATEX ** ppCoMemWFEX) const + { + if (::IsBadWritePtr(pFormatId, sizeof(*pFormatId)) || + ::IsBadWritePtr(ppCoMemWFEX, sizeof(*ppCoMemWFEX))) + { + return E_POINTER; + } + return CopyTo(pFormatId, ppCoMemWFEX); + } + + BOOL operator==(const CSpStreamFormat & Other) const + { + return IsEqual(Other.m_guidFormatId, Other.m_pCoMemWaveFormatEx); + } + BOOL operator!=(const CSpStreamFormat & Other) const + { + return !IsEqual(Other.m_guidFormatId, Other.m_pCoMemWaveFormatEx); + } + + ULONG SerializeSize() const + { + ULONG cb = sizeof(ULONG) + sizeof(m_guidFormatId); + if (m_pCoMemWaveFormatEx) + { + cb += sizeof(WAVEFORMATEX) + m_pCoMemWaveFormatEx->cbSize + 3; // Add 3 to round up + cb -= cb % 4; // Round to DWORD + } + return cb; + } + + ULONG Serialize(BYTE * pBuffer) const + { + ULONG cb = SerializeSize(); + *((UNALIGNED ULONG *)pBuffer) = cb; + pBuffer += sizeof(ULONG); + *((UNALIGNED GUID *)pBuffer) = m_guidFormatId; + if (m_pCoMemWaveFormatEx) + { + pBuffer += sizeof(m_guidFormatId); + memcpy(pBuffer, m_pCoMemWaveFormatEx, sizeof(WAVEFORMATEX) + m_pCoMemWaveFormatEx->cbSize); + } + return cb; + } + + HRESULT Deserialize(const BYTE * pBuffer, ULONG * pcbUsed) + { + HRESULT hr = S_OK; + ::CoTaskMemFree(m_pCoMemWaveFormatEx); + m_pCoMemWaveFormatEx = NULL; + *pcbUsed = *((UNALIGNED ULONG *)pBuffer); + pBuffer += sizeof(ULONG); + // Misaligment exception is generated for SHx platform. + // Marking pointer as UNALIGNED does not help. +#ifndef _WIN32_WCE + m_guidFormatId = *((UNALIGNED GUID *)pBuffer); +#else + memcpy(&m_guidFormatId, pBuffer, sizeof(GUID)); +#endif + if (*pcbUsed > sizeof(GUID) + sizeof(ULONG)) + { + pBuffer += sizeof(m_guidFormatId); + hr = CoMemCopyWFEX((const WAVEFORMATEX *)pBuffer, &m_pCoMemWaveFormatEx); + if (FAILED(hr)) + { + m_guidFormatId = GUID_NULL; + } + } + return hr; + } + +}; + + + +// Return the default codepage given a LCID. +// Note some of the newer locales do not have associated Windows codepages. For these, we return UTF-8. + +inline UINT SpCodePageFromLcid(LCID lcid) +{ + char achCodePage[6]; + + return (0 != GetLocaleInfoA(lcid, LOCALE_IDEFAULTANSICODEPAGE, achCodePage, sizeof(achCodePage))) ? atoi(achCodePage) : 65001; +} + + +inline HRESULT SPBindToFile( LPCWSTR pFileName, SPFILEMODE eMode, ISpStream ** ppStream, + const GUID * pFormatId = NULL, const WAVEFORMATEX * pWaveFormatEx = NULL, + ULONGLONG ullEventInterest = SPFEI_ALL_EVENTS) +{ + HRESULT hr = ::CoCreateInstance(CLSID_SpStream, NULL, CLSCTX_ALL, __uuidof(*ppStream), (void **)ppStream); + if (SUCCEEDED(hr)) + { + hr = (*ppStream)->BindToFile(pFileName, eMode, pFormatId, pWaveFormatEx, ullEventInterest); + if (FAILED(hr)) + { + (*ppStream)->Release(); + *ppStream = NULL; + } + } + return hr; +} /* SPBindToFile */ + +#ifndef _UNICODE +inline HRESULT SPBindToFile( const TCHAR * pFileName, SPFILEMODE eMode, ISpStream** ppStream, + const GUID * pFormatId = NULL, const WAVEFORMATEX * pWaveFormatEx = NULL, + ULONGLONG ullEventInterest = SPFEI_ALL_EVENTS) +{ + WCHAR szWcharFileName[MAX_PATH]; + ::MultiByteToWideChar(CP_ACP, 0, pFileName, -1, szWcharFileName, sp_countof(szWcharFileName)); + return SPBindToFile(szWcharFileName, eMode, ppStream, pFormatId, pWaveFormatEx, ullEventInterest); +} +#endif + +/**************************************************************************** +* SpClearEvent * +*--------------* +* Description: +* Helper function that can be used by clients that do not use the CSpEvent +* class. +* +* Returns: +* +*****************************************************************************/ + +inline void SpClearEvent(SPEVENT * pe) +{ + if( pe->elParamType != SPEI_UNDEFINED) + { + if( pe->elParamType == SPET_LPARAM_IS_POINTER || + pe->elParamType == SPET_LPARAM_IS_STRING) + { + ::CoTaskMemFree((void *)pe->lParam); + } + else if (pe->elParamType == SPET_LPARAM_IS_TOKEN || + pe->elParamType == SPET_LPARAM_IS_OBJECT) + { + ((IUnknown*)pe->lParam)->Release(); + } + } + memset(pe, 0, sizeof(*pe)); +} + +/**************************************************************************** +* SpInitEvent * +*-------------* +* Description: +* +* Returns: +* +*****************************************************************************/ + +inline void SpInitEvent(SPEVENT * pe) +{ + memset(pe, 0, sizeof(*pe)); +} + +/**************************************************************************** +* SpEventSerializeSize * +*----------------------* +* Description: +* Computes the required size of a buffer to serialize an event. The caller +* must specify which type of serialized event is desired -- either SPSERIALIZEDEVENT +* or SPSERIALIZEDEVENT64. +* +* Returns: +* Size in bytes required to seriailze the event. +* +****************************************************************************/ + +// WCE compiler does not work propertly with template +#ifndef _WIN32_WCE +template +inline ULONG SpEventSerializeSize(const SPEVENT * pEvent) + +{ + ULONG ulSize = sizeof(T); + +#else + +inline ULONG SpEventSerializeSize(const SPEVENT * pEvent, ULONG ulSize) +{ +#endif //_WIN32_WCE + + if( ( pEvent->elParamType == SPET_LPARAM_IS_POINTER ) && pEvent->lParam ) + { + ulSize += ULONG(pEvent->wParam); + } + else if ((pEvent->elParamType == SPET_LPARAM_IS_STRING) && pEvent->lParam != NULL) + { + ulSize += (wcslen((WCHAR*)pEvent->lParam) + 1) * sizeof( WCHAR ); + } + else if( pEvent->elParamType == SPET_LPARAM_IS_TOKEN ) + { + CSpDynamicString dstrObjectId; + if( ((ISpObjectToken*)(pEvent->lParam))->GetId( &dstrObjectId ) == S_OK ) + { + ulSize += (dstrObjectId.Length() + 1) * sizeof( WCHAR ); + } + } + // Round up to nearest DWORD + ulSize += 3; + ulSize -= ulSize % 4; + return ulSize; +} + +/**************************************************************************** +* SpSerializedEventSize * +*-----------------------* +* Description: +* Returns the size, in bytes, used by a serialized event. The caller can +* pass a pointer to either a SPSERIAILZEDEVENT or SPSERIALIZEDEVENT64 structure. +* +* Returns: +* Number of bytes used by serizlied event +* +********************************************************************* RAL ***/ + +// WCE compiler does not work propertly with template +#ifndef _WIN32_WCE +template +inline ULONG SpSerializedEventSize(const T * pSerEvent) +{ + ULONG ulSize = sizeof(T); + + if( ( pSerEvent->elParamType == SPET_LPARAM_IS_POINTER ) && pSerEvent->SerializedlParam ) + { + ulSize += ULONG(pSerEvent->SerializedwParam); + } + else if ((pSerEvent->elParamType == SPET_LPARAM_IS_STRING || pSerEvent->elParamType == SPET_LPARAM_IS_TOKEN) && + pSerEvent->SerializedlParam != NULL) + { + ulSize += (wcslen((WCHAR*)(pSerEvent + 1)) + 1) * sizeof( WCHAR ); + } + // Round up to nearest DWORD + ulSize += 3; + ulSize -= ulSize % 4; + return ulSize; +} + +#else //_WIN32_WCE + +inline ULONG SpSerializedEventSize(const SPSERIALIZEDEVENT * pSerEvent, ULONG ulSize) +{ + if( ( pSerEvent->elParamType == SPET_LPARAM_IS_POINTER ) && pSerEvent->SerializedlParam ) + { + ulSize += ULONG(pSerEvent->SerializedwParam); + } + else if ((pSerEvent->elParamType == SPET_LPARAM_IS_STRING || pSerEvent->elParamType == SPET_LPARAM_IS_TOKEN) && + pSerEvent->SerializedlParam != NULL) + { + ulSize += (wcslen((WCHAR*)(pSerEvent + 1)) + 1) * sizeof( WCHAR ); + } + // Round up to nearest DWORD + ulSize += 3; + ulSize -= ulSize % 4; + return ulSize; +} + +inline ULONG SpSerializedEventSize(const SPSERIALIZEDEVENT64 * pSerEvent, ULONG ulSize) +{ + if( ( pSerEvent->elParamType == SPET_LPARAM_IS_POINTER ) && pSerEvent->SerializedlParam ) + { + ulSize += ULONG(pSerEvent->SerializedwParam); + } + else if ((pSerEvent->elParamType == SPET_LPARAM_IS_STRING || pSerEvent->elParamType == SPET_LPARAM_IS_TOKEN) && + pSerEvent->SerializedlParam != NULL) + { + ulSize += (wcslen((WCHAR*)(pSerEvent + 1)) + 1) * sizeof( WCHAR ); + } + // Round up to nearest DWORD + ulSize += 3; + ulSize -= ulSize % 4; + return ulSize; +} + +#endif //_WIN32_WCE + +/*** CSpEvent helper class +* +*/ +class CSpEvent : public SPEVENT +{ +public: + CSpEvent() + { + SpInitEvent(this); + } + ~CSpEvent() + { + SpClearEvent(this); + } + // If you need to take the address of a CSpEvent that is not const, use the AddrOf() method + // which will do debug checking of parameters. If you encounter this problem when calling + // GetEvents from an event source, you may want to use the GetFrom() method of this class. + const SPEVENT * operator&() + { + return this; + } + CSpEvent * AddrOf() + { + // Note: This method does not ASSERT since we assume the caller knows what they are doing. + return this; + } + void Clear() + { + SpClearEvent(this); + } + HRESULT CopyTo(SPEVENT * pDestEvent) const + { + memcpy(pDestEvent, this, sizeof(*pDestEvent)); + if ((elParamType == SPET_LPARAM_IS_POINTER) && lParam) + { + SPDBG_ASSERT(wParam && (wParam < 0x100000)); // this is too big! + pDestEvent->lParam = (LPARAM)::CoTaskMemAlloc(wParam); + if (pDestEvent->lParam) + { + memcpy((void *)pDestEvent->lParam, (void *)lParam, wParam); + } + else + { + pDestEvent->eEventId = SPEI_UNDEFINED; + return E_OUTOFMEMORY; + } + } + else if (elParamType == SPET_LPARAM_IS_STRING && lParam != NULL) + { + pDestEvent->lParam = (LPARAM)::CoTaskMemAlloc((wcslen((WCHAR*)lParam) + 1) * sizeof(WCHAR)); + if (pDestEvent->lParam) + { + wcscpy((WCHAR*)pDestEvent->lParam, (WCHAR*)lParam); + } + else + { + pDestEvent->eEventId = SPEI_UNDEFINED; + return E_OUTOFMEMORY; + } + } + else if (elParamType == SPET_LPARAM_IS_TOKEN || + elParamType == SPET_LPARAM_IS_OBJECT) + { + ((IUnknown*)lParam)->AddRef(); + } + return S_OK; + } + + HRESULT GetFrom(ISpEventSource * pEventSrc) + { + SpClearEvent(this); + return pEventSrc->GetEvents(1, this, NULL); + } + HRESULT CopyFrom(const SPEVENT * pSrcEvent) + { + SpClearEvent(this); + return static_cast(pSrcEvent)->CopyTo(this); + } + void Detach(SPEVENT * pDestEvent = NULL) + { + if (pDestEvent) + { + memcpy(pDestEvent, this, sizeof(*pDestEvent)); + } + memset(this, 0, sizeof(*this)); + } + + template + ULONG SerializeSize() const + { + return SpEventSerializeSize(this); + } + + // Call this method with either SPSERIALIZEDEVENT or SPSERIALIZEDEVENT64 + template + void Serialize(T * pSerEvent) const + { + SPDBG_ASSERT(elParamType != SPET_LPARAM_IS_OBJECT); + pSerEvent->eEventId = this->eEventId; + pSerEvent->elParamType = this->elParamType; + pSerEvent->ulStreamNum = this->ulStreamNum; + pSerEvent->ullAudioStreamOffset = this->ullAudioStreamOffset; + pSerEvent->SerializedwParam = static_cast(this->wParam); + pSerEvent->SerializedlParam = static_cast(this->lParam); + if (lParam) + { + switch(elParamType) + { + case SPET_LPARAM_IS_POINTER: + memcpy(pSerEvent + 1, (void *)lParam, wParam); + pSerEvent->SerializedlParam = sizeof(T); + break; + + case SPET_LPARAM_IS_STRING: + wcscpy((WCHAR *)(pSerEvent + 1), (WCHAR*)lParam); + pSerEvent->SerializedlParam = sizeof(T); + break; + + case SPET_LPARAM_IS_TOKEN: + { + CSpDynamicString dstrObjectId; + if( SUCCEEDED( ((ISpObjectToken*)lParam)->GetId( &dstrObjectId ) ) ) + { + pSerEvent->SerializedwParam = (dstrObjectId.Length() + 1) * sizeof( WCHAR );; + memcpy( pSerEvent + 1, (void *)dstrObjectId.m_psz, static_cast(pSerEvent->SerializedwParam) ); + } + pSerEvent->SerializedlParam = sizeof(T); + } + break; + + default: + break; + } + } + } + + template + HRESULT Serialize(T ** ppCoMemSerEvent, ULONG * pcbSerEvent) const + { +// WCE compiler does not work propertly with template +#ifndef _WIN32_WCE + *pcbSerEvent = SpEventSerializeSize(this); +#else + *pcbSerEvent = SpEventSerializeSize(this, sizeof(** ppCoMemSerEvent)); +#endif + *ppCoMemSerEvent = (T *)::CoTaskMemAlloc(*pcbSerEvent); + if (*ppCoMemSerEvent) + { + Serialize(*ppCoMemSerEvent); + return S_OK; + } + else + { + *pcbSerEvent = 0; + return E_OUTOFMEMORY; + } + } + + + // Call this method with either SPSERIALIZEDEVENT or SPSERIALIZEDEVENT64 + template + HRESULT Deserialize(const T * pSerEvent, ULONG * pcbUsed = NULL) + { + Clear(); + HRESULT hr = S_OK; + const UNALIGNED T * pTemp = pSerEvent; + this->eEventId = pTemp->eEventId; + this->elParamType = pTemp->elParamType; + this->ulStreamNum = pTemp->ulStreamNum; + this->ullAudioStreamOffset = pTemp->ullAudioStreamOffset; + this->wParam = static_cast(pTemp->SerializedwParam); + this->lParam = static_cast(pTemp->SerializedlParam); + if (pTemp->SerializedlParam) + { + ULONG cbAlloc = 0; + switch (pTemp->elParamType) + { + case SPET_LPARAM_IS_POINTER: + cbAlloc = static_cast(wParam); + break; + + case SPET_LPARAM_IS_STRING: + cbAlloc = sizeof(WCHAR) * (1 + wcslen((const WCHAR *)(pTemp + 1))); + break; + + case SPET_LPARAM_IS_TOKEN: + { + ULONG ulDataOffset = ULONG(lParam); + hr = SpGetTokenFromId( (const WCHAR*)(pTemp + 1), + (ISpObjectToken **)&lParam ); + wParam = 0; + } + break; + } + if (cbAlloc) + { + void * pvBuff = ::CoTaskMemAlloc(cbAlloc); + this->lParam = (LPARAM)pvBuff; + if (pvBuff) + { + memcpy(pvBuff, pTemp + 1, cbAlloc); + } + else + { + hr = E_OUTOFMEMORY; + } + } + } + + if( SUCCEEDED( hr ) && pcbUsed ) + { +// WCE compiler does not work propertly with template +#ifndef _WIN32_WCE + *pcbUsed = SpEventSerializeSize(this); +#else + *pcbUsed = SpEventSerializeSize(this, sizeof(*pTemp)); +#endif + } + return hr; + } + + // + // Helpers for access to events. Performs run-time checks in debug and casts + // data to the appropriate types + // + SPPHONEID Phoneme() const + { + SPDBG_ASSERT(eEventId == SPEI_PHONEME); + return (SPPHONEID)LOWORD(lParam); + } + SPVISEMES Viseme() const + { + SPDBG_ASSERT(eEventId == SPEI_VISEME); + return (SPVISEMES)LOWORD(lParam); + } + ULONG InputWordPos() const + { + SPDBG_ASSERT(eEventId == SPEI_WORD_BOUNDARY); + return ULONG(lParam); + } + ULONG InputWordLen() const + { + SPDBG_ASSERT(eEventId == SPEI_WORD_BOUNDARY); + return ULONG(wParam); + } + ULONG InputSentPos() const + { + SPDBG_ASSERT(eEventId == SPEI_SENTENCE_BOUNDARY); + return ULONG(lParam); + } + ULONG InputSentLen() const + { + SPDBG_ASSERT(eEventId == SPEI_SENTENCE_BOUNDARY); + return ULONG(wParam); + } + ISpObjectToken * ObjectToken() const + { + SPDBG_ASSERT(elParamType == SPET_LPARAM_IS_TOKEN); + return (ISpObjectToken *)lParam; + } + ISpObjectToken * VoiceToken() const // More explicit check than ObjectToken() + { + SPDBG_ASSERT(eEventId == SPEI_VOICE_CHANGE); + return ObjectToken(); + } + BOOL PersistVoiceChange() const + { + SPDBG_ASSERT(eEventId == SPEI_VOICE_CHANGE); + return (BOOL)wParam; + } + IUnknown * Object() const + { + SPDBG_ASSERT(elParamType == SPET_LPARAM_IS_OBJECT); + return (IUnknown*)lParam; + } + ISpRecoResult * RecoResult() const + { + SPDBG_ASSERT(eEventId == SPEI_RECOGNITION || eEventId == SPEI_FALSE_RECOGNITION || eEventId == SPEI_HYPOTHESIS); + return (ISpRecoResult *)Object(); + } + BOOL IsPaused() + { + SPDBG_ASSERT(eEventId == SPEI_RECOGNITION || eEventId == SPEI_SR_BOOKMARK); + return (BOOL)(wParam & SPREF_AutoPause); + } + BOOL IsEmulated() + { + SPDBG_ASSERT(eEventId == SPEI_RECOGNITION); + return (BOOL)(wParam & SPREF_Emulated); + } + const WCHAR * String() const + { + SPDBG_ASSERT(elParamType == SPET_LPARAM_IS_STRING); + return (const WCHAR*)lParam; + } + const WCHAR * BookmarkName() const + { + SPDBG_ASSERT(eEventId == SPEI_TTS_BOOKMARK); + return String(); + } + const WCHAR * RequestTypeOfUI() const + { + SPDBG_ASSERT(eEventId == SPEI_REQUEST_UI); + return String(); + } + SPRECOSTATE RecoState() const + { + SPDBG_ASSERT(eEventId == SPEI_RECO_STATE_CHANGE); + return static_cast(wParam); + } + const WCHAR * PropertyName() const + { + SPDBG_ASSERT((eEventId == SPEI_PROPERTY_NUM_CHANGE && elParamType == SPET_LPARAM_IS_STRING) || + (eEventId == SPEI_PROPERTY_STRING_CHANGE && elParamType == SPET_LPARAM_IS_POINTER)); + // Note: Don't use String() method here since in the case of string attributes, the elParamType + // field specifies LPARAM_IS_POINTER, but the attribute name IS the first string in this buffer + return (const WCHAR*)lParam; + } + const LONG PropertyNumValue() const + { + SPDBG_ASSERT(eEventId == SPEI_PROPERTY_NUM_CHANGE); + return static_cast(wParam); + } + const WCHAR * PropertyStringValue() const + { + // Search for the first NULL and return pointer to the char past it. + SPDBG_ASSERT(eEventId == SPEI_PROPERTY_STRING_CHANGE); + for (const WCHAR * psz = (const WCHAR *)lParam; *psz; psz++) {} + return psz + 1; + } + SPINTERFERENCE Interference() const + { + SPDBG_ASSERT(eEventId == SPEI_INTERFERENCE); + return static_cast(lParam); + } + HRESULT EndStreamResult() const + { + SPDBG_ASSERT(eEventId == SPEI_END_SR_STREAM); + return static_cast(lParam); + } + BOOL InputStreamReleased() const + { + SPDBG_ASSERT(eEventId == SPEI_END_SR_STREAM); + return (wParam & SPESF_STREAM_RELEASED) ? TRUE : FALSE; + } +}; + +class CSpPhrasePtr +{ +public: + SPPHRASE * m_pPhrase; + CSpPhrasePtr() : m_pPhrase(NULL) {} + CSpPhrasePtr(ISpPhrase * pPhraseObj, HRESULT * phr) + { + *phr = pPhraseObj->GetPhrase(&m_pPhrase); + } + ~CSpPhrasePtr() + { + ::CoTaskMemFree(m_pPhrase); + } + //The assert on operator& usually indicates a bug. If this is really + //what is needed, however, take the address of the m_pPhrase member explicitly. + SPPHRASE ** operator&() + { + SPDBG_ASSERT(m_pPhrase == NULL); + return &m_pPhrase; + } + operator SPPHRASE *() const + { + return m_pPhrase; + } + SPPHRASE & operator*() const + { + SPDBG_ASSERT(m_pPhrase); + return *m_pPhrase; + } + SPPHRASE * operator->() const + { + return m_pPhrase; + } + bool operator!() const + { + return (m_pPhrase == NULL); + } + void Clear() + { + if (m_pPhrase) + { + ::CoTaskMemFree(m_pPhrase); + m_pPhrase = NULL; + } + } + HRESULT GetFrom(ISpPhrase * pPhraseObj) + { + Clear(); + return pPhraseObj->GetPhrase(&m_pPhrase); + } +}; + + +template +class CSpCoTaskMemPtr +{ +public: + T * m_pT; + CSpCoTaskMemPtr() : m_pT(NULL) {} + CSpCoTaskMemPtr(void * pv) : m_pT((T *)pv) {} + CSpCoTaskMemPtr(ULONG cElements, HRESULT * phr) + { + m_pT = (T *)::CoTaskMemAlloc(cElements * sizeof(T)); + *phr = m_pT ? S_OK : E_OUTOFMEMORY; + } + ~CSpCoTaskMemPtr() + { + ::CoTaskMemFree(m_pT); + } + void Clear() + { + if (m_pT) + { + ::CoTaskMemFree(m_pT); + m_pT = NULL; + } + } + HRESULT Alloc(ULONG cArrayElements = 1) + { + m_pT = (T *)::CoTaskMemRealloc(m_pT, sizeof(T) * cArrayElements); + SPDBG_ASSERT(m_pT); + return (m_pT ? S_OK : E_OUTOFMEMORY); + } + void Attach(void * pv) + { + Clear(); + m_pT = (T *)pv; + } + T * Detatch() + { + T * pT = m_pT; + m_pT = NULL; + return pT; + } + //The assert on operator& usually indicates a bug. If this is really + //what is needed, however, take the address of the m_pT member explicitly. + T ** operator&() + { + SPDBG_ASSERT(m_pT == NULL); + return &m_pT; + } + T * operator->() + { + SPDBG_ASSERT(m_pT != NULL); + return m_pT; + } + operator T *() + { + return m_pT; + } + bool operator!() const + { + return (m_pT == NULL); + } +}; + +/**** Helper function used to create a new phrase object from an array of + test words. Each word in the string is converted to a phrase element. + This is useful to create a phrase to pass to the EmulateRecognition method. + The method can convert standard words as well as words with the + "/display_text/lexical_form/pronounciation;" word format. + You can also specify the DisplayAttributes for each element if desired. + If prgDispAttribs is NULL then the DisplayAttribs for each element default to + SPAF_ONE_TRAILING_SPACE. ****/ +inline HRESULT CreatePhraseFromWordArray(const WCHAR ** ppWords, ULONG cWords, + SPDISPLYATTRIBUTES * prgDispAttribs, + ISpPhraseBuilder **ppResultPhrase, + LANGID LangId = 0, + CComPtr cpPhoneConv = NULL) +{ + SPDBG_FUNC("CreatePhraseFromWordArray"); + HRESULT hr = S_OK; + + if ( cWords == 0 || ppWords == NULL || ::IsBadReadPtr(ppWords, sizeof(*ppWords) * cWords ) ) + { + return E_INVALIDARG; + } + + if ( prgDispAttribs != NULL && ::IsBadReadPtr(prgDispAttribs, sizeof(*prgDispAttribs) * cWords ) ) + { + return E_INVALIDARG; + } + + ULONG cTotalChars = 0; + ULONG i; + WCHAR** pStringPtrArray = (WCHAR**)::CoTaskMemAlloc( cWords * sizeof(WCHAR *)); + if ( !pStringPtrArray ) + { + return E_OUTOFMEMORY; + } + for (i = 0; i < cWords; i++) + { + cTotalChars += wcslen(ppWords[i])+1; + } + + CSpDynamicString dsText(cTotalChars); + if(dsText.m_psz == NULL) + { + ::CoTaskMemFree(pStringPtrArray); + return E_OUTOFMEMORY; + } + CSpDynamicString dsPhoneId(cTotalChars); + if(dsPhoneId.m_psz == NULL) + { + ::CoTaskMemFree(pStringPtrArray); + return E_OUTOFMEMORY; + } + SPPHONEID* pphoneId = dsPhoneId; + + SPPHRASE Phrase; + memset(&Phrase, 0, sizeof(Phrase)); + Phrase.cbSize = sizeof(Phrase); + + if(LangId == 0) + { + LangId = SpGetUserDefaultUILanguage(); + } + + if(cpPhoneConv == NULL) + { + hr = SpCreatePhoneConverter(LangId, NULL, NULL, &cpPhoneConv); + if(FAILED(hr)) + { + ::CoTaskMemFree(pStringPtrArray); + return hr; + } + } + + SPPHRASEELEMENT *pPhraseElement = new SPPHRASEELEMENT[cWords]; + if(pPhraseElement == NULL) + { + ::CoTaskMemFree(pStringPtrArray); + return E_OUTOFMEMORY; + } + memset(pPhraseElement, 0, sizeof(SPPHRASEELEMENT) * cWords); // !!! + + WCHAR * pText = dsText; + for (i = 0; SUCCEEDED(hr) && i < cWords; i++) + { + WCHAR *p = pText; + pStringPtrArray[i] = pText; + wcscpy( pText, ppWords[i] ); + pText += wcslen( p ) + 1; + + if (*p == L'/') + { + //This is a compound word + WCHAR* pszFirstPart = ++p; + WCHAR* pszSecondPart = NULL; + WCHAR* pszThirdPart = NULL; + + while (*p && *p != L'/') + { + p++; + } + if (*p == L'/') + { + //It means we stop at the second '/' + *p = L'\0'; + pszSecondPart = ++p; + while (*p && *p != L'/') + { + p++; + } + if (*p == L'/') + { + //It means we stop at the third '/' + *p = L'\0'; + pszThirdPart = ++p; + } + } + + pPhraseElement[i].pszDisplayText = pszFirstPart; + pPhraseElement[i].pszLexicalForm = pszSecondPart ? pszSecondPart : pszFirstPart; + + if ( pszThirdPart) + { + hr = cpPhoneConv->PhoneToId(pszThirdPart, pphoneId); + if (SUCCEEDED(hr)) + { + pPhraseElement[i].pszPronunciation = pphoneId; + pphoneId += wcslen(pphoneId) + 1; + } + } + } + else + { + //It is the simple format, only have one form, use it for everything. + pPhraseElement[i].pszDisplayText = NULL; + pPhraseElement[i].pszLexicalForm = p; + pPhraseElement[i].pszPronunciation = NULL; + } + + pPhraseElement[i].bDisplayAttributes = (BYTE)(prgDispAttribs ? prgDispAttribs[i] : SPAF_ONE_TRAILING_SPACE); + pPhraseElement[i].RequiredConfidence = SP_NORMAL_CONFIDENCE; + pPhraseElement[i].ActualConfidence = SP_NORMAL_CONFIDENCE; + } + + Phrase.Rule.ulCountOfElements = cWords; + Phrase.pElements = pPhraseElement; + Phrase.LangID = LangId; + + CComPtr cpPhrase; + if (SUCCEEDED(hr)) + { + hr = cpPhrase.CoCreateInstance(CLSID_SpPhraseBuilder); + } + + if (SUCCEEDED(hr)) + { + hr = cpPhrase->InitFromPhrase(&Phrase); + } + if (SUCCEEDED(hr)) + { + *ppResultPhrase = cpPhrase.Detach(); + } + + delete pPhraseElement; + ::CoTaskMemFree(pStringPtrArray); + + return hr; +} + +/**** Helper function used to create a new phrase object from a + test string. Each word in the string is converted to a phrase element. + This is useful to create a phrase to pass to the EmulateRecognition method. + The method can convert standard words as well as words with the + "/display_text/lexical_form/pronounciation;" word format ****/ +inline HRESULT CreatePhraseFromText(const WCHAR *pszOriginalText, + ISpPhraseBuilder **ppResultPhrase, + LANGID LangId = 0, + CComPtr cpPhoneConv = NULL) +{ + SPDBG_FUNC("CreatePhraseFromText"); + HRESULT hr = S_OK; + + //We first trim the input text + CSpDynamicString dsText(pszOriginalText); + if(dsText.m_psz == NULL) + { + return E_OUTOFMEMORY; + } + dsText.TrimBoth(); + + ULONG cWords = 0; + BOOL fInCompoundword = FALSE; + + // Set first array pointer (if *p). + WCHAR *p = dsText; + while (*p) + { + if( iswspace(*p) && !fInCompoundword) + { + cWords++; + *p++ = L'\0'; + while (*p && iswspace(*p)) + { + *p++ = L'\0'; + } + // Add new array pointer. Use vector. + } + else if (*p == L'/' && !fInCompoundword) + { + fInCompoundword = TRUE; + } + else if (*p == L';' && fInCompoundword) + { + fInCompoundword = FALSE; + *p++ = L'\0'; + // Add new array element. + } + else + { + p++; + } + } + + cWords++; + + WCHAR** pStringPtrArray = (WCHAR**)::CoTaskMemAlloc( cWords * sizeof(WCHAR *)); + if ( !pStringPtrArray ) + { + hr = E_OUTOFMEMORY; + } + + if ( SUCCEEDED( hr ) ) + { + p = dsText; + for (ULONG i=0; i +#endif + +#ifndef SPError_h +#include +#endif + +#ifndef SPDebug_h +#include +#endif + +#ifndef SPHelper_h +#include +#endif + +#ifndef __ATLBASE_H__ +#include +#endif + +#ifndef __ATLCONV_H__ +#include +#endif + +/**************************************************************************** +* +* +* +********************************************************************* RAL ***/ + +// +// Dont call this function directly. Use SpInitTokenComboBox or SpInitTokenListBox. +// +inline HRESULT SpInitTokenList(UINT MsgAddString, UINT MsgSetItemData, UINT MsgSetCurSel, + HWND hwnd, const WCHAR * pszCatName, + const WCHAR * pszRequiredAttrib, const WCHAR * pszOptionalAttrib) +{ + HRESULT hr; + ISpObjectToken * pToken; // NOTE: Not a CComPtr! Be Careful. + CComPtr cpEnum; + hr = SpEnumTokens(pszCatName, pszRequiredAttrib, pszOptionalAttrib, &cpEnum); + if (hr == S_OK) + { + bool fSetDefault = false; + while (cpEnum->Next(1, &pToken, NULL) == S_OK) + { + CSpDynamicString dstrDesc; + hr = SpGetDescription(pToken, &dstrDesc); + if (SUCCEEDED(hr)) + { + USES_CONVERSION; + LRESULT i = ::SendMessage(hwnd, MsgAddString, 0, (LPARAM)W2T(dstrDesc)); + if (i == CB_ERR || i == CB_ERRSPACE) // Note: CB_ and LB_ errors are identical values... + { + hr = E_OUTOFMEMORY; + } + else + { + ::SendMessage(hwnd, MsgSetItemData, i, (LPARAM)pToken); + if (!fSetDefault) + { + ::SendMessage(hwnd, MsgSetCurSel, i, 0); + fSetDefault = true; + } + } + } + if (FAILED(hr)) + { + pToken->Release(); + } + } + } + else + { + hr = SPERR_NO_MORE_ITEMS; + } + return hr; +} + +inline HRESULT SpInitTokenComboBox(HWND hwnd, const WCHAR * pszCatName, + const WCHAR * pszRequiredAttrib = NULL, const WCHAR * pszOptionalAttrib = NULL) +{ + return SpInitTokenList(CB_ADDSTRING, CB_SETITEMDATA, CB_SETCURSEL, hwnd, pszCatName, pszRequiredAttrib, pszOptionalAttrib); +} + +inline HRESULT SpInitTokenListBox(HWND hwnd, const WCHAR * pszCatName, + const WCHAR * pszRequiredAttrib = NULL, const WCHAR * pszOptionalAttrib = NULL) +{ + return SpInitTokenList(LB_ADDSTRING, LB_SETITEMDATA, LB_SETCURSEL, hwnd, pszCatName, pszRequiredAttrib, pszOptionalAttrib); +} + +// +// Dont call this function directly. Use SpDestoyTokenComboBox or SpDestroyTokenListBox. +// +inline void SpDestroyTokenList(UINT MsgGetCount, UINT MsgGetItemData, HWND hwnd) +{ + LRESULT c = ::SendMessage(hwnd, MsgGetCount, 0, 0); + for (LRESULT i = 0; i < c; i++) + { + IUnknown * pUnkObj = (IUnknown *)::SendMessage(hwnd, MsgGetItemData, i, 0); + if (pUnkObj) + { + pUnkObj->Release(); + } + } +} + +inline void SpDestroyTokenComboBox(HWND hwnd) +{ + SpDestroyTokenList(CB_GETCOUNT, CB_GETITEMDATA, hwnd); +} + +inline void SpDestroyTokenListBox(HWND hwnd) +{ + SpDestroyTokenList(LB_GETCOUNT, LB_GETITEMDATA, hwnd); +} + + +inline ISpObjectToken * SpGetComboBoxToken(HWND hwnd, WPARAM Index) +{ + return (ISpObjectToken *)::SendMessage(hwnd, CB_GETITEMDATA, Index, 0); +} + +inline ISpObjectToken * SpGetListBoxToken(HWND hwnd, WPARAM Index) +{ + return (ISpObjectToken *)::SendMessage(hwnd, LB_GETITEMDATA, Index, 0); +} + +inline ISpObjectToken * SpGetCurSelComboBoxToken(HWND hwnd) +{ + LRESULT i = ::SendMessage(hwnd, CB_GETCURSEL, 0, 0); + return (i == CB_ERR) ? NULL : SpGetComboBoxToken(hwnd, i); +} + +inline ISpObjectToken * SpGetCurSelListBoxToken(HWND hwnd) +{ + LRESULT i = ::SendMessage(hwnd, LB_GETCURSEL, 0, 0); + return (i == LB_ERR) ? NULL : SpGetListBoxToken(hwnd, i); +} + +// +// Don't call this directly. Use SpUpdateCurSelComboBoxToken or SpUpdateCurSelListBoxToken +// +inline HRESULT SpUpdateCurSelToken(UINT MsgDelString, UINT MsgInsertString, UINT MsgGetItemData, UINT MsgSetItemData, UINT MsgGetCurSel, UINT MsgSetCurSel, + HWND hwnd) +{ + HRESULT hr = S_OK; + LRESULT i = ::SendMessage(hwnd, MsgGetCurSel, 0, 0); + if (i != CB_ERR) + { + ISpObjectToken * pToken = (ISpObjectToken *)::SendMessage(hwnd, MsgGetItemData, i, 0); + CSpDynamicString dstrDesc; + hr = SpGetDescription(pToken, &dstrDesc); + if (SUCCEEDED(hr)) + { + USES_CONVERSION; + ::SendMessage(hwnd, MsgDelString, i, 0); + ::SendMessage(hwnd, MsgInsertString, i, (LPARAM)W2T(dstrDesc)); + ::SendMessage(hwnd, MsgSetItemData, i, (LPARAM)pToken); + ::SendMessage(hwnd, MsgSetCurSel, i, 0); + } + } + return hr; +} + +inline HRESULT SpUpdateCurSelComboBoxToken(HWND hwnd) +{ + return SpUpdateCurSelToken(CB_DELETESTRING, CB_INSERTSTRING, CB_GETITEMDATA, CB_SETITEMDATA, CB_GETCURSEL, CB_SETCURSEL, hwnd); +} + +inline HRESULT SpUpdateCurSelListBoxToken(HWND hwnd) +{ + return SpUpdateCurSelToken(LB_DELETESTRING, LB_INSERTSTRING, LB_GETITEMDATA, LB_SETITEMDATA, LB_GETCURSEL, LB_SETCURSEL, hwnd); +} + +inline HRESULT SpAddTokenToList(UINT MsgAddString, UINT MsgSetItemData, UINT MsgSetCurSel, HWND hwnd, ISpObjectToken * pToken) +{ + CSpDynamicString dstrDesc; + HRESULT hr = SpGetDescription(pToken, &dstrDesc); + if (SUCCEEDED(hr)) + { + USES_CONVERSION; + LRESULT i = ::SendMessage(hwnd, MsgAddString, 0, (LPARAM)W2T(dstrDesc)); + if (i == CB_ERR || i == CB_ERRSPACE) // Note: CB_ and LB_ errors are identical values... + { + hr = E_OUTOFMEMORY; + } + else + { + ::SendMessage(hwnd, MsgSetItemData, i, (LPARAM)pToken); + ::SendMessage(hwnd, MsgSetCurSel, i, 0); + pToken->AddRef(); + } + } + return hr; +} + +inline HRESULT SpAddTokenToComboBox(HWND hwnd, ISpObjectToken * pToken) +{ + return SpAddTokenToList(CB_ADDSTRING, CB_SETITEMDATA, CB_SETCURSEL, hwnd, pToken); +} + +inline HRESULT SpAddTokenToListBox(HWND hwnd, ISpObjectToken * pToken) +{ + return SpAddTokenToList(LB_ADDSTRING, LB_SETITEMDATA, LB_SETCURSEL, hwnd, pToken); +} + + +inline HRESULT SpDeleteCurSelToken(UINT MsgGetCurSel, UINT MsgSetCurSel, UINT MsgGetItemData, UINT MsgDeleteString, HWND hwnd) +{ + HRESULT hr = S_OK; + LRESULT i = ::SendMessage(hwnd, MsgGetCurSel, 0, 0); + if (i == CB_ERR) + { + hr = S_FALSE; + } + else + { + ISpObjectToken * pToken = (ISpObjectToken *)::SendMessage(hwnd, MsgGetItemData, i, 0); + if (pToken) + { + pToken->Release(); + } + ::SendMessage(hwnd, MsgDeleteString, i, 0); + ::SendMessage(hwnd, MsgSetCurSel, i, 0); + } + return hr; +} + +inline HRESULT SpDeleteCurSelComboBoxToken(HWND hwnd) +{ + return SpDeleteCurSelToken(CB_GETCURSEL, CB_SETCURSEL, CB_GETITEMDATA, CB_DELETESTRING, hwnd); +} + +inline HRESULT SpDeleteCurSelListBoxToken(HWND hwnd) +{ + return SpDeleteCurSelToken(LB_GETCURSEL, CB_SETCURSEL, LB_GETITEMDATA, LB_DELETESTRING, hwnd); +} + +#endif /* #ifndef SPUIHelp_h -- This must be the last line in the file */ diff --git a/speech2/third_party/sapi5/lib/i386/sapi.lib b/speech2/third_party/sapi5/lib/i386/sapi.lib new file mode 100644 index 0000000..55869a5 Binary files /dev/null and b/speech2/third_party/sapi5/lib/i386/sapi.lib differ