From 20f59c5663c35809f999849b823ba24a7337a8f6 Mon Sep 17 00:00:00 2001 From: modeco80 Date: Wed, 17 Jul 2024 21:38:27 -0400 Subject: [PATCH] add speech2 stuff --- .clang-format | 44 + .editorconfig | 11 + .gitignore | 368 +- Justfile | 7 + README.md | 10 +- SAPIServer/SAPIServer.csproj | 85 +- SAPIServer/SAPIServer.vs.csproj | 84 + speech2/Makefile | 36 + speech2/README.md | 3 + speech2/build/arch.mk | 19 + speech2/build/configs.mk | 23 + speech2/build/rules.mk | 20 + speech2/compdb.sh | 2 + speech2/src/base/BCondVar.cpp | 156 + speech2/src/base/BMutex.cpp | 53 + speech2/src/base/BThread.cpp | 38 + speech2/src/base/BThread.hpp | 64 + speech2/src/base/Mutex.cpp | 21 + speech2/src/base/Mutex.hpp | 47 + speech2/src/base/README.md | 10 + speech2/src/base/SaneWin.hpp | 6 + speech2/src/base/Thread.cpp | 53 + speech2/src/base/Thread.hpp | 70 + speech2/src/base/comptr.hpp | 71 + speech2/src/base/comresult.hpp | 17 + speech2/src/main.cpp | 120 + speech2/src/sapi4/api_sapi4.cpp | 84 + speech2/src/sapi4/audio_buffer.cpp | 185 + speech2/src/sapi4/audio_buffer.hpp | 43 + speech2/src/sapi4/guid_sapi4.cpp | 6 + speech2/src/speechapi.hpp | 29 + speech2/third_party/README.md | 4 + speech2/third_party/sapi4/include/buildnum.h | 63 + speech2/third_party/sapi4/include/buildnum.rc | 69 + speech2/third_party/sapi4/include/spchtel.h | 313 + speech2/third_party/sapi4/include/spchwrap.h | 2456 ++ speech2/third_party/sapi4/include/speech.h | 6635 ++++ speech2/third_party/sapi4/lib/spchwrap.lib | Bin 0 -> 976098 bytes speech2/third_party/sapi5/idl/sapi.idl | 2197 ++ speech2/third_party/sapi5/idl/sapiaut.idl | 4847 +++ speech2/third_party/sapi5/idl/sapiddk.idl | 818 + speech2/third_party/sapi5/include/Spddkhlp.h | 854 + speech2/third_party/sapi5/include/sapi.h | 25599 ++++++++++++++++ speech2/third_party/sapi5/include/sapiddk.h | 4557 +++ speech2/third_party/sapi5/include/spcollec.h | 1432 + speech2/third_party/sapi5/include/spdebug.h | 636 + speech2/third_party/sapi5/include/sperror.h | 559 + speech2/third_party/sapi5/include/speventq.h | 605 + speech2/third_party/sapi5/include/sphelper.h | 2753 ++ speech2/third_party/sapi5/include/spuihelp.h | 253 + speech2/third_party/sapi5/lib/i386/sapi.lib | Bin 0 -> 39424 bytes 51 files changed, 55999 insertions(+), 436 deletions(-) create mode 100755 .clang-format create mode 100644 .editorconfig create mode 100644 Justfile create mode 100644 SAPIServer/SAPIServer.vs.csproj create mode 100644 speech2/Makefile create mode 100644 speech2/README.md create mode 100644 speech2/build/arch.mk create mode 100644 speech2/build/configs.mk create mode 100644 speech2/build/rules.mk create mode 100755 speech2/compdb.sh create mode 100644 speech2/src/base/BCondVar.cpp create mode 100644 speech2/src/base/BMutex.cpp create mode 100644 speech2/src/base/BThread.cpp create mode 100644 speech2/src/base/BThread.hpp create mode 100644 speech2/src/base/Mutex.cpp create mode 100644 speech2/src/base/Mutex.hpp create mode 100644 speech2/src/base/README.md create mode 100644 speech2/src/base/SaneWin.hpp create mode 100644 speech2/src/base/Thread.cpp create mode 100644 speech2/src/base/Thread.hpp create mode 100644 speech2/src/base/comptr.hpp create mode 100644 speech2/src/base/comresult.hpp create mode 100644 speech2/src/main.cpp create mode 100644 speech2/src/sapi4/api_sapi4.cpp create mode 100644 speech2/src/sapi4/audio_buffer.cpp create mode 100644 speech2/src/sapi4/audio_buffer.hpp create mode 100644 speech2/src/sapi4/guid_sapi4.cpp create mode 100644 speech2/src/speechapi.hpp create mode 100644 speech2/third_party/README.md create mode 100644 speech2/third_party/sapi4/include/buildnum.h create mode 100644 speech2/third_party/sapi4/include/buildnum.rc create mode 100644 speech2/third_party/sapi4/include/spchtel.h create mode 100644 speech2/third_party/sapi4/include/spchwrap.h create mode 100644 speech2/third_party/sapi4/include/speech.h create mode 100644 speech2/third_party/sapi4/lib/spchwrap.lib create mode 100644 speech2/third_party/sapi5/idl/sapi.idl create mode 100644 speech2/third_party/sapi5/idl/sapiaut.idl create mode 100644 speech2/third_party/sapi5/idl/sapiddk.idl create mode 100644 speech2/third_party/sapi5/include/Spddkhlp.h create mode 100644 speech2/third_party/sapi5/include/sapi.h create mode 100644 speech2/third_party/sapi5/include/sapiddk.h create mode 100644 speech2/third_party/sapi5/include/spcollec.h create mode 100644 speech2/third_party/sapi5/include/spdebug.h create mode 100644 speech2/third_party/sapi5/include/sperror.h create mode 100644 speech2/third_party/sapi5/include/speventq.h create mode 100644 speech2/third_party/sapi5/include/sphelper.h create mode 100644 speech2/third_party/sapi5/include/spuihelp.h create mode 100644 speech2/third_party/sapi5/lib/i386/sapi.lib 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 0000000000000000000000000000000000000000..7e73f8bd18e56ab648d910fd8f3bd642a8bf6201 GIT binary patch literal 976098 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%0AF`x>Ydcr4)7jaU z6?u}?C=v~heTpvPc5CbNy(GY5`hI7J3AxFN0d%JWya=?51=So#C#S%)-`vL$ot2>N z*&bhcE6(?=uqfqp?KlZ)r^%%uZ34~sfaA?JcD}%OTg=X<^?tXx(fw?F-0BWihB{#) zUWbV3f_U!9Dp|7Dis+^-w;3_kkvxP=C0CC{^W{jn!i;QtZ!H#7982F@l2ZB+BwDdS z7XMinNkYba#<*>B``9c$p~{wWH-i6N80>8kQhiOqrC%uaj#R=AL9hX~0fsvIUI(f=@MY7RI)p~M*G3E=sON*`gO ztX_3WlmJ;H3_tsIK4c0Wq?#G!Evjae9B}1geU%bPo%Ia;gpftBrpPVEEzq$tg6!y( z@L;7t97eYvTh+E^!1SxhGYEj5qD7uqaVXXS!244;#;_sfcu~CY&y>SJB+q zT+%dIs6h|LWG1EUSCW?{#oHiIYdNwYAel%ZSuaYe;@2apY7wp^ zmA6`el4|;jv7x56p$hF3<&!E#Z{4zr(p-yBu+@_{J6p5EBR#?u0ffYw6^*;g((fm5 z*Dww;y!&|^WSYRT64X~rWzp2K63id-gKLn7yoC6e6@4YvG85vmyae;P(or>AFNsE+ zc->kT`_&I#pB>Eh?uo~o`i!{d+OQwua&Lg=k+BUh4y$T=NHFdoA?&ce_XOcx(<5Ya zCy%{PdI)-?St=CThjjc9gW|L?mYVFV>z1dZab=fa2uX&T0*NHOnnW=C=$0*09QK)R zy@6A9$uacahu1+)Ti~!1B9ZcLkS?akby35x&mJdRetXytc?<)WiyXPZh#OX0!@d?9Ifma;r0y_NV+D3cwM=Ox@s?#2x~Zo!=ErKqT(Suz%d7y*S*H9 z;-c{B#@@DlQ;kH;n`%gT!@TmUksfj85H1uel21i;h*#8?E8Ca|&p62q@+(4p{|bl= zgox6Bk}6=ZCMpGGQ6kS^Jfy#1fu`TE;Hs+SQj@CL;Cn^YN+6aOTeTq2YTae}kJ7=( zXf8cVqge6i?I{Mcx_iMYyXcBpqz}3jJy31pIbZe6sV7J09#T!K#4}NCeWV)3!&H+d zC&1_5kK{GKr8~?=jh2XoAc{sqs^u4g#&-tSYT>2BR>U#pm*jThtvC4^$Ih;?s&*zS z2DM+3NcE$}xO5YIv6;2WR3L@U0=Em*HOe1hyrC<{gbi4RiVR{YD4gV2559yoQM=fD zmXXbA=xMMp4?HrU-|i2`ujx1y$VjMrqnjaI=%B!8_f;|`JrZ>$JrQ#Ok&3to$cwjt z%ZoM-OMI$a&2r)|6{*OgC{kPa-f?gS!ig`$iZ!97w{OH`YDP|imz5)rMA{NFF}}MD zD#k}SiJ;7hI1883bf8hIRLMz_1D=R_(IgPP6c#Ie%)eNG6Ec9Xg|+wGi^?%od9_`a z09bqCTvC(h5KF*H%kSuSg-jH~dtjBP})wtcn@|?1v>4~Prm?w3t zEH<}rMcHe0c&07Ye0|Dw@#53{Cz+=`y+)lBr06Fb5n0or^r<5oJ#}Qmr=F|~-P{Oy z;`QW@3w@6q4QBE@h}65+kfkrV{yM5}igb$^!ts`y2ef}g_)KG3w*&Mdugq?MpeLB7 zg*zBD9e2o~M6pJ)q=fDmtElOodZ~DbOo1v4r58#=aFb4bEJspkXSdV>TmD(3DQeJ5qBS_p!|^H~Hbql6zcd={}8 znZQ6C?pH<HDQ66R(J3 zXSTb)2+qC zm6xfQ)ZtzntSlv|`nxxn*Y^$=;d1ogVC!(!d9pvp=`4pkhoh~7!zz~1Ik`0rR?Quy zk|JzR=pq)u&|hbNK}uHEGu0FS^2KK>%aR)J9zm!aK01&ht>~{t5#jXVpOx^ zFT+=2_J@ir^{QZ{1vhHuBP%0zXYP_a>9iRK)ah$J1Z2+%inLs6G}=0PFu6BBn8}K{ z95h;ZUuA?VaG;qEx-sWTs_}RS0ij13+%bEfby_&)us!62RTo}NmnlL-*?ES7(XHap z(Qs)gee=kL(oo?S#X;3hW#1arIAF@d8dg9~=ua`3GDc5LD7$(Rvmz}Zb}r*cB*qLM zwQ&=>$VTC=nzvkWZ(`8^Zzr)+3BZ`-WMK#{Q*6*71@v55FNjQek}r{6*xfaoF-m#S zsRJJY%LJ2w=Bh1PzH@Z%fx2#inoG!Wlufdpzoe?G6=c+K<7jv53BCQsY*yy1u&=7- z%mG2g5mV+I0CTM{h&`Gg?ino%C+?<#nZ!+TT3xoN@7hUCHq~T2=HV;>J0UY}X&_|9 zg#}D%)>!*UgP_zo+0tdyTsNsVtnW-E5!bnxG3{H6WOD0;Zy|G;wk=RDv%a+w%g=pX zs91P2Z>8Mq`L&A_SUm1xkzCHX(ADfyWra;60J1l(z&+Y1R6Q;BVC zf>{WApY0XDDn%y_??#0h>7<&6yZvrOoEui{NH2Jw#tN(U)@F3qhcwBWV>QjUSS{_l*oVxvxJHWe&^m6BL=+N2;-9p9-<)jGb%vCdcLS-@@Q(R80&>41bM+z4L9?sJxHjHu-H}zYSqMo@r994Cn`0(Oen@2^?l_&9DSnNB|RJg)uWYLPxQ_axvD<(WLMx z_G;zJW=gFlMLQ!|g0wc&z_%V@Nm+-a16kRIyJL?NltLMZ6;i%YBqRej0$-x66KsLU z@T2DmViuvnFrAO+dsqgc3#u_fm{tNZiK;c@bV%NKEQSbLmdY2Sl*+E`#Sc4;l^=E4 zw^5`oQcH}A+{SMkku^lYGLe{=w5S`!be$n6C0wFYrhvU|zfg#J&5cn~&i1z5LY7Zc zZN%PKm&Sd#wB2U!TK3zL?%6q zo1qspo^XpdS|UB^%kT_j}P!}0`|qS(IJ9x zJ2R4X>_~HfI^sH?Ywq4moz*++COH0RKvzp?J5tBkGAKJaoK@?5m>sudk)7ed_66jXvNOX zB7mJEIk-v8T(+mm7Vz6G`{ojya;b#L2Vv#MG_(OMLNVVPI}Bxq`&opXc^t@8)k>a6 z=0~5;k9BW+;y>d4EH%rTo^h=mg71e=%6?E#RWw@*Wt}ux*Fv2Tf|6-v`3Xb-ogGx% zbYXm05z9=^*G@(Z^Z{S2fn;3(w;B)<%j%wA5-`wi$$R}MTd0~f&jgKARC33;nzdmA z7EMm7)i?J;!Ki@^JY88w zoa~oEu|rlNdi!O0PZ1+%uE?zFCLzwvUTs85c1xM9Hepv3%`n7Wrg&lu+i+s;$+$eS zVNd80J(!HKJ!p@C+7s?1P{w3c(HX#yaoP~AF)=WsK$X~!0H$wJt0z`?To`$CS6%x`b$(+0S8Dj{=6TRt?5va1Q0)YDusk9S^|pI-oC zbR1eLIA7)#WX`xk$_o{rfEFn?YjR<8!^t~q)|Y^B9_JxJKV7_a&@cZG# zDoGhY+{!q+)H-#?9h<(GBCd>BQtvEJ8Cl2VMAG3*B4)`qM9g{_D&a|Cez`mxfw_50 z+Z^c#BxuL+M_u2nny(40h0029WuC@G>PdY zHClQ(wl%Apjn&BZ&NUC1^qzmBh)^grU2>krlo?MS0+wu5`_l`|RoQ%}>fq(HQRV3Y zj=Yr%HsXU6>_Hil9^Rc1Ykw)MXfB~D)#y~-F`N-x;ZrF4cy2-!uc4aSgrh=Ku!Wq= zVuY+_Pqz!xID~Vdcz~y<6?a&|ql6no8Gu5^*UrhM3?Wjo zy+A{H9#-!D9&GI$?jjB)RZ6TK%#C`~5l942U%}d?0EQ(*?5@!FMsa1;WIDi>Ic~Zs z+{iI~vafHr!iKmRg0j87=WgT4%LpAgp0fox$^??h!y`CMh&9m;`c~@*qPPu6!I&Wp z6edPOGpYVfp#}C`@x>x7N!t1p+gaB48A8mh*wBmARQT{m$L=acbwk$=XRz+~RSnbm zU_rQ*U@R-@NFgN#P_!$TB77)l{Rn%@ws0s`1GU8(M!cy^XCFc&!Q~_PIb>!th=j1x zl5@R5n%tI*_e=BqiD%`=2`tZE26!TOLavOr+v|PYi7R{aQj4&u7rHn^o+IhW4wGXh zL1bpkil~ZQ%M}R~OW~4Uwh%6f70ck)#K4|}G7A6#gJ+yyEx)~Uc)YcXU`Ju66Xw9H zvVo8NdbmEtok-L*n;{otFUPMOA05lPn#E%9N>Vo8d>1=6bdqXAO+m2!c0O5VADSkv zc+n8(Rl9Br!NK&Yr82vP zHn5As0J-6qzAL!#TfXIvLblKl6=>C3~GKpr_@o=u@Tl0bst$;GVL$q}&^L zzHBf%^7~S@+%a%}6zTukV5`c#d~<2(!}#V`S-G1?`$}NGi0{9I?{iC+v*oS<_jGM( zsgG}dRh7F{TUz>NeDkZU++UBh-&9*#`tR}mZ}EMmq}(mwYW1b1KZI|7Rh9c^fcbHQ zdkR=-k3`O2kLN!H%*Dpi(ns33SBR!;9jNZU1-?~vbTviv;&?t77bu1#tIy^Q{S2$-)mxH7rCA2eP9<`%xE z_m)Bzh=|7Uv%gFDif%#tzuB;v`_a7U~xh^@(m-_%IUyk(e5KK^yOu4@g zm_KfCW#v+Se;Sy-hVQ?L?<)EIGo+7ik+-1SjQn0Vm~WHc`Fd=F#_vV?ze(w3>Tv}| z@G1=B0YKF#ke+=j(9~G@k7(EzR-GFGnv^ zkKYQ+cNtt+J*WqNz+nEY{LYs<1Ma7g{!*W%R+rlW=8nOYmHSnoao1qJQ-0^mWxM?$ zq@NwI)ar7-44AJmxUzCT1{yCK%vgTs%l%EjeIDt5-(aic{Qm%RaY*jU^@ZiW$6&6@ z?|ix60^BX6{}qF+D);XK^K%AQRo{PUFz+3a!}4o*Uc{o|Wla3a?s_OfPfcZg#D=U{S;tw0lPs#86__hJu|B3V#9W8uSm3s%6 z2L@MF?t#I4hy2c$OP2mqr2k8Utt$5-yxK1_o^4gRpD>tD%kO--EN&g?-*2#0<^C`* z|Bb;_mHW30<{!%M@^a5l;n(AvUsdHk1m;@|uB_az2aVrmFn?Ko=ga-yfcu}3{$uMb zH7GY3KYk6;{x&dYZZ9o;5Z_NPJ(Kl^ejK>3MfyL%H@{px5_+FN+A~xxeEll1FEi3&33dEK9AnlkYQ_m*jU|evd(;hx8vaSXYlsxqlm& ze_(KB@}qtJrv`I{la>-Y`3Narjr8voOd!8Zxqk|nA2qnLaybtEq`~}i`JJ!t_W*bK zo8TAYn_pG+{V##}34<#um-YSY2J=tkcfQ;=fjj>jmX^L1-~6g7_q%}kBL-JiF8jxy zFqpqCzw_n(2f+OwNI#$hg|Dh|zXO=xV{ldFexJeonEcL{``c00-$nYpO)0jr+{eKD zHiIiGmqYLG0_N}G`@-j_Rr!ATEx_GC`k%o!zpCo{S3kG3^mp*hud;HVL)y=N4nOeq z^Pl6-r?d8eCiLGReY8bPb-CNX92s0$xgP|L-we#}!T0y!`>B$CM6>)uNPq4wORX;V zmHWRN%+Ja1e7WC^ za{e{ae+M0Sd_9ftvN+No1m-_8xT30 z`v&vv@;hHHyY}xy`ad$*s&fA=Fwb*>fv>7^KWH!?mEZYtX~Mq->A%%rtIGWzV7}kr zT)C=yEM4L^U-V9XSQZ&T)tOH1E?p!mW3aQ^zy)vq3Z&D9sL|C+lyM^~GlYX0h9eU)byKHT{N)@!eF z_am<1Ik<|m6!`+<)#c@{yLRmZOHW^^y_+RGKbfvKHrEIJ`WWZ=_P)#{JhgO15}Ng1 zZ*$Tf-)@iJXOf;?dRCH5j!&A$&n$g7&9ONcZgz0<`+9H60{@s6I2sS{ytWC#xP$Do z?GKuSr>g0X%AX>7q8vD?Wmox)Pjm# zxbihuM5g%hY`5Fmw0iR~?Q{VOxmpdY_z)v{f)8F<%2Xw_K z=;IFb)VF(PTjTobaG;1~4|%!-a@|9oDS^C5Q9V*oHF5g$q&?l7w(m?oVje%W^d9>d zd)!8y;Q-s@niM26J-zgPo7x_%b_Z<>`1n%THt&_TiPudxJ{m!;2&8_5{abgBk7kD( z??n-R0YyBubooxNJ~bL^pFVA#HhbOn0L+G^y-Q28Z`W;<@e&mF z`;qdUMIv8$V7tUE)Vo1=PnObTxZg_YhA zx`yOQ{dRj3XLZ*qvP2W`Q>Ep#30{za7ahbjSPm zxXXBNwu^-}Tw2DI2~#%Pcbe@HH6Imf4#%x8LkjtLcb*Mqx{~Jka^!h{gb!@qK|gcV z`pkNFFkK(@+Akn|8|jzo<8l49O|te8Ji38L?;E8;Vd}e)`XQuV9{C*a!L#?_*|V@3 zo0H~nKn?x`9#Xa+NvVXQWm%tNS-$;5+ottKuRWpQp@?X@K8)tDxw$fKw>Kx#@p^Om ztB|&iw2y7B!GTbu!@XE&jan|M5d0`cL$ z0#F|Yxrw|S07;QRc^2TFCa%?6owoZUScCR^fm_0}=b-le_7pvV3QC>-f06tBQugGv z!L)v7v)e)^?5=d%V1th;`)a|1KZBBa=j%mF{y}9;2r2XGWdtL`l z+sv2o_~RIS&eW&FK6(G=9|NCVw?A&s=F^8K?dJNpJAF+Wb=)0Ihhu5c z@vz4h{Z+7gFK{<9u3F!057zq_6`OSm@y~;YXN7$u914Q)=P)#EOfXQjiRIIO2IzC6 z&#bq{uXXB!RIWnjhhHF)-u;N~l$KH)~}USQeC;$I|-Xu)P3c6`*TPsNq$@1pT(dH48pV6vy#ZLWWB)^-@++A^vxVeHc z{Fy6LB)z{kn!=B%x6rrhV`rCGr=LUe6p#_`Rg=ke?x;@NpH+UN}%v{+zd z>C(!b(e!$2IDPRNOTS84-hFa3BXeZsVh5e;Hg`ZWnH0`2JEcgKIrkX%pl=>I^rX3| z&E#5ig?-aDK6~Lm0F8I|My54ku?9_AXSUM2*-E3{aIl)qE_(P0lzR3v8|Wvl&`!U5 zr#&7vZt=(WCn>J?+9bPAvP}FiKKxBkcyA9XRd2P>)T2qK-JW6- zYMUnUhmiQL&FC@Av*`eQY{j*~`h1*?KobW`K83HVxaU_f&fqgtk*Y+C`VyST3y`Y_ zgE@Z+VUJARlKe6V$?Ut?p#hl@@&oX&2jfM&r%)?Rt-rB^yL{`GGw0gD}Xf=X>hN zQ?fsS#6+^v7k{@h9&H5Npv-6pE}#dkOkW#`KK#iKP#*%HiuFEsRl0Ii?>YtaU!goB z&jvf)kK*%X$hXs`saYAalhHa{@}{9wFm*NvJHWY~^Z>RXn-p!|*?^zamEq?Pqsq_n zqqS8W`u_rocpt3aW5K)J2WN5b%wJZp#T(%7b7@a|DOPSslQ_Rp`vrNxF`mWql)-3Y|RmzjPWI;{{q_N znaQ9*p?pt;P{dl$6vM)*C8nlR0WVnXBSRc~&Nb_Ht*-0jU2z!u=rngIjz<(nZ$!mqdE}2ZI5%pt_SB6ZhM)KB zsC#<|CE#R323SKFQltR+=_1Ayn3n0d&kjJFc^=A2lgXkvT3%+yF@q)b^b*AS0`)iA z^~kx*5zrrr{3^~y0*{Jy`;Q=~v(nM|i3OfTf!!91`!1xh)6)#l#!@)jAbLT@wUyqK z<$sHmAMeh+zQODycA4rpnLzC)Yk^8Yl}U`PbisBO>fl#E1n)y%G0rXv9rq=cLO3j( zDZABBYe*UQM8jy;KyB#^mCvc;IzL$_hw^<6W?2}T4%gZPwo{EXMlwOAn(U*DD|9DD zlaVzOb=nDb?sxS@BlrPR%QD-D1IKv`99=kX{LDI?U#W}UQ9hps!527Uz-huwYnZTp z25u!w=E!hvGHkB3r_$J91caQ6AcT#Xp^iNOp-Uopi6$@$YjnP|(H+2}Vi)7*XF8M5 zQql}`ot3x#nfY~-*|=T=uqDyfXhzoiE&K@*u=(F=<(eF z_`T!^%CS)&x12d;7IO6*!iuYPbWW&Fv%|Vl)Mt-3;Xsp@DG0nT>&_EPxt|?%*4nSJ zkr*BV>8LKUr-I?^xC2<263s?A6DZVseJP+7^4t27U&CC*SaEJ=#_(!3QZGoIl<% zlUYn0brQe|5^#0|OVpw?`RTpB%Q0x6^Gm7?WdXY;MhWpH)`Ind-DRb`3a+-gP;Y*| z3IUzJiw(ZBtvxdT=g@@D!|qM*Ok3T0Z@4-U`%cqx!P*s)B^wyLIPLTmYBk9(yFC;Y zecl%c12GwnLl!v>f<-?19U!hf1)-f*o2G+maRJxOHV`vw(N?g$Go6h=%SoieUQJWY zBnb>PO|XN;jFPx)Bti4cx^cGi{76j{gFG;;EDP+SZpQGCymUqBv^2{<4qiS2T_27% zd+popUJyaSJH;62SxZDkmd=AajwVzV1~xBhSQFt1R+6E6^}b*uCNexQxPBQq5L%aK z%-8^-i|!RxR*zxWXJs7X6beB_!fJ%Mo3vQrSMcOAHoM#N>sd2K$S>FcG#~srfG%L{ zk(XXb{EH+m4_Y#0$h_*e;o(JhB`lf$OVEl-{+MS9iHdVpW{zGR5J9U;qsxr&coXmD z9~?3NE+}4-Q41lY%}u&dzZR^#dn5zl`pRI40M2WZ?mz||j8IEwC!OI~2CQE|OTJKe zO~4h}lb#_Qp?S}a8n0>ai1z#pQYH&^qSok z18eP9XL;& z7KPyj7iJTC_9<|4fw3?iQc1yo3=f`1U9|{_4pS9K??R{567^s+Q?s!=&^2a+jYG`Y z&T4PmEa9w9VbG|Y;jqM}`3OpT0aljRE<4qic)^E}@*D;3eD%0`M)>koRJ?^mM>A&3G3LV+Lkx9>D*pmH2%T)N%p}HM3u5fH z9I$9+K9chgYy|o$Kz|9;zKp%AzlsnvU60|o`&n__;qJPD8$nALb+O8-=B@GVF}e9+ zasv&cQ(yi(Qr_*N1-h()Z~^Vc_ao_|JBfoW{SA0>R*pKQ82&6ieK?XSmYV}{ zvU$EAD*vwJ7(^=jpGMyIavoq~iq@96&bN-v$3>kV1oC5{)^gnr3pu(Frpt2V7BCFO z%?TRG%;(qymods)ljA!}3#EGHhc8Mk`~kq#uaViQ8#~0B(sGWl^6agQ@rVff4aoW2 zC>)omNo;{SXi}eNuODbxqqSVQ&g!)GeuWK8!0<=g2vO2Wfi~pK31_?pTZAoU|v3v z*$c_Z?1dWnS>ps#tC%3+e!G6E5|CP;md!?>$&qmxI~1^b%Sy81 z&#rQQXQFQGM6A_0#BL__KF7ZQ0p|Kj9A>&M2AYh>=#O;=<$*283Co2(?HCq+y&|+W z#G#l19FSeLj3b?_?KJwtz( zEKqwc^qW{E9qUBwYsu!wx%rN;vsG;E=eSX)j+NA=?Z>Q=vDH$oubu=wC1=vUtU%aA}AbzJbSs9TFPCVc#uGSlE5m zK<2sVunAV5eew(kMUHph26{5y$t)WN8e1Mf?H!7*cq)V?1b@0Jg=O0Kr=L;3LaEw;`D*mLsHx0ryFV z0e70gA3#mtjef=>Y`nmN;3Nac+>-IlAn^g)SFFtpTyD0+v*ZWU+Lc~?bwY{Jb2vjY zPod61LDz1rR|iU1-l1LrEw$5WLuOCm!Q;F$Z-X{X|g zQKk{bnfqfF~o1#Wylt_?*cwZu+fp~H90I$zt}F& zuV^8K&#B(r)#g?j+jnG5hJEh*qpi(doIXJM=dm||an=8yx;KHZ<0{X_=W4y$Y}u9_ zCw5{bHi@%4juR4-#n;l6bz?2pSCVCCQ)ElF<;aqv#m+)DoB&1*Q1-B8fs}@&EP;}e zLK259l%*^M3ba6h5*o@ETDFvc{?GHCb7s!WoEba$X#4%=_q#La&il-H-{(E=S?0_p zH&G-Un7b;2yUp>d^9FUQ)_b zQYXv4LpoLK{UuVXWZ(OBs@D5FQmbX(7j>%En|=J;Cl6&0wO1T!$GZNBEad7w(F~rM zWr}w%mV5PB<5oPZE4_=nI>cMBm_L-h74=>(OM;R1`t?D&!OJw>4b(!fVtUWWlsrm{ zBdEAeOlGQ9@-P|8AFL>;_O{Oca<=Nu$EK@hv&FeB+1a)V`%l*Tv%mh%-vCy%b*`Ab z`iaGo4VdHJGLkA2I_2IHq$|ATSXX*0v91yaS9@!a&U)u#UE^IGp?m@Ma-r0sd`v)d z{rX#iKM9;^k>bph;%sup4uk{F= zk9ECw8P*LR@6?^|@zH}uI58Yg1K7)j())vWY7G3jetltVWIDmCG)Q@sDdkm@C3c{C z;YJnwoL=2H+q$Y=c~;!_g8X^7!b6j!JxUKK@4W;mK(p zjUt4p_>_`ruW$C}J+uG#6w)4icXI#MxtY~>%{0ya-Q3KogFkPaeQs{1@qxLSdi=5v zJRrEM2d=p4@G2au%B9IW8!0x8P2NW4gCJvY)nQ#BAy(<3RYzDUtD@nJu!7-58e}UEcUVGm&nmxOb-2m$>WMgVRJ_`Wl*_AZz-x4u6ZPt8kb$a5-+A<2r3Z~y z9Ui1}IU}!MhFh zbsOZ$CAbG1sR|GGwV*?INu+IJz2-vc1HKzD+veZqMpq^_v8}|kWt>`4GWgK zGSX?5NrfqwmboIviLF1e^zFNSPMM?P)BsM;&CSiROv;817%DVCQDG|P_{PBT6Ocb& z$G^un(&c!(sVL(3#m4cpCGK~cpp0e8?RQG5qw&)e(BKnXE*jCXk}1zf{Dj6z`LV$r zqw;l)2oKXnGk|J_4rrY5IZaSBm~zvgBrSX>Z}MJ+wF(JW_(UlsgwN4YN{Am?ptvv< zi=U-|Sb{UijAljgKFy-b!Nm>9=-sF7{>lYS4f9Z3|933YUK+{lY zH9)jLabYSJK+S>YKLNSR^XreUtwG-`6N`^qv2zGeiGDKKBs=ggsGU%R|P)*8syK{=T@bS+ZeC194xR?qm9)O zms7nmlqt8%DT!6s)d7X?L++xG*6zH|4{kg^WepfOqp!aC5vj0-1aDudp4csin7E+< ziUd<`5|n5X$M$c<@cXXmRm*3eo5jfcf#L&mTh6$8z%Xj`eh#oY$1ao8zzR7{Sgp4kfWEs^`0zx^SDBm6?47rY_-Pr#6d zDTYkB8B*eA=no3B-l9Jt!wx(tf=4?3G-XJ`6ho%m3@LFl^oK2Y3qS(HOCr5aLK!Z# zV-zp@_TS|FCn!alrZ_U?=12)S)}tO)%emCjCmt@tsnio^TEuulQi&-FRzX~gM|xv~ z9#1*AP-;!}EVt?9_~O&H!KrC{$?w46sHFVs>$GW@pvb-?i>Xst z%#_<=O2QVe(iZprcUg=ls*-|&I+evtxhS=!MijAZI%Ji{5PdW>oO9;zPtwk(m4C9HDx*b?b)x$gckah)Ap`a*EIHK_Ii6U*Y)GQUeR3TnEn?2 z>wi!G-Ru(sS3G&RUS_bUpvgNPs(9wtB(v~`u&)a9UY_?#NfnTKg{1DpS`B*3WzN1* zCOFj-loUqtT1@&;9ynUJnWUoeA~N;!FKuUx(XGl@7U`E{?h#L*|g% z=b>lnF1@O*iSr`1QhD#Z$bSjdolgB-+6YTy z7?mo+m~ywql(7G(NE_kbYgvD^Bm55qwIS3($PK(HleKVq-OvI5E(SWCCB`|pa-7Q> zZZt`8V@h!|8qMgQ5;r%$rf0nmyZ~+=Hku-5FTyQ;66Q}tN4W94UbtbubzV=46g8&Y z)F?63mZJG;l!lC_X!1j2=AXbcdY`Z;(sFaA8J%or!_H+Dejf=ah9;)fm!F=0`LX>f zM?*)>rm}%EiseDcB8tx``X_F$yl)Hc_G34Ssl|PeN?|s7}X!lf6f~I3=2EmUe5L6#v zIQqhE)B((Uw<;$la5yPT@kXjEtyGkmQk0EFrmLbPnX*5HSnvJt1yKH2D&?cEv-34& z&O}s@aU`Hk8Pi5Zm?<}5N_c+-D(&9JJ&bA8-=>2ndrvWa@Y6ioJHe7zyQ}5w@9BBC ze4ag2#Y^W~D$afEYV^r$PbTnX3rN&G4}6<48wC!L>v8J^ zk7Z9>?Xlm^dc1nx;N>GDANJB*D1AGx536NGD>*X^u{-s*_j}`b0I7DtpF%CT$ zF;p=*GBRXBh(T38F|prxlm;u0GNn9fj6etp9ZC>Ft*a{LHdM@Rs5o5V{XqnTm&I-? zVNcA3(su+LaGDl+lz#nseDtI=yenqAF^xKuX-p~8Ox~g%`BMVZI$&C%0{!hw%@!%o z?dLuQD|ymhkAADktCil1b*NlU(<}5XDbX>)QXsf2#?P`HV}yw9`1-~0;M8!U@l>dc zXG$4wGB?IkQtiRgthZF`n^Lviy?xldfvNGLSDzz_*=YLi6RBb6Ii?j*f7kM_ zbZe9j9pEf1$8?WiU)4k>ra1SQ(4mcr5>sJH#zsnnQlq!lq7pfe4=7=lBoYxa zY>Y87UT1Grfu8yt?qD369Z^<>0&P+hmN$dtpNrEcS<9*o~KG81?Kx)M8w0!T_&( z_R2D3K^#8?!{!V2?ARq+u9(lT9C)nW$8j4lqY9($P6Ea|Ygp}JUcpf(2->V{7PO)~ zvjuDN;ZiPLpZ$3mRwBj1*sd|wE1SiF%mtEzDmmT#U=Pj>WvLRTw46A8eC8zCZ!={+ zis^|W!%MFfMl)sJg7KL$uiz+!)`y}@gOBs@M6*0o!rCyciZSItA~<#rS27{$C?ZX$x`u+|7Af;>iHQ{85(hCPTBRJ!9rCwrbBE{vJe&r0?M;ebb3#iJN6cKk5+uvaz4@~U+1 z8Q#yw5A>+Tc=d1f|9bH%Ehp}e8$5k)p3Ri`D5g22xU|aJW-1t;Df0@BGNUIs$gt?) zKMr2XGlN(gru8wVYze|lHO68(Uof15WrM61!}MSD|M|j{mJ@gUMtlxQBsNp#qnK_L znJ1G(;Wj}qK2zou97QIL!e-eTrmXvd z@tN{paMa86QEFo|Wxt@>Rl{^ith|;A#$8@-(=3(>3tB}SKMBP<%EBy|k79AB$nbi3 z*%}rsFTwaMm{)MrtMpN7W3yoYT%Ms14U46*@?u`$^3oWqyp{>Z&6JZoT$Tw_T2354 zLZ$4oBa`_krgtI5<io*1Z`F}Q_c#7nJ$YlsR<=wKj%c~iCf{`Bcl0Bm3KKu(7 zo5hLP9WJltSb3c!7`FeC8MYc@mDftaxS1}~4qA!h$}+T^IDX#igV=_dG9SfMF~n=m z6-JjA>!4u#@?u`WQ4b2*tZb&Muru6du8c8#kzj158e=g%SupO%yjU|mS(wst;`l+a zPhcBn%6t^l_lwN))QHBEDI-%bK2zou9Q7f6l-k%#Prsg7&zOA<+b|2}qgXs7GS7QbwuS}EOE5kQ<`o?Eus%v{Y!;_tS9xX#Yi$mWqE9rY zjYqK854R*5W0lwGf^nDEOLf+#3sYK796y})HEhF7nU7-nh{#Z`vNcR;n_zsV%quwR zQGJx!*i6sBuJX*)SR1CN$I9zW!MMxoZhhF9!h%*2$IrEWAKNes=A&2~7MbV$P_~8z z%S$jm3+5FZr6NEdYRaOA|9K8kp4o}DVR2@xyv`PkUB5KODz7zyaWnn6&U%e7rRBu& z193mcHq4ayD5hT!ndkjNwl-72gqQ|LeMKLoHg##Fi2hWW$+=R6$)AM6YFA$7frW#{0y-+Z2rl)D97Yb8a zP8>hGwromA)`Y2?B#b&wz|I0JC zVr|Ow(iqd6U~HxuV=>(*7@l3K8=SZ`O5diLZuD4BX*qHHnBjVX*yk6_M=_nJ55GuZ zG*kAKg7KL$uiz+EAFxXnn`sO7lxO;}E>l7r#oRPTMg^^cv6*U&#WXJ%H`B*7)4WHf zw4At?mppHiVqwj}G9SfsiO4XMr!W>%!GxFwM=jGwAsZ|=rW#{0#efGGH`6)IbhAgMw46A8B63i%u$VF*#q?xt^G=1amnnlqg z3tB}SKZVKL=+ttb#_(TRXg-QLD_$?r=o@8gcu|{Rd|u2wIO-B#2X=>ep}7OE&tPqM z6=S>@$>o`qSjR^@AJ;aQJo2Jd#PO4ycPb05IAlJGMNZrEDuvN;$gBk8vtVAqQEmDt z?8IW14#FN59>UtND8=Fs0Rv1U)+QT`u}ZK{Fl>$aVNbOf^fxurK95XkIdS|5=<5x{ zd(JOGVC3*63^`fMo-;#x?C7O-RHl<991mpXM76eCa_wArU+dl|1aK9I8 zim=q~xjj>Aka>1;?Iv&qgX{MKZWJ=44<0n#i;~l(eF=alA=`N9B z{zqY~covM$lz9b5U8|2`zTxt^0{_c12e39wFOM<3QZRNrYmCM8D#5s!-lCaa<&h~Z zCypOw{e)s+F=alA>6o_pZxzO3Dwq({;HW8m6tcl$mnmln$}{`1HcYRIF&z+$%~WG7 zrq>9@eeU@V&GZ_NOldiB{0uDbwF{T&HTbWX?$S8&u#`Y7zgVly4Y z|MJY6u{KPvi80+F7@MiaSWI^c#$BdQXr?S8&upeH8NzGabVJ^33&E8>TyBOos(yGu0T2=`O*n#5!J2f1;W0^2n5y6UR^8 z^4_{IQ|6@<^-;_>%yc*YmuFsuwPCs|#&nNhY^EAxF&z<% zn`wO&gjhyAGNt9j@#DI@=Pk^X`6#BZ);9l#!dOfN6Ji=174&41vvps=UhF8(yb^1} zbR@>~TEW;%HO68(Dj1HY_=#S%Xj8qjHPca#OldiB*=y7-bhyi4-|)Vj`zG{Jz({JB zK8kG|Qlfsmi6L;?*wnnM+|9u!<)jdJj3yoF=H~ueOfSfDQk?y zeMT^io16Pey17QO*%!}R(X(;Ee2m#M~BOm7m5o9S`Y5MsGWn9_3M`1xqwa2PIA z=A)RZv54p8VoU`SVj3K!Mkmabi(PYHivQ)AJFqrPZ;CO!Sui$Jjj@>CA{aN*OElA4 zgefg2?sg0S)curpnKB>6^ozQ5x?)TP6Ji=1_2tAey;UsaXwxvgCC2nN!PrbS#$tNA zVBAc1Yo@mgQ(8`(`b0Jop%#hxD5hTx+icZS!GxFwM}0kfl+_Er3^|u)cm`pZ-X3Fm zP%t*r5Qa^;$EYaJtYI>=+y$1GUb-fD^ku__ExG)LZI@&3Ij+5YJK%VXz#$tzKMZ>mhqO!;X%HfZEAXOZ0GQXwQD@Q>DPQ0*c|MCgxI^(X-g3w z=ff-Z#>NkfZP>5@Jlv>_o7NO_+xq1DKN~h|#!4`1u=Wox7k=ouXzo&f4ne8a+j zE;pt{YA`?dfoJSuLbMjD0U*E?o0~=KKY{7WV3Wy2p`5v(l;{rsVLw+sXa==43g*rz zw@oYxKjDS!LeHCQ*wB~TbXjhrsag2EeQp~JP=%;lWyGvJV&yzos=j`VDH(9-xf{0A zYUX`u=m8_=F_($y>ggUgU=y9$C!c@7XAo5TFEQkXqeWPw3P?Ydt)ESCqjgg_cr6}c z;e#THsI$+xpxIt7Jm>s#E?9fs+H>ulNT0K2&H3k_kL@|ug34k?VoukvRSqZz2?ToYwSTOWmn+$amW{P6pMvJnf6BHrv^H0vJ)!~VNM3-e2wF%NO0DW zjo5GEw?Si;aMX(jE?jy!VfrtSU&2u@mNdO3V0LI+lHQAv$0#rl;`dejIHBRvy92lk z#<4p&mc`=hjqu<_^aH@$gz@aM+sOYIXMVeo#{-bp-HrqnKR<{6RseIh#$|wY`Hws< z1ZF>eufk8BpmLPk9B_XH`3GKx1QuU!gvXhXJr2w-@GHY;G%3G-2JU3YD>xd(l9bwr;(MdOn6(tn-6?8I*$eo6it25uJeXYk{a=D&(pD$EJ8b@O0;=R^KBjrH?$`0sLtuQyUJ$z!|5Ov%>GgZa%u{%kZqhyNO8aT1Ilmn0r1L3WD96lCkx`xn3sLSFr6 z%+2EA(7Ozn(={$hFZrIQG2OCt>*X}xZpgo*vA+KtdVc}TA2lvbZ}u)SKu;uFw_e7} zddMHt*fhPL1m;T`m!y~V?OVY7JAS{#FD+gczZ$O@z>kZs*AXvo)|d~=*3DxKc{~aE zi(ezz1^GGrw;7l#G%kq;<7HT5ULjkz-gf|Z59AlU_Q-mRz+9toNqQMCdo|_`*}C=a z1McmR*ZldB^&St*nHra-_r)5sMYe9e*FoI~42l@ExCA%O$2akimyk6syc$|Q2-k~v% z$kwfwP50L!zv2x?);kW&ts0l6_mIZCN49Rg>~bH4JpaZc>)j5_h{h%9JsH_dY0TZS zb?bcyxDP`<^rj>0y&jlXYFv_D){oa|%==~Q);kK^ry*a%Yu#A zjk#X7$$DQ4`EweZrnm7ep4W^Ymo&YnX-unZ-FkN;k1HX6LSxhPehZkNYFv`uCCKlW zz*OIjM?mpQs+T)}I~(#p$B&Dz*HJGY(3nSM>*lcwd3+1G`dI_&$w!Otx;n z+y>mYA>YOh2aE4#hhIj4d8x)F`DGdMcsVfl;rBlLlFIi6;GTqh<2$L<(i`#1DUfZ| zn44wm=J9^u-UxZ_9_D7{=it!?%&^8K@nCt3Ys}ka>n@K+fcpgGGxs8a#rL0s$Dw-# z;(bWAZXSOH$mb#7f1kqo`8jyJ3YfQQToR8J$mZP|^Mq{OdT#^nyO3XT|B>~M19Pj! zrRhDSF@Gsrx89dQ-D8k%eAkinZUttS#--_<(3scAHd*g`AV2lpN7j2WFr6Bgrng^X z_RH3-m#2ZRhJ5h@N7j2PFc)fEn%)+T*&$oE-h)tgBjkV3*fRW2nwMIDla&+k(1}%z`Ydm?!RPi$@wwvcWTVbWb5|J z?ZCYi@?~tOv84IsY+x?cxFo-@{VM=7gx?r`N$uZ_!2KEIRdf&*U$3LxI8I}7vUT(L z0P@%ldDZ(QyC6SDyKx*ar)gXg50=L|jTw}!yFC6DxLYBA2^(N6X*{|$X1{FRJU)m# zUJd!hB!tD!&%t90FoPPG#DnE=t;W1uwr;&6z`YalYBs=F()2C^=5&oq(#vtqdBAMO zuMfYZIM@l?6y)E;kBhH25(nh*ZyHlcCt*g`HD9*}lH(!2Q!rM34*%T^%!3-2#DjVt z(wHyHHd*h#Lf-Wu+Lo?&2QZTwm!y~V_oW*1HrcxM-VWSDkgxkNwWjNB2WFebrRm+F zF}KS$S?}GDANP?X>pcsYOEfM`Z@b3qmaSXwZBTbB-Zgu&b=Bh){=gP zxK-E7v0RbwAmlR~0AMM{ueou}HD_HvG&nsN09RxG>w$Sh!vjz_!VHj z{Ye0@RN?2kZnYBon?6MZ=455-F5lNe-VOQpH8#!9{|QX_qmpH!pBc{$8naHeZoL@N zc^#1dT4U4n);tCueTJCB_+iQ5=PF<7t<{)QW$V^^J8(J34{L0h$G=6xEMq?hgF$28{eW$X6yF5sSmyz4VaU`f-v1DHvTOVZ2oeW}L0O}1{mw*vPN z(1{h!2KTbFFcu^ALHPkHRf5_y8SW?+=4G)UJ5@h zX>sr>VBV^6Nq$+0Jl?G_pOdXy?<{cNhkWnfQER&1TY!1B#wF=xeS3?>ykE9%|7`{C z3y?Q|ky_LBt^=l3?z=@GHa1ab4$c<;Y;cm(a(3S=0u8j>G}uYBez1 z@EgUC4`sXZ`xoGDf&3Z<1Qx&CBKa{6rZwg@vUQgSM*#1Ee8t~0H!D9!yL&D$EgF~P z7wYZQm_4#}>)j9BZIJ&)V|^YDy|rJ(7#}|_NqX51t*Ec!YvbnAT?B&S3E0l}n~@8iIH zRpXNM($C-3nE#TkTkoB~E&K-BUi`SE@qHgKk7!(yUdGjDH0B4gb?co5?st%n{sXn9 z>%9$_*J@mv-nVMZ$7Ji)yBoT`1o^seirQ4Z?Z9l)xHP>xH0Ea6y7i7i-5Vj#eCx=1 z7X$MmjZ4#ew#Hm0TesdxsM`VgH#9b_e4hg5cN&+bx9r=B!|}3p>*e|Md63_)v1xk$ z8ko;&T#{bK^WSUC|B(;v$xL-iN?Yq>Pu6Goemug&+Uh;jp#ylunx864b z_c-KRzelakZ=7bQJd=Ly};b4aY=fYA)7li<{sI) z^)jA64*9BoKC<2mfN9sbB)yF1lEz#oTesd@fjb0w_WMWHyBwG^G%iUm%lCYZ*)ChR z-g|(%4)Vqy99i!wVAg3|lHN0s%_SOht!&-nKf2-&(+Z4AQwRXu*Rn8{UR{m)3_wPO~~(GHRiu$>yDSJ zfLr=B<{k0llBV|%Fn4QQl3wzCm&P2Ht())dz3YY3xmDwm^s>D_q%rT7 zty}LnaDNN=>Hkix>3S~(rd#9E^lsOfY1z8f7pTAZaY@q4cs@g8 zx@GIu`#RuuL;kGBrs-|?Ke*P3AD1M(EZ=)S9k$ zp2nOhTesfZkw+f#&uVO%-tPeOZyJ}xmvQwgjhX*TTIklh50X)sWn+I<7&RfoF-eh-fMx|2>AyzHcjv2zb)BCCE2?5z8binKtAaY=evzV~U&W3qMYy#=^$ zL%#KQ)S9k$FEBT1T$IR);j{+ z-H@04*OB!u0p?_lOVhhXV>Zjyt#=gac0&FYjZKTI9|7~98keM(<@*PXS^j%+aqDG! zwGQ$R2`0UKKMl+`G%ii=KWoe%Wb4*@6Z9^A4)a|2aY^I*ZeTvDaY=elK^~vdn4iej zt@rJ~{Q>g3|3IzjdOrZnCp9ifFa7*EjrmvEy7k@++#eyo>5tT!uJ<*-+@o(=`^==~bxLmB3juJ?LiUa4_Ode1~2uhW=EW$W&LzXaSrLH^#dh~CI~Jj?A< z8uLThx_P`2xMv}MH80d)Nvj|C1M?A$OXKmk8uK&Rx_NvNx~eNO-q-O9>5cFhhVZAr zbX3BJ_*Er5x6QbJ81nO~((`KouAnhnWn1RF&eRLs4#@vHnxEtR_Y1&$N8^(GvK0CK z7?|hqtE$c*a@^(72iysePvOTUtvp@<%$qeXNpB_cxKCsLLbh(c>=!-)`3dTq2B~`2 z0<%%$()4y{%of?Y_3nk3ozo>R?IJ z`*~o#t#N63|3zbdDqFYSE1~N@A@8m|vfiD*Ole%2-kUY%WwLea<#_VdkUyufX?z>& zGF~%&T+;NOrZH#B)~$Cx@^}g4AJ*73y`KT*A2cpa@Aoz4$FgbFy{oWjtr+p&!JLOPb#6fqA9IrRja0#=Kd!ZoQX7*SjG9gT|)mT`)i6 zoroWoG`**5%o^Fc^|C*@2=e8G`)L)xl!ZN^xmN{hh*#4I|RLNg#1~JP1DvUTg-g*+~R{GA$`ruQSj9M(8ruNn_=xFpLOtiPx+dY8O^=**$vU4t{D z)1xCh)_3-7Z7KCO+q=3uTDx+c`JQI#Un-yZ#r2!BuIwKf!yBcp+}gTx`mFICdt1Pl zBbtjkM|Mt*PmS-IZeCqFwfWq&XYLr8Zf-fd<@D2=yCHEjf{`stxIRES+m^BHlEsOjGHenKkO;VE2D-d`&Wdd3)QO;p}rUQ3%3mJ+%tSq z2(Z`(6vp-w(=|T1um8jlrpd=xuTDJ1D{I`akXFp=>FwJ%(AU+OEA_PJI*!$XjMpfF zmRv{2Ku^B3HD6k+MP**Si1ZPw^zL$RS@ej3uI_>MQog6Jqn8RFR0@lw?rqx#ka0^- z;qv@aEy#HDm0(l8cVk~$TfVeJOUk?kCD96x)BDT41!{j!zN@vAZ^;+7`ngq@+$>_Y z-|NLG`n_T&hx~P{?=KYKzQM7fsf{xuqtk`4{v_WUTyA0_(f8In=#t9VWRn;Kn?}d+ zqPfW%5)BEItnEJ*q)e3IrCbBU*Y6yjm>w7%nVLQ!#CL(uw{>K2bbR+zKMVS1DXaRP z(xy^pTW9Y;OWURudUwWK;_vP#bQXH^t*zaixkA@64Jh*#`heC#OK+~X(A{;s5#HwA z7Ko8;7sOlhr}*N`ZOi?mL)k0fN*`Eu+fpCst5Kj6eNg81z}VJOZc}%cLYxyo$`T-J z14wxSq17|UGxJbS+8Csxl(JPE7x&MC{Anj8(rZ#lYfoMA8$fb zaFt7~GN(1)n=f_3FC}AVof2&6%XRe@+6wuSv8Y~IRHQk560Jtk;M>|;%89LPAZhD7 zuaUMEx}Zh;(cNW4^OY#KabqdJwGhg$QEMvYi`_j1RWIyzsZlDU)lie_CsEoNuWnmM zu2(n3W^b9^+tN|Ucl9m{`D>nEuh}s;8x_2Bv^Y6FHa>%w=JvZfCdMg`UfbUs%6pOI zZ6CfCEnj)#%bReo=s;T^`ix?4X`r`zppHsw)fg_ePhg)Wrqrh!s-UoVPrpqML^n8US_Lt95TJPUD8ZfkxZ zSIXy(f$R>*8m9+$mx?Xj)Y;RM+mt^Zf?W_S8HnXw=xXa;3i0g_FDR5IcDC#p92*-R z-8i#r*YG4IJ(LXOx3%PpEG`ggLA)Ic3GGMvplG$LxXNn1O9*G<{lI`Vd2X z#g6;}$cG@W&6P^I?TD& zfj*2B0FaS{MKIS|B0;+IMBo+_qpqPl85j%Waj^stvNTNkU&afpCyL62Ej{=L91=_vMMY@cgImCTj==8PnthPZD3 z;OM~4@v&+29;^aC!@g=*zOkcwBclqId9`iZioI)FyL-=FLvxzx+#NSe57S!OR@08^ zxV59u(@QaPsNmsrD?_9T@16z|AKlY3pvuiJ;x^W16Ai4lKSdr3JBqq^(a@>!2a9bX zi>=tv-L=Vict0_`tWmjzZ(jD5ws#h`bf9@$o-KVvrhPv=y(cXqe-b>x{X zr)MfCT!ug2Kn_hEh_PI2D~Dt~?fHB!-aDLUOZqT`^JS#w??$VxYXs58UH#;9A`5|y zB07NH5{vDRxROv?=qcgF;CYlVtHCqaHBap_XR+MP*qgTr9T|>96f+7LOY3k_l0^xK z+oTn`TgdK<*uzk1!SFz;kod5bZm0P3fw-OjzYzQ{a0u|QstuvnOS?Jd zc=$(_C~asDd;O+_MPxT6Qk!U3g)xfpTh&_VDHbFa)CzdDAIWQ`h0?9<3r zyKy6H?kU7hijZ1CNvLre~jC&K>1hhFJ<8mx5)}yKpsYtZq zU5E~JeJxbN;%50Hq}uy2YAZ;;cR&15&%dTkgo$E80V_)r=R(L2s>3Fv}~ut`5%GMvYnN#940pqZ~ABn z$m@7WI}IEdAlWzIKg-Ru__T-NRx3lH-gcbdQPZFEumaxbK0LUOnNPvd4XBnu?65#T z0Mr5w4U2^$M${armwLO{w$THX?VX*4Zsv9fPO5Hai3|)lO%+$Z7rEJ#rN>3o;xsN- zD&Q<@fPE#Mb2*XhpiLo@*?owOI@NN>#|T&%eg?DW7w|sy!0vuO5~DqQKkNH@kaeTq zr0Wqab>1WeU2JJ-@9y5r#$^R|J^=L6jv_}Og_bC`>GmgG}))IgxQ)`7BS{2)#Bgp zQBLJOT^s3?H>WtIpTW*U(Q2!HfIAqJSrd^oh+SV*OV0FrioD;*)2THqy%NhI$sOW< zo?9;**xHTK!D&rzcUw;}kB*N@P2VAdGw!H|>tGfb<#U~ko;RF;=uzL8@h4!c;4ZWl z{N|$|Bi>Hby>0a1etNK@$oQv;gv}zex*}>l3J2#G;&(cts@Os&lEt8E1;Z0QmO>N= z%YxphL6?Wdthdz3`o$)^8g+p!ICZhxuVcN`y*@*}7A3TRRRJfXL2cl<+%(Y3LnB6> zjYY*ys2 zwb4}C&f&@3!?g5fu{7KntnDY73hGz~dU{aTdNxz3jziQRDqv`2O$}w>p9E(uMg`Ra zei~Bhlt~oA(bQ^tS~seenkCX9Va)~>xp@_46n7)~MYe$$t!$bcoY<4Uo)zvO%5|P9 z*VaO=qkB`240fc#^zl%0IE$?T{fk)N+r2s8#Yo>kg+)2K28KNBI-4q84iqW^pfob40!pUPN{CoNo}En_aegu><%%|L`RCb zfh`!D(;9YrRXyD;oAbRAS1=A4`GY0NST~Lg^F7F@R*F+*(|8D3R=4*Tx-bf5!@&RL z?LC*Xs5oy~DPKC`!MpUqdbmme!vg_?*kE~3wnr>Rr*Q1C0EY~Y=>^z*6SiKC#!`raCiMkO-{g_$w zn|tbrQ7Lc@D%Z==jQF`{w+1 zmQpqTAxJUhD>2W}MfSkX=^G}72d3$`68$5^!tsjkJn0Xd6KH>MNXo3F1wy=|`UFjj z6kbOEj zMIM^(LHDyscD5tCdaGUN57@W1kQ`eXgf*I&z&f-?J>7B=WcaYJ2Om46-rf>O3xnTGq7$s>PmNUpd-IE-(k&jwG}!r zydm#aWLph;*&#Ah&O_IzS!hfVkv1%iLc#*FTN8l2l?4#~l^y!s7DC``w z!9@m~0$^;7PyXa(9LdWW_0r|@Bo?#5tP?9ip;5|BE^J_&49Bw0u4bz)0#*X-R<ZMH!g4)otb9{1miZ$-{2)+dzm4*f%?8C|cpRX!U z=lIabt{c#*`F3|mi$EQW)XL(t)*R@8mug~ARqb#Lnxfa_k~(m=AVOQRju89m_?^!S*xWh z&ljZ|S4|ZIem#n@QHn7rLz#A(5k0(2K-h(Zp|8kywFmRK3`#l%qfE^0q6$kpcLhwU z$JDJK@@$6a&5DkeLMx|gc_O(;E=O=$0F(FD`IDTObI@wK5&HQl%ox;yGsjeDS^TzN zT;DUGrvw!#dW9pI`D$=s&Q7Fyz5<0)qXuD!pP+dxZNg!NwBj59{gr?)OJ@ak%!5OeQn_3~zn7uWsVYjV!^7yEYif}V&R%%LARzXP+}_E zH+7U+5=_t0P`0EM?8;f3%b|P$c(5(-Yo1IuErXF;g=F1TD04eQ4UcH*+*` zJnH0Pgc52TzLYjI9E2KO%ra|o4T)(FiBzyD3@C8oGx*0*WwKM{r2VfLDX5?RWs9Ih zFeT_$@Ai$QzMgjem5I#`so%b@SWM_<*|f9EpaIhBU?xqCdsG<|a~*k{QTc^}D{e!h z7zlC4d{elbQ)l7UVtB18v48hNR3C5Mp*|k}9C&0g3o<^55Av~;BWMycwrRcU#w)i`Xqg7UrwMBwiy@+veDqh z4fey!Qo3P=7^~0%)IpvJ1yzAf83*LmdNj_=*-#*JwiN8-*|IHn4a&@=lV*S(L+;12 z_I7TO@L7IHl9AF_PT zLVFLY5hegalfSG$AH}gvJRvg^;-*dWD|8FP zF)ckPNqr8_a;n2{$+T8M1#E@ZphDrCfRXurz}1jZW-$D&&2PbrxOK*_Br;(N?Sx&0 zBO8kLn1ltvVyRcN8mc9vm9(iQw-G%(qdYO1a|pf4Nq=0~#X37F=Ib zHZaS#1+{16;MB-Y8I;Z-%WNl`QrsUA#7%3z43Ah%vZj{M@@87jV$0`npfA{_p}-w?da0U!-$B!S9^(3CsZR zm)XqP$-#$T#O)gkIL$87f>j(;q1$Ga)MvbOAf4POqhG7vC;nX!VA=+wFu$K=oN|;> zhsMa}dN1}>$?3FA5z(JjQzJK`k0GmjAg!cSPR-xpV+*{r`8NDrVs4Y@>tfWHF%iA^ z79Wjs$nwTF;xF5|-fg{sRcfM;I?-36=CK}f)W^#n98MLwSQBXZ2?#%wdpt>EyVCNQkB zoh`WKs-#Y#PotSd{|w5{*l!9M1`WKiGlyFYT1+#+z16s>f&W?ftMOm1jpWn}AnlhE zrUQ)gfoYofR=9ov2CSF?+!u_h=tFBPhI@a4`DWy&yI-rFWL`rsfR|j%m0GJ+Z)vkzbx>ic z=SsOwVyLgaU7vEW@nNZ64-ncZHDgYPZb9zz3-(OeTB!_D0sAF0nm3K(?2Ax6?Ys!Z z*82T$@{sIEg6$Czqrns)2lg+WkHJ2Ao0){)!P!@}ZtsDk|z z%X1t#s9PyaTS`iwLR@Ce*)@0UCC38JHVR|A#)Hb!i@9tTC{Oz4h0pnt8Zqf(0mqp) zPi*|YgY92I#_pFuS~*bcR5QE(2vcyWfz^z$0$MY8WSovQUNL#i9TsPnpXs@B_w z)FpzuPN!3s@D4~QZJT$U(hM| z1*!97-%oX_)~kTMYh_M(FFi-a^X6k+ z=^-2;Ta0xz9<@MBd&{t{@en8|-4n5{^HyP9@125mgLfL%^E^JFJl|V`b)&?_0tsnUd8mDktz8CF%BgaWe8KXl9^E_1uiPrd!8(f-q9|5BC?^E`euK= z<*xj5TZ?o6;t~ zCS?{!oUwj=VQgeN;*v(Ms`0tGxj9^$@+wCs@PLh}P_#-piK$v|Yya%C2X9^N-L+}; zbnU~H8@$_oM%J^_tLl|^w$9F*TX5%N^Y8pBcUSd`pSI35&Q{&kU9rXfmks@^5B+Nl z{c8&STN?VeJoK+Q^lw$@-x;BQYeN6lh5lV&{X6)%i+m2}J~nXm;R=MT>I15zMc#ma zRUX%D+pD}TtS^xiA9H1?R7r(l4_4(}k2U+0D(~f3v#hGTH(<^FqsqG<>kB0HA*|Ui zRC%Amntg4R$JZa6C#mmX&1S7i-tfn^v&#Do*6bmwq*AL$%AoqP5jY0xN*#r(k*@a6 z!Wz99)^(_8tn7VQH+Va-o+nj%zIQ9qjd=M5EBo89Ug$lD^&);D1@X!XyV(0W)=Rt} zVttJFf3RNa{Q>Layg96w#bQ*yw?U+f{20Xy>ekS`7|s}NLX5I@Fh*-8c%gxJE|@rF z9a3@1l&Z`|8)|YHc8Xu5GWX2>BZJmM#XYru>)gy4cg-xH{kwxdZ=8K@Zf5BNb2Cl& zHR4x~Usj-34_tB8;ni>)Zu-TqNnE`V_B45&%nEL2yIY4fp0~le5>8_W$>OYwIf7w9 zGL$a#9dUG(^;kF}i{m&ho;NXdBc5Ly9oZ>QEiHnGy*5QzhO{#>Ls%4{!KG>AQv2!SbFT?wAK70??`<}n*@KVd~ zt8j29Y-{qiA?5Nr2P`$-YOLdaKNEX#ut*#KbbhDP=yy(_#+=4Nq5ngL;&MIr(e<|X zj=?^9oP}3!7oG`xdO^9BDGUHJ7#`HmO|Pnufld9>l@FJpl}5A0s;&HmC;gDB(9J@7 zq$4>_aIDby`9AVaidE9w%=GvsO!()=26v1OZyJvFDobEHoy}W=>L!K`7`!o^1}W2- zQgzlSm);k9DN!Bp!QtmTbizf67<92uKEY~6d6PGRwJKOVCx=v-RK9XZxHn30iN;d8 z#3z_}{sb3;AiGT#SZ$mity27$iWN;`P&79|{(Ot(Sl{v^7EMpAXlS_<4GoK1PJ5K) zOu0*jlIm!%{2C<68%!y07;DS1hYKaK zx^|`ULWTEzL8;jvdvFl-0zJfqacR}HG%v)9HrWe?63tPRm~s~|B{53t0!lxJ+!U-$ zX=9{dZA#X7XL+n(OT&Ysy(9Y^#Tp&y7^I;?QxqMh+;k{$G#`HJL3xw+EY_~pLydHz z)a;(f8tFVAYLPKclo{<&%$SO`9v1|~q0YwQ5f-)CE)HvqlWcQ5z9OTWsLixQ+02x? zG$=`IJ+3jV>b(WPnIN-Uk6a|kOnqDdwAFeniv^j!#1n5i3@P?cwLDpy7#_Tq54#8L zM#Innz4yqC1`StEV9MQSP!g+QLxy~XcY;OUu3=H~c9B|*Mk4v-5{-~I^^1lmGEBKk zl#&>kBw`gHmY`^W&{X)Ns30 ztX3n%@OY5iH@>Hj5V?{>fjZIiwvi%SF|`OhcAQ1N?cb8 z&*+*#2Bl}3KbTgFM;bb%?wRR$oSBZ6an^u1D~#>L+pR{2r-#W^h8vLZ+#FZ1WxwG{ z8x>ck6jx(H8SLRgiIeMwfa_H+fa_UCQ3}_1>G^dEmet!-*>IYX70z{|OlhHF%9NWa zC7S6{lxm}tD$7@XDBWJe7#Bw@#w1c9Gx(LUS%{PALM$u!3mC^|AqrEuu^TX&)Q`rE z?T$>|&)1C!XY4BW^p6d3#Xf=of|(_0h!`N;A0Awi zj&cuE%00$()v8J`dxTL~6V7bKZCpJU^-mb)}1D6~Z3wU+QVm#hWA9*qkuARX2 zumYN(rX7k4Q|<~(NsLP|;Bv=*50`j6AAt+)P+XXDbD<>0r8VI4=LuY*6B>58SY2Lx zmHeN*~*mL^OT6^XLGzF zj;owY(ezm}^l19b4D(foo4mgkRy^m-NRDN44YNY7JjMIB(|{wE&B+?Sx@Y43o4&m& zH#8J!`bTwbntJmQCPZxxhR%0>68SU-OzWb^|s z$*(;MKg8QTmmeZ6KKvm3%+-jHdl)7>gVbTd>o(j)|H$(g6XG(?LhxFInT1fUHL*|5 z%3(|)_9bM(gCKukm-W6VF5>kxb$QaDg@s4%6fhOwiJ#$cf&+$fm~Ry<=rT!Aa63e@ENqfn&@=IR7}T`qGd z6|rdGXpdOVu$=1?POcSh!X#%CPH3=bnqtb7DKz&O$G=|D=>1q2sluaUDs+5DXNyjO zj0>ax#Xc7=K3k*p+@_$(L(ykS6|}LL zWx$0Js|`%5{!6Xu|4VU?-3-zJ6;i?D&7fWVFZ7+1T;TCm{=cF6v%zHb4;oD4Gm=w2 zV=6sl{L|}3?>X^FJY=F5=ZyO!Arl`K>yS|w9}CmNM^o+D_?fUl-=L0lb{K5_5`u z%yjE$^aR0-Bzb~R%M*m+;3V$&G|u2@g4`@HGCk^#%V?V-$&|YZq{L0qZz{6hk_3`z z?Yu=YJ{Z_Ej4LyPqkkHjv`*1v%1x6JH%-&!qbyhcscGVN>=C?(?N39K)+w4yxoJ}3 zrfHfs&|H&1GkRNRLdeE%>+GGx4FrGEBBhCnD^qT+l(@P2EmqdMIDu<)!a9L#e8O6| z;=<0Krc7y`;>nboCndV?;@zo79KZ9fYBd&hjo+ihPt(}Q_&rYCJOlbaI)En^ z0G?h*>cLHI<^aAg;)w77KI#a&2e$_B$&UDca|BP)%41BiXQ#Wu-Iq0jzeao%@4lkm zvFnF5f=~92dqj&~Dm0=^AHvf(#f2$%?V#j{LwJIk&S) zV-JcdQ>NICIEKF-VDje)7>me^;iGpTBn-&nSMyCR|DPVjlZfKalqzatG=qi4;sHuZ1i3$PKgIiAu?n&{$B;( zTPJ=iV?$OGH2?F%cv4XwV9FgflyIEDr#XUqDosa$ll*sB{#XRA74mRQdUXn0}deo#6<|Jr@qQewJGwgo<aLpN zet08#Uo&k`<}&5>J|*!u@=paTyu%4ZqGw5_SQ$qz2~Gv$XG!4DGdx3J(l?GFk5{78(1zHri&|1A~hKGVwN(U*{Pgo8mi{ zBWySbV8QTh1~n5C8ffN2SX+3(fmgZ=OB$zGGNo7=L&R?6Mv0rHAA4EvdxBQ6XS0kJ znaP}I?-vIw<3*;8k5_(k6_+RKylG4Ud8v+<{$!K@NyWsj?lHrX#wnIexmi-;X6ZL@ zS?^~rfaN7e!7^UQl3C6(EaAa&izIDRB$;xPq=Y0_g<9}+!G)OLSOo1RBpR%C&D$6d zj0fw+@$qZ-4NhJgKiM(Cx&epROc2)zoGCIIqS!Fyu6~plHtqqQe{~P9FW}e(a5mr! z!b+Kjt-=$2;prv2ug(X|;vZ*p~Sc++&WozB*^=l#Vz3r57D`6yWVaJ z+!CL=Hg3TSpeApKv`^;RJpEFEn-W^hS&KUcXqzI*lslp+F(iXAiFKph@c^iDFT=xH z!I&gEu(u=H>J;MxdqdDUu#aA0v?7{@C^k&FBbt&po8F*)o|eGo!blV+uvruvakgzs zFQc|?rbbe=vY#op{gfE{-8FKJ;nL{6*yj?ikV*kneVF)oKs9%v_%3a2k7!uX$sj4R) zF5BSU_QV#;`UVshKB*-Yj@7O*_Rt@v47gAlJfZ7&`mtkt=d}?I#$IYv_A;gHHTg>B zSW%)+cG>MYXZ?!)<*Fv{YGJ{Zn)NG}tM=x3(P(g<1{|@R_3QM5({Z^zvJcPms&9LGF|wNdyr6u^xsT0u{%YtD1IK$3cTezKZ4y>g z$-|^KAk`#Kiqo>?)+jBo&RamqNnmrY(4Nj9yZsY=OR@25j}Jj&VF~@&8;Rs!zowY#DxDAP7V$j!F-~*!hYzUMW}+3saknJn}Jd1Z3djFTJLhC z=(;-ZYMtVlGV6Q%X%~MyU+*2nA#5F3huNl9dd*l@;feL|pl~Jja%sk|==Luw z;jZEgmZKOC@`RK%pEsIRPVm+oQ#Wa=asyMUtuuCEhb)wsw%OhP+Ot=36v>CDJfjmE zcK=%n$j7G(NWL@qj)kLOAG!F<%zDSUQ(8S(ip$h^eqn0dKec-;NGPu`rMzMcrpvid zV!RR$2Y(K~-g}4T5r#vB6nOj|g_V-63WuJ+Bk>UlJ>ncEnojun`y@=C7AyKpxr2fd zLqB{T;6Ean_1+7RstMuqfM`o(p9iGhg$?SMbBR}m=;WPrUu+cE5VHHy=R0zGWP+dO zDV|Izp2n0iT^f|QdHT=cX1$NU0G{c0U@M;SGx+CG#D*n}Q!JTsv!ukZbXRdRZGX7Y z`?STD?lM<3qV1chG3zoN<$B(`rHeO6)gi8phn)^9RUE@8@DzbP>; zQ6thuJtF<8#XmkGy*Sd!n~`H=M0!l@q^WN#WlTz)%3`LJ#U^JRsU9W9;^0J}!<-vc zc>in}ZlASY6frsBL|{qGUKw!wT>{4q zk>X0=7{8?-9P`&t;GNQr0UAo{XhssIAZeQ-$&{NUCHfrcB9!Ivb2H7nsdst&zTRv6 zGo|HTB`uM&A9bcwA#XdY^3K5CYA-rvxJF|s?f2W5Onk~PI8$2dU@yG{6c^tSVi)I3+n z`^aT3(em@rpOJ14{2U*gXg|A~^P_b0@nFrd83*kPhRcaK zx?&U)X6y)9;HD#x7bQh|YGh?N(@e#gDaF~CgqB1WN(^V!DPN#FPD_=4dZV_wrXJT*Ltck|*3b|gN{_0srj-AwhTP0D7gP#p@&({Xb; zU!REU_c@I@`_KY(*(tXDK`&F;ynDh(+cnL z1Rl|r)8=7awT-u&!oxXl?2JDXX|zL;VaiR0k~o<&OtVqpeK~U zM~X9AqbM=urbG!T@rB_*fSjkg4cItoR~Y z{q7;&m}UxyhA1{nx!F)+*n}HBtFL|vAi`L4>_#topMc%yS@#si?-OuT8uOeSZzjZ@ zNitQtYZ%|%31;eRG0%YsT>FMXTBay6r6?LJOh-+Lp&0MN{LZ@G`?W=rg=4PAL}x)w z$I%STo}ht<&w|Rwo{zrVIH$wzizof{6S_dzi*dARCY^%UOxgV#O;>(kO8LQMXuZw8~miak^Af}|vwz2D>2d&?8pN9(PLlx7tF zND$ERdW)-p(JA5-@@AfgA9Bj#X2Y3Xx<`lLsJF%2 z4&)cy0+)vO4^Kw#Y)WBnVwr|0HcYu=nG(Y$+yeW3K0Xp*F|u3WC?nJMaoB0y2^{ZJ zaIG|cdwL2ZGqj#Y#+AExJ<4#TX^JCLilZ^ZG{KY@j`8~H4+rYK7K`W6*4NY~xPKBS zdq>|0{a-Y}G+p_DDR<;jqAz^#6C+7aLYct?r-X{)5w_vx{;*Xn0{u3VXw!TqWW=6| z-(J5aXW~tB{03>BKeDOfM~$j^H5{jy+{enwK?ZN$2n|F7#o;JNKCRclK*_6Zx^-_y{e})H%5%*EVoaBVPz$1a=Qk{>rUP z>FXGD-pTlM0IwRYo|{>P3rNn(M`jGeuLoQaab%_bBmt*Ev-lW9_!b=A=0!(RdTp8` z-O~+6<4E=m;z+2dI?yvbHs!mJ{to%}IAD1`!b=$QaVMVfIX%UTBIXj&LbRy9P`yix zgNJ4uwim_HFcB>m29v8?R%1Vv#ma^E_MJf?Ok4zQL8*mbT}F4Sa$}0qcPzAU1Lu#u zvfeH!o%j$lt$`c$%f*W~aL)6Y=o|^-*>usoJfVxhG;K6WabU{bv{9m~^g0ksxt3{0 zT2~!j?oA0@yH=k9^_6lhvkKqa3J2pF$cUxi_xYqV@zDutb?6P6K z`>r~ChIdQEzv@~>wS4k}S2V)@y@)2`cL9E5fq&!oqoA_4O^!#OgL>f}X6%WFq1b8y z=-Zgn*#wx@($xes;~-YbgeHI$-Q5JRs=EqIYB^-iCV(M%q$YrcpbC^JHUTWnc>iyW zSPx0Lsb;|L|D%`bRzf|OX8gwe5_7zmN;Lxsg$8d)NCwq{?Y7<7v4Erl#QsR*KvNYv zrriBKB^>vVcev^EN2^)+S{-50v+J~HVys8`URwYXt@@=WvG2|U8IzdHor?3E>bgU!<$+@WKp(<>(R+@ zGfrl`zAm5~pA6UEHqE&&Ih!l&ti_?1kkSd!M`mf8BFU7yY$-7$!?(D7(qb0BnjU?h z6x%i~JPETNx`@9|O7lD7MRlrI#xtdiH%dekR+Jdy!zE;mH@;x;uuCY)Afbd38L*{M z?>&ul!=W;o0K|+tSVnqkz{DYqQ!JTs7ZD|fWpEN~#u$eyyl+_y?UUeW46;gcVW(rw z<|M`-8Mcj#Mo+4uLn}fIADW{0Fs1kywPyOBk~kmJr-RRr6Zk|+%w$YHlR=$IEiv`+ z)kuk%$?tlMi?aCo)AZ!&`7h1Aul z1GiQj`9dL4rj3*q#6&0CNJn(iT1A~HMcuUB97S=V#83~{L965Yqea`UgVBz`u7lRJ zaw2Vx>fNVh?D;ssY(}^YT6PWW|Dw;T|9`~237izg-T&Xi?8UOca;PY%sHkW>5R`Z% z%Ixm!?#Ld)%q$CD!vYJeEW7Kn3!*XNeGu<>>tkXbqDEshG0~U{MU5s#b7_*t9OjNO z$CJY(CMNtopKn!lS5I{hkY9fPfA4F0da6G4t?#?8uCDHxrFROGN70>-G0~X*`LD(s z$46=)D?PuLc0?O{*3`V!#!r*QWG;~DK@F==hGRCE`ZhjsdLsME`HjOpVl&P=XA7Q7{Xv^ux24kEjoK>C~bFkXR?Nd$aeQ{%s}XdV&PGAKVpo_V$DES#jupt zl+9ud46!w}`@;e~Q8+w`#$k-XDLeaEZ(-4ObKA4rHMceUa376D_xXP_^Pr~+n@0+} zbmqYrgB|X3*34tGg>3h^Qe?Z&Su>AF~7CC=!7ESQFJe4 zj7wt8HtvfdDXk})#2Qp$>S_0f6#AiHcoYr87{XMPn`t~|0oi@4^bv8p;f(~-UH7Tw zrtZ#MlRKX`&+_mJ1>fpOjo<;g<)b6Lacf%iO9ApIy4^7*8qnNH!s5$Z{|5KrJLlf@ z+I7}kO4_%nZ91x`c@#~}7*ZdPk=d+Y=78I&8wZCr6$Tsn z21-`X%zB_+f-d)?WNZMYU*lE`Y#DTVtI&BAjm{W-1D5o0&s3NJoX=EDB){D8GrzRW zvCI66h|-^Ev!AKhM2iCFDR?g}XG!fg&z& zZiGKr$NoBRA1NX3!p)?#Y)tQ)38mFc+_K5` z;9Fk2aQlDMQs}T^VazVH6mte(OF5K95Zh8pSA^`Aa(>WK+!Z0eH2!ZJ3&#*P z7JuEA4TH-N>~`o&uuln_3V)1Ae&~i0b0ZlNtD%rq6(Wz+*Vnd;)}LL!2I=veM0J-O zqJEy~l4p4PYhDoXD+*NTzLBBTPmEdMZGLn7mUPWkRr1?R74x>?J8yMTSBD^VmHeCS zmhYE6cqIWopKDVO>~l{0HCo_jMhEBYmqj<@*NKo_M0%Qq2tDi;AmyR`|dC*^VR? zBWwEBvy3@{9fG>381Cy^Y33&E#L1zd4W=v7VO7FBLRV~>Rk341#g+vXxWjRZ(6H@} z@k*b2;p!GQ#xC|f<#R73p5hUZT<7$dM1-ewE7bm*{QPY+<-2E=tCJZ-BUT3G3znvTi5lxsW+yJp%p zV|0VL#&WH6slayajKDQ46_nHiU5oR}JiN^!c76tnxhrRR6n2(9iW_6Jvv*j|o?3GC z7~|}$NN3HDq5fM=(+lM^kD{GsjIR9qET_wruvPhP30psz7+dqqNcqL1uwSO;86$qx zd5>9sl^ZI~3ToaRDwJQ%eFJ^#*Eo)qEHLo z5yxu0Us;Zo&JOGWpcu4ScXqJ2s~um1D|2Q;TT54N2g>&RjZJ@I6Nt_ahLfkcX<@;E@QO2W4Hu}i49-n>e_PGt!p)-?ZrQ& zQ8 zw2zDtAMtG|%f|&}&Qd)=BgJw^iI4vO33r_2oP;@;ISHS{Q+$t)VN))%LAYB)Od-{>EYo)w_6c_)}0?nWuD4K9)(>r{faT##rZU% zT`br4Ef?Ls-`z7j5LNTBPBK^JB#)w8(bcnfsVY7s6RVF_zu^){j~c-YO@CzVClklYCtS+QX3hcZ zx7?E6Om9qrwA3v;PhE4tpXI99*J8lRN5f>a%%HanXX!!Rh$z}}EnIizS@C8Szok+Qud6Ys^o zLVlPT2Y$Jn$Pd`Y3MoCO?i&~2-*q!sHm-1}4W%Im>rDXORmg>*5W6KXcU3+)t!a>V zQ$8dRjbA?WAV{@L)MjUw4_ja|u^fBl15>f)?e@$cu}&r`P_gy$rE+}q*{|UTY~zHT zUQsuFGZr)$EZY<20PiZ77o3nEI3a&@LaJcdY|74FPROB7$jMGfn-j9k30d!iTbSm{`lTw#Vj9_m__i*Zqy*C+CU*FWp_7Vzu#WMaHD6YhNn1Xf`#b+cA zeN5gB1?x*RJ_T(BsXnJusW+Q~>u_O;y`1{uOe8!?XpL20%rB1gUz&6uA*JV3fB16G zyBY6cQpPCKFG`%}-74=ksc1r^L8|RKm3p&Dc|SE78V~nzNO|KWOsX{&>As?2?Yk}W zKu*N4?JK18oVs;ac;1Kb9wwz7Mf#k?dEUM9Zb;cOMdOpwR*>o|I+c2}NqKK8ndrsd zw9I{-mdTk~Tzxfaiv5LxUa@@lL$mxi-oq5MqbR;6ah|98nW13I6pc?oTS2OC>Qw5@ zrkIJKFvb2(eH|bgdnC~stG*5t4Rhr@PHhSO-m6Iu6jFLl-A_UKq$un$lXev8D-!2< zpH~`d%oI(CG)VP7I+c2}Ne@C$GBJq#7_B+bA)O@}n^bEo(t}0AUhlTd>ow`YLQ2o6 z`|MSo_blGSbxJ#m^am2>d0&=yQ>T^qBpRQTwt`eY)~VE+O?n7|l8FKA4e7y7%j8@- zu4O)7wt`e|h}!IIirEMZQyl8l z*I}Zu>q~2_`Z`=RY$0yT{IMoITuA9Tb(t-m_an+f=Q!F?q`#3k&r>yElZwVCrL7>< zA9O19W|O`PLCM5Nu{ZT~xI=n`Xlzogu}C=wimTI!x>Fu0r1YHi(D?z+Q#5v+(vBki zGmg0ZPWCpbXna!I3R1l-YO}LRk3wKF!Rs?adZa^ov}kNnt+7bwh=#ekb$Ws(og<|5 zoVo+A@jT_1O-eh8^c@^=`-kjpQqhD+gH(xx$o0-9JqBUn(PoZAI#)FH*c&riW0B4i zP4s!NN0ZJIQhH9^UqQ;NmvHN)9Yw0*aE-4tdR*mbBO0HSwt`eO#zlm}vbAn=EIx<( z={!YhQ5+|l==!=`QyeE0^oqJiuf@NBQXX3CHngKC#%X`1D2;V?5RFekTS2ONoeF{2 zY>N5#9HuzVsjqj7#;z}|u}F^>4ST-ZG9S{U$9pqz9Y@cpyW%>W^%aFhN;`^F5qjQC zrLjmwkZPK!5hR;UdICa{iMz2keeigP^hD9vq*`NpkyXioznL9Ys1_`+TI*SfrxyNogxcrOE|Cve~5XK}a&O4tqm-l0*7l(b%L~W09UL znrPC0Y0{HDlG1bP7TtilP!tv^?I_ZNB+m0rR2qv^G$GO;)oh�X|$r{HrkaSrx| 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�Xyyx+bAA$|Ocy^5#ZLsBgRXh}Js4_L*a< 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") +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 0000000000000000000000000000000000000000..55869a5b17eb1ffc9285a71242bfb894a1e757ab GIT binary patch literal 39424 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 HqR{^bl)