From 553c9482f253cbbb88c25bd3e0c7f15a3c9ffd9d Mon Sep 17 00:00:00 2001 From: IRBorisov <8611739+IRBorisov@users.noreply.github.com> Date: Fri, 7 Jun 2024 20:45:14 +0300 Subject: [PATCH] Initial commit --- .clang-tidy | 23 + .gitignore | 13 + OfficeOLE.sln | 31 + OfficeOLE.vcxproj | 244 +++ OfficeOLE.vcxproj.filters | 172 ++ header/stdafx.h | 15 + header/stdafx.h.hpp | 15 + include/office/ExcelWrapper.h | 44 + include/office/MSCollection.hpp | 41 + include/office/Office.h | 36 + include/office/VariantableDispatch.hpp | 28 + include/office/excel/EXLApplication.h | 468 +++++ include/office/excel/EXLRange.h | 253 +++ include/office/excel/EXLRanges.h | 28 + include/office/excel/EXLWorkbook.h | 295 +++ include/office/excel/EXLWorkbooks.h | 60 + include/office/excel/EXLWorksheet.h | 164 ++ include/office/excel/EXLWorksheets.h | 46 + include/office/word/WApplication.h | 262 +++ include/office/word/WBookmark.h | 34 + include/office/word/WBookmarks.h | 34 + include/office/word/WCell.h | 70 + include/office/word/WColumn.h | 42 + include/office/word/WColumns.h | 46 + include/office/word/WComment.h | 40 + include/office/word/WComments.h | 31 + include/office/word/WDocument.h | 457 +++++ include/office/word/WDocuments.h | 41 + include/office/word/WRange.h | 238 +++ include/office/word/WRow.h | 53 + include/office/word/WRows.h | 77 + include/office/word/WTable.h | 101 + include/office/word/WTables.h | 32 + src/ExcelWrapper.cpp | 95 + src/Office.cpp | 12 + src/excel/EXLApplication.cpp | 2567 ++++++++++++++++++++++++ src/excel/EXLRange.cpp | 1115 ++++++++++ src/excel/EXLRanges.cpp | 58 + src/excel/EXLWorkbook.cpp | 1209 +++++++++++ src/excel/EXLWorkbooks.cpp | 120 ++ src/excel/EXLWorksheet.cpp | 707 +++++++ src/excel/EXLWorksheets.cpp | 129 ++ src/stdafx.cpp | 6 + src/word/WApplication.cpp | 1167 +++++++++++ src/word/WBookmark.cpp | 86 + src/word/WBookmarks.cpp | 77 + src/word/WCell.cpp | 239 +++ src/word/WColumn.cpp | 127 ++ src/word/WColumns.cpp | 125 ++ src/word/WComment.cpp | 120 ++ src/word/WComments.cpp | 62 + src/word/WDocument.cpp | 1957 ++++++++++++++++++ src/word/WDocuments.cpp | 113 ++ src/word/WRange.cpp | 1241 ++++++++++++ src/word/WRow.cpp | 182 ++ src/word/WRows.cpp | 272 +++ src/word/WTable.cpp | 392 ++++ src/word/WTables.cpp | 73 + test/Data/WrapperNewTest.xltx | Bin 0 -> 7912 bytes test/Data/WrapperOpenTest.xlsx | Bin 0 -> 7910 bytes 60 files changed, 15785 insertions(+) create mode 100644 .clang-tidy create mode 100644 .gitignore create mode 100644 OfficeOLE.sln create mode 100644 OfficeOLE.vcxproj create mode 100644 OfficeOLE.vcxproj.filters create mode 100644 header/stdafx.h create mode 100644 header/stdafx.h.hpp create mode 100644 include/office/ExcelWrapper.h create mode 100644 include/office/MSCollection.hpp create mode 100644 include/office/Office.h create mode 100644 include/office/VariantableDispatch.hpp create mode 100644 include/office/excel/EXLApplication.h create mode 100644 include/office/excel/EXLRange.h create mode 100644 include/office/excel/EXLRanges.h create mode 100644 include/office/excel/EXLWorkbook.h create mode 100644 include/office/excel/EXLWorkbooks.h create mode 100644 include/office/excel/EXLWorksheet.h create mode 100644 include/office/excel/EXLWorksheets.h create mode 100644 include/office/word/WApplication.h create mode 100644 include/office/word/WBookmark.h create mode 100644 include/office/word/WBookmarks.h create mode 100644 include/office/word/WCell.h create mode 100644 include/office/word/WColumn.h create mode 100644 include/office/word/WColumns.h create mode 100644 include/office/word/WComment.h create mode 100644 include/office/word/WComments.h create mode 100644 include/office/word/WDocument.h create mode 100644 include/office/word/WDocuments.h create mode 100644 include/office/word/WRange.h create mode 100644 include/office/word/WRow.h create mode 100644 include/office/word/WRows.h create mode 100644 include/office/word/WTable.h create mode 100644 include/office/word/WTables.h create mode 100644 src/ExcelWrapper.cpp create mode 100644 src/Office.cpp create mode 100644 src/excel/EXLApplication.cpp create mode 100644 src/excel/EXLRange.cpp create mode 100644 src/excel/EXLRanges.cpp create mode 100644 src/excel/EXLWorkbook.cpp create mode 100644 src/excel/EXLWorkbooks.cpp create mode 100644 src/excel/EXLWorksheet.cpp create mode 100644 src/excel/EXLWorksheets.cpp create mode 100644 src/stdafx.cpp create mode 100644 src/word/WApplication.cpp create mode 100644 src/word/WBookmark.cpp create mode 100644 src/word/WBookmarks.cpp create mode 100644 src/word/WCell.cpp create mode 100644 src/word/WColumn.cpp create mode 100644 src/word/WColumns.cpp create mode 100644 src/word/WComment.cpp create mode 100644 src/word/WComments.cpp create mode 100644 src/word/WDocument.cpp create mode 100644 src/word/WDocuments.cpp create mode 100644 src/word/WRange.cpp create mode 100644 src/word/WRow.cpp create mode 100644 src/word/WRows.cpp create mode 100644 src/word/WTable.cpp create mode 100644 src/word/WTables.cpp create mode 100644 test/Data/WrapperNewTest.xltx create mode 100644 test/Data/WrapperOpenTest.xlsx diff --git a/.clang-tidy b/.clang-tidy new file mode 100644 index 0000000..9088f9f --- /dev/null +++ b/.clang-tidy @@ -0,0 +1,23 @@ +Checks: "*,\ + -bugprone-branch-clone,\ + -modernize-use-trailing-return-type,\ + -hicpp-special-member-functions,\ + -llvm-header-guard,\ + -google-runtime-references,\ + -llvm-include-order,\ + -fuchsia-overloaded-operator,\ + -fuchsia-default-arguments,\ + -google-readability-todo,\ + -google-global-names-in-headers,\ + -readability-redundant-access-specifiers,\ + -readability-else-after-return,\ + -readability-implicit-bool-conversion,\ + -performance-inefficient-string-concatenation,\ + -performance-unnecessary-value-param,\ + -fuchsia-default-arguments-declarations,\ + -fuchsia-trailing-return,\ + -fuchsia-multiple-inheritance,\ + -fuchsia-default-arguments-calls,\ + -misc-non-private-member-variables-in-classes,\ + -cppcoreguidelines-special-member-functions,\ + -cppcoreguidelines-non-private-member-variables-in-classes" \ No newline at end of file diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..d2aa20f --- /dev/null +++ b/.gitignore @@ -0,0 +1,13 @@ +.vscode +.vs +*.vcxproj.user +*.aps +~* +*.pch.tmp +*.clang.pch + +packages +bin +build +output +import/lib \ No newline at end of file diff --git a/OfficeOLE.sln b/OfficeOLE.sln new file mode 100644 index 0000000..d981339 --- /dev/null +++ b/OfficeOLE.sln @@ -0,0 +1,31 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.29209.62 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "OfficeOLE", "OfficeOLE.vcxproj", "{7E5F3034-B8DB-4073-BF8F-78EA626D5624}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 + Release|x64 = Release|x64 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {7E5F3034-B8DB-4073-BF8F-78EA626D5624}.Debug|x64.ActiveCfg = Debug|x64 + {7E5F3034-B8DB-4073-BF8F-78EA626D5624}.Debug|x64.Build.0 = Debug|x64 + {7E5F3034-B8DB-4073-BF8F-78EA626D5624}.Debug|x86.ActiveCfg = Debug|Win32 + {7E5F3034-B8DB-4073-BF8F-78EA626D5624}.Debug|x86.Build.0 = Debug|Win32 + {7E5F3034-B8DB-4073-BF8F-78EA626D5624}.Release|x64.ActiveCfg = Release|x64 + {7E5F3034-B8DB-4073-BF8F-78EA626D5624}.Release|x64.Build.0 = Release|x64 + {7E5F3034-B8DB-4073-BF8F-78EA626D5624}.Release|x86.ActiveCfg = Release|Win32 + {7E5F3034-B8DB-4073-BF8F-78EA626D5624}.Release|x86.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {5EC5CF3E-91A4-4FEA-A294-BF585E26A41F} + EndGlobalSection +EndGlobal diff --git a/OfficeOLE.vcxproj b/OfficeOLE.vcxproj new file mode 100644 index 0000000..728c40f --- /dev/null +++ b/OfficeOLE.vcxproj @@ -0,0 +1,244 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Create + Create + Create + Create + + + + + + + + + + + + + + + + + + + 16.0 + {7E5F3034-B8DB-4073-BF8F-78EA626D5624} + Win32Proj + OfficeOLE + 10.0 + StaticLibrary + v143 + Unicode + Dynamic + + + + true + + + false + true + + + true + + + false + true + + + + + + + + + + + + true + output\lib\x86\ + build\x86\$(Configuration)\ + $(ProjectName)d + false + + + true + output\lib\x64\ + build\x64\$(Configuration)\ + $(ProjectName)d + false + + + false + output\lib\x86\ + build\x86\$(Configuration)\ + false + + + false + output\lib\x64\ + build\x64\$(Configuration)\ + false + + + + Use + Level4 + Disabled + true + _DEBUG;_LIB;%(PreprocessorDefinitions) + true + stdafx.h + stdcpplatest + include;header + true + false + $(IntDir)obj\ + $(OutDir)$(ProjectName)d.pdb + false + + + Windows + true + + + + + Use + Level4 + Disabled + true + _DEBUG;_LIB;%(PreprocessorDefinitions) + true + stdafx.h + stdcpplatest + include;header + true + false + false + $(IntDir)obj\ + $(OutDir)$(ProjectName)d.pdb + false + + + Windows + true + + + + + Use + Level4 + MaxSpeed + true + true + true + NDEBUG;_LIB;%(PreprocessorDefinitions) + true + stdafx.h + stdcpplatest + include;header + true + false + $(IntDir)obj\ + $(OutDir)$(ProjectName).pdb + false + + + Windows + true + true + true + + + + + Use + Level4 + MaxSpeed + true + true + true + NDEBUG;_LIB;%(PreprocessorDefinitions) + true + stdafx.h + stdcpplatest + include;header + true + false + false + $(IntDir)obj\ + $(OutDir)$(ProjectName).pdb + false + + + Windows + true + true + true + + + + + + \ No newline at end of file diff --git a/OfficeOLE.vcxproj.filters b/OfficeOLE.vcxproj.filters new file mode 100644 index 0000000..0207a85 --- /dev/null +++ b/OfficeOLE.vcxproj.filters @@ -0,0 +1,172 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;hm;inl;inc;ipp;xsd + + + {ec1278ed-8b59-4bec-8e13-d4e574926314} + + + + + + 00 API + + + 00 API + + + 00 API + + + 00 API + + + 02 excel + + + 02 excel + + + 02 excel + + + 02 excel + + + 02 excel + + + 02 excel + + + 02 excel + + + 01 word + + + 01 word + + + 01 word + + + 01 word + + + 01 word + + + 01 word + + + 01 word + + + 01 word + + + 01 word + + + 01 word + + + 01 word + + + 01 word + + + 01 word + + + 01 word + + + 01 word + + + + + + 00 API + + + 00 API + + + 02 excel + + + 02 excel + + + 02 excel + + + 02 excel + + + 02 excel + + + 02 excel + + + 02 excel + + + 01 word + + + 01 word + + + 01 word + + + 01 word + + + 01 word + + + 01 word + + + 01 word + + + 01 word + + + 01 word + + + 01 word + + + 01 word + + + 01 word + + + 01 word + + + 01 word + + + 01 word + + + \ No newline at end of file diff --git a/header/stdafx.h b/header/stdafx.h new file mode 100644 index 0000000..9f033b2 --- /dev/null +++ b/header/stdafx.h @@ -0,0 +1,15 @@ +#pragma once + +// MFC +#define _AFX_ALL_WARNINGS +#define WIN32_LEAN_AND_MEAN + +#define _WIN32_WINNT _WIN32_WINNT_WIN7 + +#include "afxwin.h" +#include "comutil.h" +#include "afxdisp.h" +#include "afxdlgs.h" + +#undef min +#undef max \ No newline at end of file diff --git a/header/stdafx.h.hpp b/header/stdafx.h.hpp new file mode 100644 index 0000000..9f033b2 --- /dev/null +++ b/header/stdafx.h.hpp @@ -0,0 +1,15 @@ +#pragma once + +// MFC +#define _AFX_ALL_WARNINGS +#define WIN32_LEAN_AND_MEAN + +#define _WIN32_WINNT _WIN32_WINNT_WIN7 + +#include "afxwin.h" +#include "comutil.h" +#include "afxdisp.h" +#include "afxdlgs.h" + +#undef min +#undef max \ No newline at end of file diff --git a/include/office/ExcelWrapper.h b/include/office/ExcelWrapper.h new file mode 100644 index 0000000..d9dc2c4 --- /dev/null +++ b/include/office/ExcelWrapper.h @@ -0,0 +1,44 @@ +#pragma once + +#include "office/Office.h" + +namespace MSO::Excel { + +//! Excel API wrapper +class ExcelWrapper { +public: + ExcelWrapper() = default; + ~ExcelWrapper(); + + ExcelWrapper(const ExcelWrapper&) = delete; + ExcelWrapper& operator=(const ExcelWrapper&) = delete; + +public: + void Clear(); + BOOL IsActive() noexcept { return xlApplication.m_lpDispatch != nullptr; } + EXLWorkbook GetDocument(); + + EXLWorkbook OpenDocument(CString docPath, + BOOL docVisible = TRUE, + BOOL docReadOnly = FALSE, + BOOL closeAfter = FALSE, + BOOL add2Recent = FALSE); + + EXLWorkbook NewDocument(CString docTemplate = {}, BOOL closeAfter = FALSE); + + void ReleaseDocument(); + void ReleaseDocumentAndQuit(); + + static CString PromptUserForPath(CString text); + +protected: + EXLWorkbook linkedWb{ nullptr }; + EXLApplication xlApplication{ nullptr }; + BOOL m_NeedClose{ TRUE }; + +protected: + BOOL InitApplication(BOOL isVisible = TRUE); + void CloseApplication(); +}; + +} // namespace MSO::Excel \ No newline at end of file diff --git a/include/office/MSCollection.hpp b/include/office/MSCollection.hpp new file mode 100644 index 0000000..6749537 --- /dev/null +++ b/include/office/MSCollection.hpp @@ -0,0 +1,41 @@ +#pragma once + +#include "comutil.h" + +namespace MSO { + +// CRTP for adding Collection access functions to wrapper classes +template +class MSCollection { +public: + using IndexType = long; + using IndexString = CString; + using size_type = long; + +// Note: Do not warn about static_cast downcast +#pragma warning( push ) +#pragma warning( disable : 26491 ) + + Item operator[](const IndexType& index) { + auto* collection = static_cast(this); + return collection->get_Item(_variant_t(index)); + } + + Item operator[](const IndexString& index) { + auto* collection = static_cast(this); + return collection->get_Item(_variant_t(index)); + } + +#pragma warning( pop ) + + size_type size() const { + auto* collection = static_cast(this); + return collection->GetCount(); + } + +private: + friend Collection; + MSCollection() = default; +}; + +} // namespace MSO \ No newline at end of file diff --git a/include/office/Office.h b/include/office/Office.h new file mode 100644 index 0000000..f67ee00 --- /dev/null +++ b/include/office/Office.h @@ -0,0 +1,36 @@ +#pragma once +#include "word/WApplication.h" +#include "word/WDocument.h" +#include "word/WRange.h" +#include "word/WDocuments.h" +#include "word/WBookmark.h" +#include "word/WBookmarks.h" +#include "word/WCell.h" +#include "word/WColumn.h" +#include "word/WColumns.h" +#include "word/WComment.h" +#include "word/WComments.h" +#include "word/WRow.h" +#include "word/WRows.h" +#include "word/WTable.h" +#include "word/WTables.h" + +#include "excel/EXLApplication.h" +#include "excel/EXLRange.h" +#include "excel/EXLRanges.h" +#include "excel/EXLWorkbook.h" +#include "excel/EXLWorkbooks.h" +#include "excel/EXLWorksheet.h" +#include "excel/EXLWorksheets.h" + +#define T2VT(T) _variant_t(T) + +namespace MSO { + using SizeT = int32_t; + + extern COleVariant ovTrue; + extern COleVariant ovFalse; + extern COleVariant ovOptional; + + static constexpr SizeT FIRST_INDEX{ 1 }; +} // namespace MSO \ No newline at end of file diff --git a/include/office/VariantableDispatch.hpp b/include/office/VariantableDispatch.hpp new file mode 100644 index 0000000..776115b --- /dev/null +++ b/include/office/VariantableDispatch.hpp @@ -0,0 +1,28 @@ +#pragma once + +namespace MSO { + +//! Variantable DispatchDriver +class VariantableDispatch : public COleDispatchDriver { +public: + VariantableDispatch() = default; + VariantableDispatch(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + VariantableDispatch(const VariantableDispatch& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +public: + explicit operator LPDISPATCH() { + return COleDispatchDriver::operator LPDISPATCH(); + } + explicit operator VARIANT() const noexcept { + if (this->m_lpDispatch == nullptr) { + return vtMissing; + } else { + return _variant_t(this->m_lpDispatch); + } + } + + bool operator!=(nullptr_t) const noexcept { return m_lpDispatch != nullptr; } + bool operator==(nullptr_t) const noexcept { return m_lpDispatch == nullptr; } +}; + +} // namespace MSO \ No newline at end of file diff --git a/include/office/excel/EXLApplication.h b/include/office/excel/EXLApplication.h new file mode 100644 index 0000000..5a031ce --- /dev/null +++ b/include/office/excel/EXLApplication.h @@ -0,0 +1,468 @@ +#pragma once +// EXLApplication wrapper class + +#include "office/VariantableDispatch.hpp" + +namespace MSO::Excel { + class EXLWorkbooks; + class EXLWorkbook; + +class EXLApplication : public VariantableDispatch { +public: + EXLApplication() = default; + EXLApplication(LPDISPATCH pDispatch) : VariantableDispatch(pDispatch) {} + EXLApplication(const EXLApplication& dispatchSrc) : VariantableDispatch(dispatchSrc) {} + +public: + EXLApplication get_Application(); + long get_Creator(); + LPDISPATCH get_Parent(); + LPDISPATCH get_ActiveCell(); + LPDISPATCH get_ActiveChart(); + LPDISPATCH get_ActiveDialog(); + LPDISPATCH get_ActiveMenuBar(); + CString get_ActivePrinter(); + void put_ActivePrinter(LPCTSTR newValue); + LPDISPATCH get_ActiveSheet(); + LPDISPATCH get_ActiveWindow(); + LPDISPATCH get_ActiveWorkbook(); + LPDISPATCH get_AddIns(); + LPDISPATCH get_Assistant(); + void Calculate(); + LPDISPATCH get_Cells(); + LPDISPATCH get_Charts(); + LPDISPATCH get_Columns(); + LPDISPATCH get_CommandBars(); + long get_DDEAppReturnCode(); + void DDEExecute(long Channel, LPCTSTR String); + long DDEInitiate(LPCTSTR App, LPCTSTR Topic); + void DDEPoke(long Channel, VARIANT Item, VARIANT Data); + VARIANT DDERequest(long Channel, LPCTSTR Item); + void DDETerminate(long Channel); + LPDISPATCH get_DialogSheets(); + VARIANT Evaluate(VARIANT Name); + VARIANT _Evaluate(VARIANT Name); + VARIANT ExecuteExcel4Macro(LPCTSTR String); + LPDISPATCH Intersect(LPDISPATCH Arg1, LPDISPATCH Arg2, VARIANT Arg3, VARIANT Arg4, VARIANT Arg5, VARIANT Arg6, VARIANT Arg7, VARIANT Arg8, VARIANT Arg9, VARIANT Arg10, VARIANT Arg11, VARIANT Arg12, VARIANT Arg13, VARIANT Arg14, VARIANT Arg15, VARIANT Arg16, VARIANT Arg17, VARIANT Arg18, VARIANT Arg19, VARIANT Arg20, VARIANT Arg21, VARIANT Arg22, VARIANT Arg23, VARIANT Arg24, VARIANT Arg25, VARIANT Arg26, VARIANT Arg27, VARIANT Arg28, VARIANT Arg29, VARIANT Arg30); + LPDISPATCH get_MenuBars(); + LPDISPATCH get_Modules(); + LPDISPATCH get_Names(); + LPDISPATCH get_Range(VARIANT Cell1, VARIANT Cell2); + LPDISPATCH get_Rows(); + VARIANT Run(VARIANT Macro, VARIANT Arg1, VARIANT Arg2, VARIANT Arg3, VARIANT Arg4, VARIANT Arg5, VARIANT Arg6, VARIANT Arg7, VARIANT Arg8, VARIANT Arg9, VARIANT Arg10, VARIANT Arg11, VARIANT Arg12, VARIANT Arg13, VARIANT Arg14, VARIANT Arg15, VARIANT Arg16, VARIANT Arg17, VARIANT Arg18, VARIANT Arg19, VARIANT Arg20, VARIANT Arg21, VARIANT Arg22, VARIANT Arg23, VARIANT Arg24, VARIANT Arg25, VARIANT Arg26, VARIANT Arg27, VARIANT Arg28, VARIANT Arg29, VARIANT Arg30); + VARIANT _Run2(VARIANT Macro, VARIANT Arg1, VARIANT Arg2, VARIANT Arg3, VARIANT Arg4, VARIANT Arg5, VARIANT Arg6, VARIANT Arg7, VARIANT Arg8, VARIANT Arg9, VARIANT Arg10, VARIANT Arg11, VARIANT Arg12, VARIANT Arg13, VARIANT Arg14, VARIANT Arg15, VARIANT Arg16, VARIANT Arg17, VARIANT Arg18, VARIANT Arg19, VARIANT Arg20, VARIANT Arg21, VARIANT Arg22, VARIANT Arg23, VARIANT Arg24, VARIANT Arg25, VARIANT Arg26, VARIANT Arg27, VARIANT Arg28, VARIANT Arg29, VARIANT Arg30); + LPDISPATCH get_Selection(); + void SendKeys(VARIANT Keys, VARIANT Wait); + LPDISPATCH get_Sheets(); + LPDISPATCH get_ShortcutMenus(long IndexType); + LPDISPATCH get_ThisWorkbook(); + LPDISPATCH get_Toolbars(); + LPDISPATCH Union(LPDISPATCH Arg1, LPDISPATCH Arg2, VARIANT Arg3, VARIANT Arg4, VARIANT Arg5, VARIANT Arg6, VARIANT Arg7, VARIANT Arg8, VARIANT Arg9, VARIANT Arg10, VARIANT Arg11, VARIANT Arg12, VARIANT Arg13, VARIANT Arg14, VARIANT Arg15, VARIANT Arg16, VARIANT Arg17, VARIANT Arg18, VARIANT Arg19, VARIANT Arg20, VARIANT Arg21, VARIANT Arg22, VARIANT Arg23, VARIANT Arg24, VARIANT Arg25, VARIANT Arg26, VARIANT Arg27, VARIANT Arg28, VARIANT Arg29, VARIANT Arg30); + LPDISPATCH get_Windows(); + EXLWorkbooks get_Workbooks(); + LPDISPATCH get_WorksheetFunction(); + LPDISPATCH get_Worksheets(); + LPDISPATCH get_Excel4IntlMacroSheets(); + LPDISPATCH get_Excel4MacroSheets(); + void ActivateMicrosoftApp(long IndexType); + void AddChartAutoFormat(VARIANT Chart, LPCTSTR Name, VARIANT Description); + void AddCustomList(VARIANT ListArray, VARIANT ByRow); + BOOL get_AlertBeforeOverwriting(); + void put_AlertBeforeOverwriting(BOOL newValue); + CString get_AltStartupPath(); + void put_AltStartupPath(LPCTSTR newValue); + BOOL get_AskToUpdateLinks(); + void put_AskToUpdateLinks(BOOL newValue); + BOOL get_EnableAnimations(); + void put_EnableAnimations(BOOL newValue); + LPDISPATCH get_AutoCorrect(); + long get_Build(); + BOOL get_CalculateBeforeSave(); + void put_CalculateBeforeSave(BOOL newValue); + long get_Calculation(); + void put_Calculation(long newValue); + VARIANT get_Caller(VARIANT IndexType); + BOOL get_CanPlaySounds(); + BOOL get_CanRecordSounds(); + CString get_Caption(); + void put_Caption(LPCTSTR newValue); + BOOL get_CellDragAndDrop(); + void put_CellDragAndDrop(BOOL newValue); + double CentimetersToPoints(double Centimeters); + BOOL CheckSpelling(LPCTSTR Word, VARIANT CustomDictionary, VARIANT IgnoreUppercase); + VARIANT get_ClipboardFormats(VARIANT IndexType); + BOOL get_DisplayClipboardWindow(); + void put_DisplayClipboardWindow(BOOL newValue); + BOOL get_ColorButtons(); + void put_ColorButtons(BOOL newValue); + long get_CommandUnderlines(); + void put_CommandUnderlines(long newValue); + BOOL get_ConstrainNumeric(); + void put_ConstrainNumeric(BOOL newValue); + VARIANT ConvertFormula(VARIANT Formula, long FromReferenceStyle, VARIANT ToReferenceStyle, VARIANT ToAbsolute, VARIANT RelativeTo); + BOOL get_CopyObjectsWithCells(); + void put_CopyObjectsWithCells(BOOL newValue); + long get_Cursor(); + void put_Cursor(long newValue); + long get_CustomListCount(); + long get_CutCopyMode(); + void put_CutCopyMode(long newValue); + long get_DataEntryMode(); + void put_DataEntryMode(long newValue); + VARIANT Dummy1(VARIANT Arg1, VARIANT Arg2, VARIANT Arg3, VARIANT Arg4); + VARIANT Dummy2(VARIANT Arg1, VARIANT Arg2, VARIANT Arg3, VARIANT Arg4, VARIANT Arg5, VARIANT Arg6, VARIANT Arg7, VARIANT Arg8); + VARIANT Dummy3(); + VARIANT Dummy4(VARIANT Arg1, VARIANT Arg2, VARIANT Arg3, VARIANT Arg4, VARIANT Arg5, VARIANT Arg6, VARIANT Arg7, VARIANT Arg8, VARIANT Arg9, VARIANT Arg10, VARIANT Arg11, VARIANT Arg12, VARIANT Arg13, VARIANT Arg14, VARIANT Arg15); + VARIANT Dummy5(VARIANT Arg1, VARIANT Arg2, VARIANT Arg3, VARIANT Arg4, VARIANT Arg5, VARIANT Arg6, VARIANT Arg7, VARIANT Arg8, VARIANT Arg9, VARIANT Arg10, VARIANT Arg11, VARIANT Arg12, VARIANT Arg13); + VARIANT Dummy6(); + VARIANT Dummy7(); + VARIANT Dummy8(VARIANT Arg1); + VARIANT Dummy9(); + BOOL Dummy10(VARIANT arg); + void Dummy11(); + CString get__Default(); + CString get_DefaultFilePath(); + void put_DefaultFilePath(LPCTSTR newValue); + void DeleteChartAutoFormat(LPCTSTR Name); + void DeleteCustomList(long ListNum); + LPDISPATCH get_Dialogs(); + BOOL get_DisplayAlerts(); + void put_DisplayAlerts(BOOL newValue); + BOOL get_DisplayFormulaBar(); + void put_DisplayFormulaBar(BOOL newValue); + BOOL get_DisplayFullScreen(); + void put_DisplayFullScreen(BOOL newValue); + BOOL get_DisplayNoteIndicator(); + void put_DisplayNoteIndicator(BOOL newValue); + long get_DisplayCommentIndicator(); + void put_DisplayCommentIndicator(long newValue); + BOOL get_DisplayExcel4Menus(); + void put_DisplayExcel4Menus(BOOL newValue); + BOOL get_DisplayRecentFiles(); + void put_DisplayRecentFiles(BOOL newValue); + BOOL get_DisplayScrollBars(); + void put_DisplayScrollBars(BOOL newValue); + BOOL get_DisplayStatusBar(); + void put_DisplayStatusBar(BOOL newValue); + void DoubleClick(); + BOOL get_EditDirectlyInCell(); + void put_EditDirectlyInCell(BOOL newValue); + BOOL get_EnableAutoComplete(); + void put_EnableAutoComplete(BOOL newValue); + long get_EnableCancelKey(); + void put_EnableCancelKey(long newValue); + BOOL get_EnableSound(); + void put_EnableSound(BOOL newValue); + BOOL get_EnableTipWizard(); + void put_EnableTipWizard(BOOL newValue); + VARIANT get_FileConverters(VARIANT Index1, VARIANT Index2); + LPDISPATCH get_FileSearch(); + LPDISPATCH get_FileFind(); + void _FindFile(); + BOOL get_FixedDecimal(); + void put_FixedDecimal(BOOL newValue); + long get_FixedDecimalPlaces(); + void put_FixedDecimalPlaces(long newValue); + VARIANT GetCustomListContents(long ListNum); + long GetCustomListNum(VARIANT ListArray); + VARIANT GetOpenFilename(VARIANT FileFilter, VARIANT FilterIndex, VARIANT Title, VARIANT ButtonText, VARIANT MultiSelect); + VARIANT GetSaveAsFilename(VARIANT InitialFilename, VARIANT FileFilter, VARIANT FilterIndex, VARIANT Title, VARIANT ButtonText); + void Goto(VARIANT Reference, VARIANT Scroll); + double get_Height(); + void put_Height(double newValue); + void Help(VARIANT HelpFile, VARIANT HelpContextID); + BOOL get_IgnoreRemoteRequests(); + void put_IgnoreRemoteRequests(BOOL newValue); + double InchesToPoints(double Inches); + VARIANT InputBox(LPCTSTR Prompt, VARIANT Title, VARIANT Default, VARIANT Left, VARIANT Top, VARIANT HelpFile, VARIANT HelpContextID, VARIANT Type); + BOOL get_Interactive(); + void put_Interactive(BOOL newValue); + VARIANT get_International(VARIANT IndexType); + BOOL get_Iteration(); + void put_Iteration(BOOL newValue); + BOOL get_LargeButtons(); + void put_LargeButtons(BOOL newValue); + double get_Left(); + void put_Left(double newValue); + CString get_LibraryPath(); + void _MacroOptions(VARIANT Macro, VARIANT Description, VARIANT HasMenu, VARIANT MenuText, VARIANT HasShortcutKey, VARIANT ShortcutKey, VARIANT Category, VARIANT StatusBar, VARIANT HelpContextID, VARIANT HelpFile); + void MailLogoff(); + void MailLogon(VARIANT Name, VARIANT Password, VARIANT DownloadNewMail); + VARIANT get_MailSession(); + long get_MailSystem(); + BOOL get_MathCoprocessorAvailable(); + double get_MaxChange(); + void put_MaxChange(double newValue); + long get_MaxIterations(); + void put_MaxIterations(long newValue); + long get_MemoryFree(); + long get_MemoryTotal(); + long get_MemoryUsed(); + BOOL get_MouseAvailable(); + BOOL get_MoveAfterReturn(); + void put_MoveAfterReturn(BOOL newValue); + long get_MoveAfterReturnDirection(); + void put_MoveAfterReturnDirection(long newValue); + LPDISPATCH get_RecentFiles(); + CString get_Name(); + LPDISPATCH NextLetter(); + CString get_NetworkTemplatesPath(); + LPDISPATCH get_ODBCErrors(); + long get_ODBCTimeout(); + void put_ODBCTimeout(long newValue); + CString get_OnCalculate(); + void put_OnCalculate(LPCTSTR newValue); + CString get_OnData(); + void put_OnData(LPCTSTR newValue); + CString get_OnDoubleClick(); + void put_OnDoubleClick(LPCTSTR newValue); + CString get_OnEntry(); + void put_OnEntry(LPCTSTR newValue); + void OnKey(LPCTSTR Key, VARIANT Procedure); + void OnRepeat(LPCTSTR Text, LPCTSTR Procedure); + CString get_OnSheetActivate(); + void put_OnSheetActivate(LPCTSTR newValue); + CString get_OnSheetDeactivate(); + void put_OnSheetDeactivate(LPCTSTR newValue); + void OnTime(VARIANT EarliestTime, LPCTSTR Procedure, VARIANT LatestTime, VARIANT Schedule); + void OnUndo(LPCTSTR Text, LPCTSTR Procedure); + CString get_OnWindow(); + void put_OnWindow(LPCTSTR newValue); + CString get_OperatingSystem(); + CString get_OrganizationName(); + CString get_Path(); + CString get_PathSeparator(); + VARIANT get_PreviousSelections(VARIANT IndexType); + BOOL get_PivotTableSelection(); + void put_PivotTableSelection(BOOL newValue); + BOOL get_PromptForSummaryInfo(); + void put_PromptForSummaryInfo(BOOL newValue); + void Quit(); + void RecordMacro(VARIANT BasicCode, VARIANT XlmCode); + BOOL get_RecordRelative(); + long get_ReferenceStyle(); + void put_ReferenceStyle(long newValue); + VARIANT get_RegisteredFunctions(VARIANT Index1, VARIANT Index2); + BOOL RegisterXLL(LPCTSTR Filename); + void Repeat(); + void ResetTipWizard(); + BOOL get_RollZoom(); + void put_RollZoom(BOOL newValue); + void Save(VARIANT Filename); + void SaveWorkspace(VARIANT Filename); + BOOL get_ScreenUpdating(); + void put_ScreenUpdating(BOOL newValue); + void SetDefaultChart(VARIANT FormatName, VARIANT Gallery); + long get_SheetsInNewWorkbook(); + void put_SheetsInNewWorkbook(long newValue); + BOOL get_ShowChartTipNames(); + void put_ShowChartTipNames(BOOL newValue); + BOOL get_ShowChartTipValues(); + void put_ShowChartTipValues(BOOL newValue); + CString get_StandardFont(); + void put_StandardFont(LPCTSTR newValue); + double get_StandardFontSize(); + void put_StandardFontSize(double newValue); + CString get_StartupPath(); + VARIANT get_StatusBar(); + void put_StatusBar(VARIANT newValue); + CString get_TemplatesPath(); + BOOL get_ShowToolTips(); + void put_ShowToolTips(BOOL newValue); + double get_Top(); + void put_Top(double newValue); + long get_DefaultSaveFormat(); + void put_DefaultSaveFormat(long newValue); + CString get_TransitionMenuKey(); + void put_TransitionMenuKey(LPCTSTR newValue); + long get_TransitionMenuKeyAction(); + void put_TransitionMenuKeyAction(long newValue); + BOOL get_TransitionNavigKeys(); + void put_TransitionNavigKeys(BOOL newValue); + void Undo(); + double get_UsableHeight(); + double get_UsableWidth(); + BOOL get_UserControl(); + void put_UserControl(BOOL newValue); + CString get_UserName(); + void put_UserName(LPCTSTR newValue); + CString get_Value(); + LPDISPATCH get_VBE(); + CString get_Version(); + BOOL get_Visible(); + void put_Visible(BOOL newValue); + void Volatile(VARIANT Volatile); + void _Wait(VARIANT Time); + double get_Width(); + void put_Width(double newValue); + BOOL get_WindowsForPens(); + long get_WindowState(); + void put_WindowState(long newValue); + long get_UILanguage(); + void put_UILanguage(long newValue); + long get_DefaultSheetDirection(); + void put_DefaultSheetDirection(long newValue); + long get_CursorMovement(); + void put_CursorMovement(long newValue); + BOOL get_ControlCharacters(); + void put_ControlCharacters(BOOL newValue); + VARIANT _WSFunction(VARIANT Arg1, VARIANT Arg2, VARIANT Arg3, VARIANT Arg4, VARIANT Arg5, VARIANT Arg6, VARIANT Arg7, VARIANT Arg8, VARIANT Arg9, VARIANT Arg10, VARIANT Arg11, VARIANT Arg12, VARIANT Arg13, VARIANT Arg14, VARIANT Arg15, VARIANT Arg16, VARIANT Arg17, VARIANT Arg18, VARIANT Arg19, VARIANT Arg20, VARIANT Arg21, VARIANT Arg22, VARIANT Arg23, VARIANT Arg24, VARIANT Arg25, VARIANT Arg26, VARIANT Arg27, VARIANT Arg28, VARIANT Arg29, VARIANT Arg30); + BOOL get_EnableEvents(); + void put_EnableEvents(BOOL newValue); + BOOL get_DisplayInfoWindow(); + void put_DisplayInfoWindow(BOOL newValue); + BOOL Wait(VARIANT Time); + BOOL get_ExtendList(); + void put_ExtendList(BOOL newValue); + LPDISPATCH get_OLEDBErrors(); + CString GetPhonetic(VARIANT Text); + LPDISPATCH get_COMAddIns(); + LPDISPATCH get_DefaultWebOptions(); + CString get_ProductCode(); + CString get_UserLibraryPath(); + BOOL get_AutoPercentEntry(); + void put_AutoPercentEntry(BOOL newValue); + LPDISPATCH get_LanguageSettings(); + LPDISPATCH get_Dummy101(); + void Dummy12(LPDISPATCH p1, LPDISPATCH p2); + LPDISPATCH get_AnswerWizard(); + void CalculateFull(); + BOOL FindFile(); + long get_CalculationVersion(); + BOOL get_ShowWindowsInTaskbar(); + void put_ShowWindowsInTaskbar(BOOL newValue); + long get_FeatureInstall(); + void put_FeatureInstall(long newValue); + BOOL get_Ready(); + VARIANT Dummy13(VARIANT Arg1, VARIANT Arg2, VARIANT Arg3, VARIANT Arg4, VARIANT Arg5, VARIANT Arg6, VARIANT Arg7, VARIANT Arg8, VARIANT Arg9, VARIANT Arg10, VARIANT Arg11, VARIANT Arg12, VARIANT Arg13, VARIANT Arg14, VARIANT Arg15, VARIANT Arg16, VARIANT Arg17, VARIANT Arg18, VARIANT Arg19, VARIANT Arg20, VARIANT Arg21, VARIANT Arg22, VARIANT Arg23, VARIANT Arg24, VARIANT Arg25, VARIANT Arg26, VARIANT Arg27, VARIANT Arg28, VARIANT Arg29, VARIANT Arg30); + LPDISPATCH get_FindFormat(); + void putref_FindFormat(LPDISPATCH newValue); + LPDISPATCH get_ReplaceFormat(); + void putref_ReplaceFormat(LPDISPATCH newValue); + LPDISPATCH get_UsedObjects(); + long get_CalculationState(); + long get_CalculationInterruptKey(); + void put_CalculationInterruptKey(long newValue); + LPDISPATCH get_Watches(); + BOOL get_DisplayFunctionToolTips(); + void put_DisplayFunctionToolTips(BOOL newValue); + long get_AutomationSecurity(); + void put_AutomationSecurity(long newValue); + LPDISPATCH get_FileDialog(long fileDialogType); + void Dummy14(); + void CalculateFullRebuild(); + BOOL get_DisplayPasteOptions(); + void put_DisplayPasteOptions(BOOL newValue); + BOOL get_DisplayInsertOptions(); + void put_DisplayInsertOptions(BOOL newValue); + BOOL get_GenerateGetPivotData(); + void put_GenerateGetPivotData(BOOL newValue); + LPDISPATCH get_AutoRecover(); + long get_Hwnd(); + long get_Hinstance(); + void CheckAbort(VARIANT KeepAbort); + LPDISPATCH get_ErrorCheckingOptions(); + BOOL get_AutoFormatAsYouTypeReplaceHyperlinks(); + void put_AutoFormatAsYouTypeReplaceHyperlinks(BOOL newValue); + LPDISPATCH get_SmartTagRecognizers(); + LPDISPATCH get_NewWorkbook(); + LPDISPATCH get_SpellingOptions(); + LPDISPATCH get_Speech(); + BOOL get_MapPaperSize(); + void put_MapPaperSize(BOOL newValue); + BOOL get_ShowStartupDialog(); + void put_ShowStartupDialog(BOOL newValue); + CString get_DecimalSeparator(); + void put_DecimalSeparator(LPCTSTR newValue); + CString get_ThousandsSeparator(); + void put_ThousandsSeparator(LPCTSTR newValue); + BOOL get_UseSystemSeparators(); + void put_UseSystemSeparators(BOOL newValue); + LPDISPATCH get_ThisCell(); + LPDISPATCH get_RTD(); + BOOL get_DisplayDocumentActionTaskPane(); + void put_DisplayDocumentActionTaskPane(BOOL newValue); + void DisplayXMLSourcePane(VARIANT XmlMap); + BOOL get_ArbitraryXMLSupportAvailable(); + VARIANT Support(LPDISPATCH Object, long ID, VARIANT arg); + VARIANT Dummy20(long grfCompareFunctions); + long get_MeasurementUnit(); + void put_MeasurementUnit(long newValue); + BOOL get_ShowSelectionFloaties(); + void put_ShowSelectionFloaties(BOOL newValue); + BOOL get_ShowMenuFloaties(); + void put_ShowMenuFloaties(BOOL newValue); + BOOL get_ShowDevTools(); + void put_ShowDevTools(BOOL newValue); + BOOL get_EnableLivePreview(); + void put_EnableLivePreview(BOOL newValue); + BOOL get_DisplayDocumentInformationPanel(); + void put_DisplayDocumentInformationPanel(BOOL newValue); + BOOL get_AlwaysUseClearType(); + void put_AlwaysUseClearType(BOOL newValue); + BOOL get_WarnOnFunctionNameConflict(); + void put_WarnOnFunctionNameConflict(BOOL newValue); + long get_FormulaBarHeight(); + void put_FormulaBarHeight(long newValue); + BOOL get_DisplayFormulaAutoComplete(); + void put_DisplayFormulaAutoComplete(BOOL newValue); + long get_GenerateTableRefs(); + void put_GenerateTableRefs(long newValue); + LPDISPATCH get_Assistance(); + void CalculateUntilAsyncQueriesDone(); + BOOL get_EnableLargeOperationAlert(); + void put_EnableLargeOperationAlert(BOOL newValue); + long get_LargeOperationCellThousandCount(); + void put_LargeOperationCellThousandCount(long newValue); + BOOL get_DeferAsyncQueries(); + void put_DeferAsyncQueries(BOOL newValue); + LPDISPATCH get_MultiThreadedCalculation(); + long SharePointVersion(LPCTSTR bstrUrl); + long get_ActiveEncryptionSession(); + BOOL get_HighQualityModeForGraphics(); + void put_HighQualityModeForGraphics(BOOL newValue); + LPDISPATCH get_FileExportConverters(); + LPDISPATCH get_SmartArtLayouts(); + LPDISPATCH get_SmartArtQuickStyles(); + LPDISPATCH get_SmartArtColors(); + LPDISPATCH get_AddIns2(); + BOOL get_PrintCommunication(); + void put_PrintCommunication(BOOL newValue); + void MacroOptions(VARIANT Macro, VARIANT Description, VARIANT HasMenu, VARIANT MenuText, VARIANT HasShortcutKey, VARIANT ShortcutKey, VARIANT Category, VARIANT StatusBar, VARIANT HelpContextID, VARIANT HelpFile, VARIANT ArgumentDescriptions); + BOOL get_UseClusterConnector(); + void put_UseClusterConnector(BOOL newValue); + CString get_ClusterConnector(); + void put_ClusterConnector(LPCTSTR newValue); + BOOL get_Quitting(); + BOOL get_Dummy22(); + void put_Dummy22(BOOL newValue); + BOOL get_Dummy23(); + void put_Dummy23(BOOL newValue); + LPDISPATCH get_ProtectedViewWindows(); + LPDISPATCH get_ActiveProtectedViewWindow(); + BOOL get_IsSandboxed(); + BOOL get_SaveISO8601Dates(); + void put_SaveISO8601Dates(BOOL newValue); + VARIANT get_HinstancePtr(); + long get_FileValidation(); + void put_FileValidation(long newValue); + long get_FileValidationPivot(); + void put_FileValidationPivot(long newValue); + BOOL get_ShowQuickAnalysis(); + void put_ShowQuickAnalysis(BOOL newValue); + LPDISPATCH get_QuickAnalysis(); + BOOL get_FlashFill(); + void put_FlashFill(BOOL newValue); + BOOL get_EnableMacroAnimations(); + void put_EnableMacroAnimations(BOOL newValue); + BOOL get_ChartDataPointTrack(); + void put_ChartDataPointTrack(BOOL newValue); + BOOL get_FlashFillMode(); + void put_FlashFillMode(BOOL newValue); + BOOL get_MergeInstances(); + void put_MergeInstances(BOOL newValue); + BOOL get_EnableCheckFileExtensions(); + void put_EnableCheckFileExtensions(BOOL newValue); +}; + +} // namespace MSO::Excel diff --git a/include/office/excel/EXLRange.h b/include/office/excel/EXLRange.h new file mode 100644 index 0000000..2552b14 --- /dev/null +++ b/include/office/excel/EXLRange.h @@ -0,0 +1,253 @@ +#pragma once +// EXLRange wrapper class + +#include "office/VariantableDispatch.hpp" + +#undef DialogBox + +namespace MSO::Excel { + static constexpr long xlRangeValueDefault = 10; + static constexpr long xlRangeValueXMLSpreadsheet = 11; + static constexpr long xlRangeValueMSPersistXML = 12; + +class EXLRange : public VariantableDispatch { +public: + EXLRange() = default; + EXLRange(LPDISPATCH pDispatch) : VariantableDispatch(pDispatch) {} + EXLRange(const EXLRange& dispatchSrc) : VariantableDispatch(dispatchSrc) {} + +public: + template + EXLRange operator()(const IndexType& RowIndex, const IndexType& ColumnIndex); + +public: + void put_Item(long RowIndex, long ColumnIndex, const VARIANT& newValue); + + EXLRange get_Item(VARIANT RowIndex, VARIANT ColumnIndex); + void put_Item(VARIANT RowIndex, VARIANT ColumnIndex, VARIANT newValue); + EXLRange get_Columns(); + EXLRange get_Rows(); + EXLRange get_Cells(); + VARIANT get_Value(VARIANT RangeValueDataType = _variant_t(xlRangeValueDefault)); + + LPDISPATCH get_Application(); + long get_Creator(); + LPDISPATCH get_Parent(); + VARIANT Activate(); + VARIANT get_AddIndent(); + void put_AddIndent(VARIANT newValue); + CString get_Address(VARIANT RowAbsolute, VARIANT ColumnAbsolute, long ReferenceStyle, VARIANT External, VARIANT RelativeTo); + CString get_AddressLocal(VARIANT RowAbsolute, VARIANT ColumnAbsolute, long ReferenceStyle, VARIANT External, VARIANT RelativeTo); + VARIANT AdvancedFilter(long Action, VARIANT CriteriaRange, VARIANT CopyToRange, VARIANT Unique); + VARIANT ApplyNames(VARIANT Names, VARIANT IgnoreRelativeAbsolute, VARIANT UseRowColumnNames, VARIANT OmitColumn, VARIANT OmitRow, long Order, VARIANT AppendLast); + VARIANT ApplyOutlineStyles(); + LPDISPATCH get_Areas(); + CString AutoComplete(LPCTSTR String); + VARIANT AutoFill(LPDISPATCH Destination, long Type); + VARIANT AutoFilter(VARIANT Field, VARIANT Criteria1, long Operator, VARIANT Criteria2, VARIANT VisibleDropDown); + VARIANT AutoFit(); + VARIANT AutoFormat(long Format, VARIANT Number, VARIANT Font, VARIANT Alignment, VARIANT Border, VARIANT Pattern, VARIANT Width); + VARIANT AutoOutline(); + VARIANT _BorderAround(VARIANT LineStyle, long Weight, long ColorIndex, VARIANT Color); + LPDISPATCH get_Borders(); + VARIANT Calculate(); + LPDISPATCH get_Characters(VARIANT Start, VARIANT Length); + VARIANT CheckSpelling(VARIANT CustomDictionary, VARIANT IgnoreUppercase, VARIANT AlwaysSuggest, VARIANT SpellLang); + VARIANT Clear(); + VARIANT ClearContents(); + VARIANT ClearFormats(); + VARIANT ClearNotes(); + VARIANT ClearOutline(); + long get_Column(); + LPDISPATCH ColumnDifferences(VARIANT Comparison); + VARIANT get_ColumnWidth(); + void put_ColumnWidth(VARIANT newValue); + VARIANT Consolidate(VARIANT Sources, VARIANT Function, VARIANT TopRow, VARIANT LeftColumn, VARIANT CreateLinks); + VARIANT Copy(VARIANT Destination); + long CopyFromRecordset(LPUNKNOWN Data, VARIANT MaxRows, VARIANT MaxColumns); + VARIANT CopyPicture(long Appearance, long Format); + long get_Count(); + VARIANT CreateNames(VARIANT Top, VARIANT Left, VARIANT Bottom, VARIANT Right); + VARIANT CreatePublisher(VARIANT Edition, long Appearance, VARIANT ContainsPICT, VARIANT ContainsBIFF, VARIANT ContainsRTF, VARIANT ContainsVALU); + LPDISPATCH get_CurrentArray(); + LPDISPATCH get_CurrentRegion(); + VARIANT Cut(VARIANT Destination); + VARIANT DataSeries(VARIANT Rowcol, long Type, long Date, VARIANT Step, VARIANT Stop, VARIANT Trend); + VARIANT get__Default(VARIANT RowIndex, VARIANT ColumnIndex); + void put__Default(VARIANT RowIndex, VARIANT ColumnIndex, VARIANT newValue); + VARIANT Delete(VARIANT Shift); + LPDISPATCH get_Dependents(); + VARIANT DialogBox(); + LPDISPATCH get_DirectDependents(); + LPDISPATCH get_DirectPrecedents(); + VARIANT EditionOptions(long Type, long Option, VARIANT Name, VARIANT Reference, long Appearance, long ChartSize, VARIANT Format); + LPDISPATCH get_End(long Direction); + LPDISPATCH get_EntireColumn(); + LPDISPATCH get_EntireRow(); + VARIANT FillDown(); + VARIANT FillLeft(); + VARIANT FillRight(); + VARIANT FillUp(); + LPDISPATCH Find(VARIANT What, VARIANT After, VARIANT LookIn, VARIANT LookAt, VARIANT SearchOrder, long SearchDirection, VARIANT MatchCase, VARIANT MatchByte, VARIANT SearchFormat); + LPDISPATCH FindNext(VARIANT After); + LPDISPATCH FindPrevious(VARIANT After); + LPDISPATCH get_Font(); + VARIANT get_Formula(); + void put_Formula(VARIANT newValue); + VARIANT get_FormulaArray(); + void put_FormulaArray(VARIANT newValue); + long get_FormulaLabel(); + void put_FormulaLabel(long newValue); + VARIANT get_FormulaHidden(); + void put_FormulaHidden(VARIANT newValue); + VARIANT get_FormulaLocal(); + void put_FormulaLocal(VARIANT newValue); + VARIANT get_FormulaR1C1(); + void put_FormulaR1C1(VARIANT newValue); + VARIANT get_FormulaR1C1Local(); + void put_FormulaR1C1Local(VARIANT newValue); + VARIANT FunctionWizard(); + BOOL GoalSeek(VARIANT Goal, LPDISPATCH ChangingCell); + VARIANT Group(VARIANT Start, VARIANT End, VARIANT By, VARIANT Periods); + VARIANT get_HasArray(); + VARIANT get_HasFormula(); + VARIANT get_Height(); + VARIANT get_Hidden(); + void put_Hidden(VARIANT newValue); + VARIANT get_HorizontalAlignment(); + void put_HorizontalAlignment(VARIANT newValue); + VARIANT get_IndentLevel(); + void put_IndentLevel(VARIANT newValue); + void InsertIndent(long InsertAmount); + VARIANT Insert(VARIANT Shift, VARIANT CopyOrigin); + LPDISPATCH get_Interior(); + VARIANT Justify(); + VARIANT get_Left(); + long get_ListHeaderRows(); + VARIANT ListNames(); + long get_LocationInTable(); + VARIANT get_Locked(); + void put_Locked(VARIANT newValue); + void Merge(VARIANT Across); + void UnMerge(); + LPDISPATCH get_MergeArea(); + VARIANT get_MergeCells(); + void put_MergeCells(VARIANT newValue); + VARIANT get_Name(); + void put_Name(VARIANT newValue); + VARIANT NavigateArrow(VARIANT TowardPrecedent, VARIANT ArrowNumber, VARIANT LinkNumber); + LPUNKNOWN get_NewEnum(); + LPDISPATCH get_Next(); + CString NoteText(VARIANT Text, VARIANT Start, VARIANT Length); + VARIANT get_NumberFormat(); + void put_NumberFormat(VARIANT newValue); + VARIANT get_NumberFormatLocal(); + void put_NumberFormatLocal(VARIANT newValue); + LPDISPATCH get_Offset(VARIANT RowOffset, VARIANT ColumnOffset); + VARIANT get_Orientation(); + void put_Orientation(VARIANT newValue); + VARIANT get_OutlineLevel(); + void put_OutlineLevel(VARIANT newValue); + long get_PageBreak(); + void put_PageBreak(long newValue); + VARIANT Parse(VARIANT ParseLine, VARIANT Destination); + VARIANT _PasteSpecial(long Paste, long Operation, VARIANT SkipBlanks, VARIANT Transpose); + LPDISPATCH get_PivotField(); + LPDISPATCH get_PivotItem(); + LPDISPATCH get_PivotTable(); + LPDISPATCH get_Precedents(); + VARIANT get_PrefixCharacter(); + LPDISPATCH get_Previous(); + VARIANT __PrintOut(VARIANT From, VARIANT To, VARIANT Copies, VARIANT Preview, VARIANT ActivePrinter, VARIANT PrintToFile, VARIANT Collate); + VARIANT PrintPreview(VARIANT EnableChanges); + LPDISPATCH get_QueryTable(); + LPDISPATCH get_Range(VARIANT Cell1, VARIANT Cell2); + VARIANT RemoveSubtotal(); + BOOL Replace(VARIANT What, VARIANT Replacement, VARIANT LookAt, VARIANT SearchOrder, VARIANT MatchCase, VARIANT MatchByte, VARIANT SearchFormat, VARIANT ReplaceFormat); + LPDISPATCH get_Resize(VARIANT RowSize, VARIANT ColumnSize); + long get_Row(); + LPDISPATCH RowDifferences(VARIANT Comparison); + VARIANT get_RowHeight(); + void put_RowHeight(VARIANT newValue); + VARIANT Run(VARIANT Arg1, VARIANT Arg2, VARIANT Arg3, VARIANT Arg4, VARIANT Arg5, VARIANT Arg6, VARIANT Arg7, VARIANT Arg8, VARIANT Arg9, VARIANT Arg10, VARIANT Arg11, VARIANT Arg12, VARIANT Arg13, VARIANT Arg14, VARIANT Arg15, VARIANT Arg16, VARIANT Arg17, VARIANT Arg18, VARIANT Arg19, VARIANT Arg20, VARIANT Arg21, VARIANT Arg22, VARIANT Arg23, VARIANT Arg24, VARIANT Arg25, VARIANT Arg26, VARIANT Arg27, VARIANT Arg28, VARIANT Arg29, VARIANT Arg30); + VARIANT Select(); + VARIANT Show(); + VARIANT ShowDependents(VARIANT Remove); + VARIANT get_ShowDetail(); + void put_ShowDetail(VARIANT newValue); + VARIANT ShowErrors(); + VARIANT ShowPrecedents(VARIANT Remove); + VARIANT get_ShrinkToFit(); + void put_ShrinkToFit(VARIANT newValue); + VARIANT Sort(VARIANT Key1, long Order1, VARIANT Key2, VARIANT Type, long Order2, VARIANT Key3, long Order3, long Header, VARIANT OrderCustom, VARIANT MatchCase, long Orientation, long SortMethod, long DataOption1, long DataOption2, long DataOption3); + VARIANT SortSpecial(long SortMethod, VARIANT Key1, long Order1, VARIANT Type, VARIANT Key2, long Order2, VARIANT Key3, long Order3, long Header, VARIANT OrderCustom, VARIANT MatchCase, long Orientation, long DataOption1, long DataOption2, long DataOption3); + LPDISPATCH get_SoundNote(); + LPDISPATCH SpecialCells(long Type, VARIANT Value); + VARIANT get_Style(); + void put_Style(VARIANT newValue); + VARIANT SubscribeTo(LPCTSTR Edition, long Format); + VARIANT Subtotal(long GroupBy, long Function, VARIANT TotalList, VARIANT Replace, VARIANT PageBreaks, long SummaryBelowData); + VARIANT get_Summary(); + VARIANT Table(VARIANT RowInput, VARIANT ColumnInput); + VARIANT get_Text(); + VARIANT TextToColumns(VARIANT Destination, long DataType, long TextQualifier, VARIANT ConsecutiveDelimiter, VARIANT Tab, VARIANT Semicolon, VARIANT Comma, VARIANT Space, VARIANT Other, VARIANT OtherChar, VARIANT FieldInfo, VARIANT DecimalSeparator, VARIANT ThousandsSeparator, VARIANT TrailingMinusNumbers); + VARIANT get_Top(); + VARIANT Ungroup(); + VARIANT get_UseStandardHeight(); + void put_UseStandardHeight(VARIANT newValue); + VARIANT get_UseStandardWidth(); + void put_UseStandardWidth(VARIANT newValue); + LPDISPATCH get_Validation(); + void put_Value(VARIANT RangeValueDataType, VARIANT newValue); + VARIANT get_Value2(); + void put_Value2(VARIANT newValue); + VARIANT get_VerticalAlignment(); + void put_VerticalAlignment(VARIANT newValue); + VARIANT get_Width(); + LPDISPATCH get_Worksheet(); + VARIANT get_WrapText(); + void put_WrapText(VARIANT newValue); + LPDISPATCH AddComment(VARIANT Text); + LPDISPATCH get_Comment(); + void ClearComments(); + LPDISPATCH get_Phonetic(); + LPDISPATCH get_FormatConditions(); + long get_ReadingOrder(); + void put_ReadingOrder(long newValue); + LPDISPATCH get_Hyperlinks(); + LPDISPATCH get_Phonetics(); + void SetPhonetic(); + CString get_ID(); + void put_ID(LPCTSTR newValue); + VARIANT _PrintOut(VARIANT From, VARIANT To, VARIANT Copies, VARIANT Preview, VARIANT ActivePrinter, VARIANT PrintToFile, VARIANT Collate, VARIANT PrToFileName); + LPDISPATCH get_PivotCell(); + void Dirty(); + LPDISPATCH get_Errors(); + LPDISPATCH get_SmartTags(); + void Speak(VARIANT SpeakDirection, VARIANT SpeakFormulas); + VARIANT PasteSpecial(long Paste, long Operation, VARIANT SkipBlanks, VARIANT Transpose); + BOOL get_AllowEdit(); + LPDISPATCH get_ListObject(); + LPDISPATCH get_XPath(); + LPDISPATCH get_ServerActions(); + void RemoveDuplicates(VARIANT Columns, long Header); + VARIANT PrintOut(VARIANT From, VARIANT To, VARIANT Copies, VARIANT Preview, VARIANT ActivePrinter, VARIANT PrintToFile, VARIANT Collate, VARIANT PrToFileName); + CString get_MDX(); + void ExportAsFixedFormat(long Type, VARIANT Filename, VARIANT Quality, VARIANT IncludeDocProperties, VARIANT IgnorePrintAreas, VARIANT From, VARIANT To, VARIANT OpenAfterPublish, VARIANT FixedFormatExtClassPtr); + VARIANT get_CountLarge(); + VARIANT CalculateRowMajorOrder(); + LPDISPATCH get_SparklineGroups(); + void ClearHyperlinks(); + LPDISPATCH get_DisplayFormat(); + VARIANT BorderAround(VARIANT LineStyle, long Weight, long ColorIndex, VARIANT Color, VARIANT ThemeColor); + void AllocateChanges(); + void DiscardChanges(); + void FlashFill(); +}; + +template +EXLRange EXLRange::operator()(const IndexType& RowIndex, const IndexType& ColumnIndex) { + return get_Item(_variant_t(RowIndex), _variant_t(ColumnIndex)); +} + +} // namespace MSO::Excel diff --git a/include/office/excel/EXLRanges.h b/include/office/excel/EXLRanges.h new file mode 100644 index 0000000..ecf71fe --- /dev/null +++ b/include/office/excel/EXLRanges.h @@ -0,0 +1,28 @@ +#pragma once +// EXLRanges wrapper class + +#include "office/VariantableDispatch.hpp" +#include "office/MSCollection.hpp" + +namespace MSO::Excel { + class EXLRange; + +class EXLRanges : + public VariantableDispatch, + public MSCollection { +public: + EXLRanges() = default; + EXLRanges(LPDISPATCH pDispatch) : VariantableDispatch(pDispatch) {} + EXLRanges(const EXLRanges& dispatchSrc) : VariantableDispatch(dispatchSrc) {} + +public: + LPDISPATCH get_Application(); + long get_Creator(); + LPDISPATCH get_Parent(); + LPDISPATCH get__Default(VARIANT IndexType); + LPUNKNOWN get_NewEnum(); + LPDISPATCH get_Item(VARIANT IndexType); + long get_Count(); +}; + +} // namespace MSO::Excel diff --git a/include/office/excel/EXLWorkbook.h b/include/office/excel/EXLWorkbook.h new file mode 100644 index 0000000..fa424df --- /dev/null +++ b/include/office/excel/EXLWorkbook.h @@ -0,0 +1,295 @@ +#pragma once +// EXLWorkbook wrapper class + +#include "office/VariantableDispatch.hpp" + +namespace MSO::Excel { + class EXLWorksheets; + +#pragma warning( push ) +#pragma warning( disable : 26426 ) // allow variant_t initialization + + static const _variant_t xlWorkbookDefault = 51; + static const _variant_t xlSaveAsAccessMode_xlNoChange = 1; + static const _variant_t xlLocalSessionChanges = 2; + +#pragma warning( pop ) + +class EXLWorkbook : public VariantableDispatch { +public: + EXLWorkbook() = default; + EXLWorkbook(LPDISPATCH pDispatch) : VariantableDispatch(pDispatch) {} + EXLWorkbook(const EXLWorkbook& dispatchSrc) : VariantableDispatch(dispatchSrc) {} + +public: + void Close(VARIANT SaveChanges, VARIANT Filename, VARIANT RouteWorkbook); + void SaveAs(VARIANT Filename, VARIANT FileFormat, VARIANT Password, VARIANT WriteResPassword, + VARIANT ReadOnlyRecommended, VARIANT CreateBackup, long AccessMode, VARIANT ConflictResolution, + VARIANT AddToMru, VARIANT TextCodepage, VARIANT TextVisualLayout, VARIANT Local); + + LPDISPATCH get_Application(); + long get_Creator(); + LPDISPATCH get_Parent(); + BOOL get_AcceptLabelsInFormulas(); + void put_AcceptLabelsInFormulas(BOOL newValue); + void Activate(); + LPDISPATCH get_ActiveChart(); + LPDISPATCH get_ActiveSheet(); + CString get_Author(); + void put_Author(LPCTSTR newValue); + long get_AutoUpdateFrequency(); + void put_AutoUpdateFrequency(long newValue); + BOOL get_AutoUpdateSaveChanges(); + void put_AutoUpdateSaveChanges(BOOL newValue); + long get_ChangeHistoryDuration(); + void put_ChangeHistoryDuration(long newValue); + LPDISPATCH get_BuiltinDocumentProperties(); + void ChangeFileAccess(long Mode, VARIANT WritePassword, VARIANT Notify); + void ChangeLink(LPCTSTR Name, LPCTSTR NewName, long Type); + LPDISPATCH get_Charts(); + CString get_CodeName(); + CString get__CodeName(); + void put__CodeName(LPCTSTR newValue); + VARIANT get_Colors(VARIANT IndexType); + void put_Colors(VARIANT IndexType, VARIANT newValue); + LPDISPATCH get_CommandBars(); + CString get_Comments(); + void put_Comments(LPCTSTR newValue); + long get_ConflictResolution(); + void put_ConflictResolution(long newValue); + LPDISPATCH get_Container(); + BOOL get_CreateBackup(); + LPDISPATCH get_CustomDocumentProperties(); + BOOL get_Date1904(); + void put_Date1904(BOOL newValue); + void DeleteNumberFormat(LPCTSTR NumberFormat); + LPDISPATCH get_DialogSheets(); + long get_DisplayDrawingObjects(); + void put_DisplayDrawingObjects(long newValue); + BOOL ExclusiveAccess(); + long get_FileFormat(); + void ForwardMailer(); + CString get_FullName(); + BOOL get_HasMailer(); + void put_HasMailer(BOOL newValue); + BOOL get_HasPassword(); + BOOL get_HasRoutingSlip(); + void put_HasRoutingSlip(BOOL newValue); + BOOL get_IsAddin(); + void put_IsAddin(BOOL newValue); + CString get_Keywords(); + void put_Keywords(LPCTSTR newValue); + VARIANT LinkInfo(LPCTSTR Name, long LinkInfo, VARIANT Type, VARIANT EditionRef); + VARIANT LinkSources(VARIANT Type); + LPDISPATCH get_Mailer(); + void MergeWorkbook(VARIANT Filename); + LPDISPATCH get_Modules(); + BOOL get_MultiUserEditing(); + CString get_Name(); + LPDISPATCH get_Names(); + LPDISPATCH NewWindow(); + CString get_OnSave(); + void put_OnSave(LPCTSTR newValue); + CString get_OnSheetActivate(); + void put_OnSheetActivate(LPCTSTR newValue); + CString get_OnSheetDeactivate(); + void put_OnSheetDeactivate(LPCTSTR newValue); + void OpenLinks(LPCTSTR Name, VARIANT ReadOnly, VARIANT Type); + CString get_Path(); + BOOL get_PersonalViewListSettings(); + void put_PersonalViewListSettings(BOOL newValue); + BOOL get_PersonalViewPrintSettings(); + void put_PersonalViewPrintSettings(BOOL newValue); + LPDISPATCH PivotCaches(); + void Post(VARIANT DestName); + BOOL get_PrecisionAsDisplayed(); + void put_PrecisionAsDisplayed(BOOL newValue); + void __PrintOut(VARIANT From, VARIANT To, VARIANT Copies, VARIANT Preview, VARIANT ActivePrinter, VARIANT PrintToFile, VARIANT Collate); + void PrintPreview(VARIANT EnableChanges); + void _Protect(VARIANT Password, VARIANT Structure, VARIANT Windows); + void _ProtectSharing(VARIANT Filename, VARIANT Password, VARIANT WriteResPassword, VARIANT ReadOnlyRecommended, VARIANT CreateBackup, VARIANT SharingPassword); + BOOL get_ProtectStructure(); + BOOL get_ProtectWindows(); + BOOL get_ReadOnly(); + BOOL get__ReadOnlyRecommended(); + void RefreshAll(); + void Reply(); + void ReplyAll(); + void RemoveUser(long IndexType); + long get_RevisionNumber(); + void Route(); + BOOL get_Routed(); + LPDISPATCH get_RoutingSlip(); + void RunAutoMacros(long Which); + void Save(); + void _SaveAs(VARIANT Filename, VARIANT FileFormat, VARIANT Password, VARIANT WriteResPassword, VARIANT ReadOnlyRecommended, VARIANT CreateBackup, long AccessMode, VARIANT ConflictResolution, VARIANT AddToMru, VARIANT TextCodepage, VARIANT TextVisualLayout); + void SaveCopyAs(VARIANT Filename); + BOOL get_Saved(); + void put_Saved(BOOL newValue); + BOOL get_SaveLinkValues(); + void put_SaveLinkValues(BOOL newValue); + void SendMail(VARIANT Recipients, VARIANT Subject, VARIANT ReturnReceipt); + void SendMailer(VARIANT FileFormat, long Priority); + void SetLinkOnData(LPCTSTR Name, VARIANT Procedure); + LPDISPATCH get_Sheets(); + BOOL get_ShowConflictHistory(); + void put_ShowConflictHistory(BOOL newValue); + LPDISPATCH get_Styles(); + CString get_Subject(); + void put_Subject(LPCTSTR newValue); + CString get_Title(); + void put_Title(LPCTSTR newValue); + void Unprotect(VARIANT Password); + void UnprotectSharing(VARIANT SharingPassword); + void UpdateFromFile(); + void UpdateLink(VARIANT Name, VARIANT Type); + BOOL get_UpdateRemoteReferences(); + void put_UpdateRemoteReferences(BOOL newValue); + BOOL get_UserControl(); + void put_UserControl(BOOL newValue); + VARIANT get_UserStatus(); + LPDISPATCH get_CustomViews(); + LPDISPATCH get_Windows(); + EXLWorksheets get_Worksheets(); + BOOL get_WriteReserved(); + CString get_WriteReservedBy(); + LPDISPATCH get_Excel4IntlMacroSheets(); + LPDISPATCH get_Excel4MacroSheets(); + BOOL get_TemplateRemoveExtData(); + void put_TemplateRemoveExtData(BOOL newValue); + void HighlightChangesOptions(VARIANT When, VARIANT Who, VARIANT Where); + BOOL get_HighlightChangesOnScreen(); + void put_HighlightChangesOnScreen(BOOL newValue); + BOOL get_KeepChangeHistory(); + void put_KeepChangeHistory(BOOL newValue); + BOOL get_ListChangesOnNewSheet(); + void put_ListChangesOnNewSheet(BOOL newValue); + void PurgeChangeHistoryNow(long Days, VARIANT sharingPassword); + void AcceptAllChanges(VARIANT When, VARIANT Who, VARIANT Where); + void RejectAllChanges(VARIANT When, VARIANT Who, VARIANT Where); + void PivotTableWizard(VARIANT sourceType, VARIANT operableData, VARIANT tableDestination, VARIANT TableName, VARIANT RowGrand, VARIANT ColumnGrand, VARIANT SaveData, VARIANT HasAutoFormat, VARIANT AutoPage, VARIANT Reserved, VARIANT BackgroundQuery, VARIANT OptimizeCache, VARIANT PageFieldOrder, VARIANT PageFieldWrapCount, VARIANT ReadData, VARIANT Connection); + void ResetColors(); + LPDISPATCH get_VBProject(); + void FollowHyperlink(LPCTSTR Address, VARIANT SubAddress, VARIANT NewWindow, VARIANT AddHistory, VARIANT ExtraInfo, VARIANT Method, VARIANT HeaderInfo); + void AddToFavorites(); + BOOL get_IsInplace(); + void _PrintOut(VARIANT From, VARIANT To, VARIANT Copies, VARIANT Preview, VARIANT ActivePrinter, VARIANT PrintToFile, VARIANT Collate, VARIANT PrToFileName); + void WebPagePreview(); + LPDISPATCH get_PublishObjects(); + LPDISPATCH get_WebOptions(); + void ReloadAs(long Encoding); + LPDISPATCH get_HTMLProject(); + BOOL get_EnvelopeVisible(); + void put_EnvelopeVisible(BOOL newValue); + long get_CalculationVersion(); + void Dummy17(long calcid); + void sblt(LPCTSTR s); + BOOL get_VBASigned(); + BOOL get_ShowPivotTableFieldList(); + void put_ShowPivotTableFieldList(BOOL newValue); + long get_UpdateLinks(); + void put_UpdateLinks(long newValue); + void BreakLink(LPCTSTR Name, long Type); + void Dummy16(); + BOOL get_EnableAutoRecover(); + void put_EnableAutoRecover(BOOL newValue); + BOOL get_RemovePersonalInformation(); + void put_RemovePersonalInformation(BOOL newValue); + CString get_FullNameURLEncoded(); + void CheckIn(VARIANT SaveChanges, VARIANT Comments, VARIANT MakePublic); + BOOL CanCheckIn(); + void SendForReview(VARIANT Recipients, VARIANT Subject, VARIANT ShowMessage, VARIANT IncludeAttachment); + void ReplyWithChanges(VARIANT ShowMessage); + void EndReview(); + CString get_Password(); + void put_Password(LPCTSTR newValue); + CString get_WritePassword(); + void put_WritePassword(LPCTSTR newValue); + CString get_PasswordEncryptionProvider(); + CString get_PasswordEncryptionAlgorithm(); + long get_PasswordEncryptionKeyLength(); + void SetPasswordEncryptionOptions(VARIANT PasswordEncryptionProvider, VARIANT PasswordEncryptionAlgorithm, VARIANT PasswordEncryptionKeyLength, VARIANT PasswordEncryptionFileProperties); + BOOL get_PasswordEncryptionFileProperties(); + BOOL get_ReadOnlyRecommended(); + void put_ReadOnlyRecommended(BOOL newValue); + void Protect(VARIANT Password, VARIANT Structure, VARIANT Windows); + LPDISPATCH get_SmartTagOptions(); + void RecheckSmartTags(); + LPDISPATCH get_Permission(); + LPDISPATCH get_SharedWorkspace(); + LPDISPATCH get_Sync(); + void SendFaxOverInternet(VARIANT Recipients, VARIANT Subject, VARIANT ShowMessage); + LPDISPATCH get_XmlNamespaces(); + LPDISPATCH get_XmlMaps(); + long XmlImport(LPCTSTR Url, LPDISPATCH * ImportMap, VARIANT Overwrite, VARIANT Destination); + LPDISPATCH get_SmartDocument(); + LPDISPATCH get_DocumentLibraryVersions(); + BOOL get_InactiveListBorderVisible(); + void put_InactiveListBorderVisible(BOOL newValue); + BOOL get_DisplayInkComments(); + void put_DisplayInkComments(BOOL newValue); + long XmlImportXml(LPCTSTR Data, LPDISPATCH * ImportMap, VARIANT Overwrite, VARIANT Destination); + void SaveAsXMLData(LPCTSTR Filename, LPDISPATCH Map); + void ToggleFormsDesign(); + LPDISPATCH get_ContentTypeProperties(); + LPDISPATCH get_Connections(); + void RemoveDocumentInformation(long RemoveDocInfoType); + LPDISPATCH get_Signatures(); + void CheckInWithVersion(VARIANT SaveChanges, VARIANT Comments, VARIANT MakePublic, VARIANT VersionType); + LPDISPATCH get_ServerPolicy(); + void LockServerFile(); + LPDISPATCH get_DocumentInspectors(); + LPDISPATCH GetWorkflowTasks(); + LPDISPATCH GetWorkflowTemplates(); + void PrintOut(VARIANT From, VARIANT To, VARIANT Copies, VARIANT Preview, VARIANT ActivePrinter, VARIANT PrintToFile, VARIANT Collate, VARIANT PrToFileName, VARIANT IgnorePrintAreas); + LPDISPATCH get_ServerViewableItems(); + LPDISPATCH get_TableStyles(); + VARIANT get_DefaultTableStyle(); + void put_DefaultTableStyle(VARIANT newValue); + VARIANT get_DefaultPivotTableStyle(); + void put_DefaultPivotTableStyle(VARIANT newValue); + BOOL get_CheckCompatibility(); + void put_CheckCompatibility(BOOL newValue); + BOOL get_HasVBProject(); + LPDISPATCH get_CustomXMLParts(); + BOOL get_Final(); + void put_Final(BOOL newValue); + LPDISPATCH get_Research(); + LPDISPATCH get_Theme(); + void ApplyTheme(LPCTSTR Filename); + BOOL get_Excel8CompatibilityMode(); + BOOL get_ConnectionsDisabled(); + void EnableConnections(); + BOOL get_ShowPivotChartActiveFields(); + void put_ShowPivotChartActiveFields(BOOL newValue); + void ExportAsFixedFormat(long Type, VARIANT Filename, VARIANT Quality, VARIANT IncludeDocProperties, VARIANT IgnorePrintAreas, VARIANT From, VARIANT To, VARIANT OpenAfterPublish, VARIANT FixedFormatExtClassPtr); + LPDISPATCH get_IconSets(); + CString get_EncryptionProvider(); + void put_EncryptionProvider(LPCTSTR newValue); + BOOL get_DoNotPromptForConvert(); + void put_DoNotPromptForConvert(BOOL newValue); + BOOL get_ForceFullCalculation(); + void put_ForceFullCalculation(BOOL newValue); + void ProtectSharing(VARIANT Filename, VARIANT Password, VARIANT WriteResPassword, VARIANT ReadOnlyRecommended, VARIANT CreateBackup, VARIANT SharingPassword, VARIANT FileFormat); + LPDISPATCH get_SlicerCaches(); + LPDISPATCH get_ActiveSlicer(); + VARIANT get_DefaultSlicerStyle(); + void put_DefaultSlicerStyle(VARIANT newValue); + void Dummy26(); + void Dummy27(); + long get_AccuracyVersion(); + void put_AccuracyVersion(long newValue); + BOOL get_CaseSensitive(); + BOOL get_UseWholeCellCriteria(); + BOOL get_UseWildcards(); + LPDISPATCH get_PivotTables(); + LPDISPATCH get_Model(); + BOOL get_ChartDataPointTrack(); + void put_ChartDataPointTrack(BOOL newValue); + VARIANT get_DefaultTimelineStyle(); + void put_DefaultTimelineStyle(VARIANT newValue); + LPDISPATCH get_Queries(); + void CreateForecastSheet(LPDISPATCH Timeline, LPDISPATCH Values, VARIANT ForecastStart, VARIANT ForecastEnd, VARIANT ConfInt, VARIANT Seasonality, VARIANT DataCompletion, VARIANT Aggregation, VARIANT ChartType, VARIANT ShowStatsTable); +}; + +} // namespace MSO::Excel diff --git a/include/office/excel/EXLWorkbooks.h b/include/office/excel/EXLWorkbooks.h new file mode 100644 index 0000000..25177e3 --- /dev/null +++ b/include/office/excel/EXLWorkbooks.h @@ -0,0 +1,60 @@ +#pragma once +// EXLWorkbooks wrapper class + +#include "office/VariantableDispatch.hpp" +#include "office/MSCollection.hpp" + +namespace MSO::Excel { + class EXLWorkbook; + +class EXLWorkbooks : + public VariantableDispatch, + public MSCollection { +public: + EXLWorkbooks() = default; + EXLWorkbooks(LPDISPATCH pDispatch) : VariantableDispatch(pDispatch) {} + EXLWorkbooks(const EXLWorkbooks& dispatchSrc) : VariantableDispatch(dispatchSrc) {} + +public: + LPDISPATCH get_Application(); + long get_Creator(); + LPDISPATCH get_Parent(); + long get_Count(); + LPDISPATCH get_Item(VARIANT IndexType); + LPUNKNOWN get_NewEnum(); + LPDISPATCH get__Default(VARIANT IndexType); + + void Close(); + + void CheckOut(LPCTSTR Filename); + BOOL CanCheckOut(LPCTSTR Filename); + + EXLWorkbook Add(VARIANT Template); + + EXLWorkbook _Open(LPCTSTR Filename, VARIANT UpdateLinks, VARIANT ReadOnly, VARIANT Format, + VARIANT Password, VARIANT WriteResPassword, VARIANT IgnoreReadOnlyRecommended, VARIANT Origin, + VARIANT Delimiter, VARIANT Editable, VARIANT Notify, VARIANT Converter, VARIANT AddToMru); + + EXLWorkbook Open(LPCTSTR Filename, VARIANT UpdateLinks, VARIANT ReadOnly, VARIANT Format, + VARIANT Password, VARIANT WriteResPassword, VARIANT IgnoreReadOnlyRecommended, VARIANT Origin, + VARIANT Delimiter, VARIANT Editable, VARIANT Notify, VARIANT Converter, VARIANT AddToMru, VARIANT Local, VARIANT CorruptLoad); + + void __OpenText(LPCTSTR Filename, VARIANT Origin, VARIANT StartRow, VARIANT DataType, + long TextQualifier, VARIANT ConsecutiveDelimiter, VARIANT Tab, VARIANT Semicolon, VARIANT Comma, + VARIANT Space, VARIANT Other, VARIANT OtherChar, VARIANT FieldInfo, VARIANT TextVisualLayout); + + void _OpenText(LPCTSTR Filename, VARIANT Origin, VARIANT StartRow, VARIANT DataType, long TextQualifier, + VARIANT ConsecutiveDelimiter, VARIANT Tab, VARIANT Semicolon, VARIANT Comma, VARIANT Space, VARIANT Other, + VARIANT OtherChar, VARIANT FieldInfo, VARIANT TextVisualLayout, VARIANT DecimalSeparator, VARIANT ThousandsSeparator); + + void OpenText(LPCTSTR Filename, VARIANT Origin, VARIANT StartRow, VARIANT DataType, long TextQualifier, + VARIANT ConsecutiveDelimiter, VARIANT Tab, VARIANT Semicolon, VARIANT Comma, VARIANT Space, VARIANT Other, + VARIANT OtherChar, VARIANT FieldInfo, VARIANT TextVisualLayout, VARIANT DecimalSeparator, VARIANT ThousandsSeparator, + VARIANT TrailingMinusNumbers, VARIANT Local); + + LPDISPATCH OpenDatabase(LPCTSTR Filename, VARIANT CommandText, VARIANT CommandType, VARIANT BackgroundQuery, VARIANT ImportDataAs); + LPDISPATCH _OpenXML(LPCTSTR Filename, VARIANT Stylesheets); + LPDISPATCH OpenXML(LPCTSTR Filename, VARIANT Stylesheets, VARIANT LoadOption); +}; + +} // namespace MSO::Excel diff --git a/include/office/excel/EXLWorksheet.h b/include/office/excel/EXLWorksheet.h new file mode 100644 index 0000000..3209a9e --- /dev/null +++ b/include/office/excel/EXLWorksheet.h @@ -0,0 +1,164 @@ +#pragma once +// EXLWorksheet wrapper class + +#include "office/VariantableDispatch.hpp" + +namespace MSO::Excel { + class EXLRange; + +class EXLWorksheet : public VariantableDispatch { +public: + EXLWorksheet() = default; + EXLWorksheet(LPDISPATCH pDispatch) : VariantableDispatch(pDispatch) {} + EXLWorksheet(const EXLWorksheet& dispatchSrc) : VariantableDispatch(dispatchSrc) {} + +public: + EXLRange get_Cells(); + EXLRange get_Columns(); + EXLRange get_Rows(); + EXLRange get_UsedRange(); + + LPDISPATCH get_Application(); + long get_Creator(); + LPDISPATCH get_Parent(); + void Activate(); + void Copy(VARIANT Before, VARIANT After); + void Delete(); + CString get_CodeName(); + CString get__CodeName(); + void put__CodeName(LPCTSTR newValue); + long get_Index(); + void Move(VARIANT Before, VARIANT After); + CString get_Name(); + void put_Name(LPCTSTR newValue); + LPDISPATCH get_Next(); + CString get_OnDoubleClick(); + void put_OnDoubleClick(LPCTSTR newValue); + CString get_OnSheetActivate(); + void put_OnSheetActivate(LPCTSTR newValue); + CString get_OnSheetDeactivate(); + void put_OnSheetDeactivate(LPCTSTR newValue); + LPDISPATCH get_PageSetup(); + LPDISPATCH get_Previous(); + void __PrintOut(VARIANT From, VARIANT To, VARIANT Copies, VARIANT Preview, VARIANT ActivePrinter, VARIANT PrintToFile, VARIANT Collate); + void PrintPreview(VARIANT EnableChanges); + void _Protect(VARIANT Password, VARIANT DrawingObjects, VARIANT Contents, VARIANT Scenarios, VARIANT UserInterfaceOnly); + BOOL get_ProtectContents(); + BOOL get_ProtectDrawingObjects(); + BOOL get_ProtectionMode(); + BOOL get_ProtectScenarios(); + void _SaveAs(LPCTSTR Filename, VARIANT FileFormat, VARIANT Password, VARIANT WriteResPassword, VARIANT ReadOnlyRecommended, VARIANT CreateBackup, VARIANT AddToMru, VARIANT TextCodepage, VARIANT TextVisualLayout); + void Select(VARIANT Replace); + void Unprotect(VARIANT Password); + long get_Visible(); + void put_Visible(long newValue); + LPDISPATCH get_Shapes(); + BOOL get_TransitionExpEval(); + void put_TransitionExpEval(BOOL newValue); + LPDISPATCH Arcs(VARIANT IndexType); + BOOL get_AutoFilterMode(); + void put_AutoFilterMode(BOOL newValue); + void SetBackgroundPicture(LPCTSTR Filename); + LPDISPATCH Buttons(VARIANT IndexType); + void Calculate(); + BOOL get_EnableCalculation(); + void put_EnableCalculation(BOOL newValue); + LPDISPATCH ChartObjects(VARIANT IndexType); + LPDISPATCH CheckBoxes(VARIANT IndexType); + void CheckSpelling(VARIANT CustomDictionary, VARIANT IgnoreUppercase, VARIANT AlwaysSuggest, VARIANT SpellLang); + LPDISPATCH get_CircularReference(); + void ClearArrows(); + long get_ConsolidationFunction(); + VARIANT get_ConsolidationOptions(); + VARIANT get_ConsolidationSources(); + BOOL get_DisplayAutomaticPageBreaks(); + void put_DisplayAutomaticPageBreaks(BOOL newValue); + LPDISPATCH Drawings(VARIANT IndexType); + LPDISPATCH DrawingObjects(VARIANT IndexType); + LPDISPATCH DropDowns(VARIANT IndexType); + BOOL get_EnableAutoFilter(); + void put_EnableAutoFilter(BOOL newValue); + long get_EnableSelection(); + void put_EnableSelection(long newValue); + BOOL get_EnableOutlining(); + void put_EnableOutlining(BOOL newValue); + BOOL get_EnablePivotTable(); + void put_EnablePivotTable(BOOL newValue); + VARIANT Evaluate(VARIANT Name); + VARIANT _Evaluate(VARIANT Name); + BOOL get_FilterMode(); + void ResetAllPageBreaks(); + LPDISPATCH GroupBoxes(VARIANT IndexType); + LPDISPATCH GroupObjects(VARIANT IndexType); + LPDISPATCH Labels(VARIANT IndexType); + LPDISPATCH Lines(VARIANT IndexType); + LPDISPATCH ListBoxes(VARIANT IndexType); + LPDISPATCH get_Names(); + LPDISPATCH OLEObjects(VARIANT IndexType); + CString get_OnCalculate(); + void put_OnCalculate(LPCTSTR newValue); + CString get_OnData(); + void put_OnData(LPCTSTR newValue); + CString get_OnEntry(); + void put_OnEntry(LPCTSTR newValue); + LPDISPATCH OptionButtons(VARIANT IndexType); + LPDISPATCH get_Outline(); + LPDISPATCH Ovals(VARIANT IndexType); + void Paste(VARIANT Destination, VARIANT Link); + void _PasteSpecial(VARIANT Format, VARIANT Link, VARIANT DisplayAsIcon, VARIANT IconFileName, VARIANT IconIndex, VARIANT IconLabel); + LPDISPATCH Pictures(VARIANT IndexType); + LPDISPATCH PivotTables(VARIANT IndexType); + LPDISPATCH PivotTableWizard(VARIANT SourceType, VARIANT DataStream, VARIANT TableDestination, VARIANT TableName, VARIANT RowGrand, VARIANT ColumnGrand, VARIANT SaveData, VARIANT HasAutoFormat, VARIANT AutoPage, VARIANT Reserved, VARIANT BackgroundQuery, VARIANT OptimizeCache, VARIANT PageFieldOrder, VARIANT PageFieldWrapCount, VARIANT ReadData, VARIANT Connection); + LPDISPATCH get_Range(VARIANT Cell1, VARIANT Cell2); + LPDISPATCH Rectangles(VARIANT IndexType); + LPDISPATCH Scenarios(VARIANT IndexType); + CString get_ScrollArea(); + void put_ScrollArea(LPCTSTR newValue); + LPDISPATCH ScrollBars(VARIANT IndexType); + void ShowAllData(); + void ShowDataForm(); + LPDISPATCH Spinners(VARIANT IndexType); + double get_StandardHeight(); + double get_StandardWidth(); + void put_StandardWidth(double newValue); + LPDISPATCH TextBoxes(VARIANT IndexType); + BOOL get_TransitionFormEntry(); + void put_TransitionFormEntry(BOOL newValue); + long get_Type(); + LPDISPATCH get_HPageBreaks(); + LPDISPATCH get_VPageBreaks(); + LPDISPATCH get_QueryTables(); + BOOL get_DisplayPageBreaks(); + void put_DisplayPageBreaks(BOOL newValue); + LPDISPATCH get_Comments(); + LPDISPATCH get_Hyperlinks(); + void ClearCircles(); + void CircleInvalid(); + long get__DisplayRightToLeft(); + void put__DisplayRightToLeft(long newValue); + LPDISPATCH get_AutoFilter(); + BOOL get_DisplayRightToLeft(); + void put_DisplayRightToLeft(BOOL newValue); + LPDISPATCH get_Scripts(); + void _PrintOut(VARIANT From, VARIANT To, VARIANT Copies, VARIANT Preview, VARIANT ActivePrinter, VARIANT PrintToFile, VARIANT Collate, VARIANT PrToFileName); + void _CheckSpelling(VARIANT CustomDictionary, VARIANT IgnoreUppercase, VARIANT AlwaysSuggest, VARIANT SpellLang, VARIANT IgnoreFinalYaa, VARIANT SpellScript); + LPDISPATCH get_Tab(); + LPDISPATCH get_MailEnvelope(); + void SaveAs(LPCTSTR Filename, VARIANT FileFormat, VARIANT Password, VARIANT WriteResPassword, VARIANT ReadOnlyRecommended, VARIANT CreateBackup, VARIANT AddToMru, VARIANT TextCodepage, VARIANT TextVisualLayout, VARIANT Local); + LPDISPATCH get_CustomProperties(); + LPDISPATCH get_SmartTags(); + LPDISPATCH get_Protection(); + void PasteSpecial(VARIANT Format, VARIANT Link, VARIANT DisplayAsIcon, VARIANT IconFileName, VARIANT IconIndex, VARIANT IconLabel, VARIANT NoHTMLFormatting); + void Protect(VARIANT Password, VARIANT DrawingObjects, VARIANT Contents, VARIANT Scenarios, VARIANT UserInterfaceOnly, VARIANT AllowFormattingCells, VARIANT AllowFormattingColumns, VARIANT AllowFormattingRows, VARIANT AllowInsertingColumns, VARIANT AllowInsertingRows, VARIANT AllowInsertingHyperlinks, VARIANT AllowDeletingColumns, VARIANT AllowDeletingRows, VARIANT AllowSorting, VARIANT AllowFiltering, VARIANT AllowUsingPivotTables); + LPDISPATCH get_ListObjects(); + LPDISPATCH XmlDataQuery(LPCTSTR XPath, VARIANT SelectionNamespaces, VARIANT Map); + LPDISPATCH XmlMapQuery(LPCTSTR XPath, VARIANT SelectionNamespaces, VARIANT Map); + void PrintOut(VARIANT From, VARIANT To, VARIANT Copies, VARIANT Preview, VARIANT ActivePrinter, VARIANT PrintToFile, VARIANT Collate, VARIANT PrToFileName, VARIANT IgnorePrintAreas); + BOOL get_EnableFormatConditionsCalculation(); + void put_EnableFormatConditionsCalculation(BOOL newValue); + LPDISPATCH get_Sort(); + void ExportAsFixedFormat(long Type, VARIANT Filename, VARIANT Quality, VARIANT IncludeDocProperties, VARIANT IgnorePrintAreas, VARIANT From, VARIANT To, VARIANT OpenAfterPublish, VARIANT FixedFormatExtClassPtr); + long get_PrintedCommentPages(); +}; + +} // namespace MSO::Excel diff --git a/include/office/excel/EXLWorksheets.h b/include/office/excel/EXLWorksheets.h new file mode 100644 index 0000000..e5c7679 --- /dev/null +++ b/include/office/excel/EXLWorksheets.h @@ -0,0 +1,46 @@ +#pragma once +// EXLWorksheets wrapper class + +#include "office/MSCollection.hpp" +#include "office/VariantableDispatch.hpp" + +namespace MSO::Excel { + class EXLWorksheet; + +class EXLWorksheets : + public VariantableDispatch, + public MSCollection { +public: + EXLWorksheets() = default; + EXLWorksheets(LPDISPATCH pDispatch) : VariantableDispatch(pDispatch) {} + EXLWorksheets(const EXLWorksheets& dispatchSrc) : VariantableDispatch(dispatchSrc) {} + +public: + EXLWorksheet get_Item(VARIANT IndexType); + size_type get_Count(); + EXLWorksheet Add(const EXLWorksheet& Before, const EXLWorksheet& After, VARIANT Count, VARIANT Type); + EXLWorksheet Add2(const EXLWorksheet& Before, const EXLWorksheet& After, VARIANT Count, VARIANT NewLayout); + void Copy(const EXLWorksheet& Before, const EXLWorksheet& After); + void Move(const EXLWorksheet& Before, const EXLWorksheet& After); + + VARIANT get_Visible(); + void put_Visible(VARIANT newValue); + + void Delete(); + + LPDISPATCH get_Application(); + long get_Creator(); + LPDISPATCH get_Parent(); + void FillAcrossSheets(LPDISPATCH Range, long Type); + LPUNKNOWN get_NewEnum(); + void __PrintOut(VARIANT From, VARIANT To, VARIANT Copies, VARIANT Preview, VARIANT ActivePrinter, VARIANT PrintToFile, VARIANT Collate); + void PrintPreview(VARIANT EnableChanges); + void Select(VARIANT Replace); + LPDISPATCH get_HPageBreaks(); + LPDISPATCH get_VPageBreaks(); + LPDISPATCH get__Default(VARIANT IndexType); + void _PrintOut(VARIANT From, VARIANT To, VARIANT Copies, VARIANT Preview, VARIANT ActivePrinter, VARIANT PrintToFile, VARIANT Collate, VARIANT PrToFileName); + void PrintOut(VARIANT From, VARIANT To, VARIANT Copies, VARIANT Preview, VARIANT ActivePrinter, VARIANT PrintToFile, VARIANT Collate, VARIANT PrToFileName, VARIANT IgnorePrintAreas); +}; + +} // namespace MSO::Excel diff --git a/include/office/word/WApplication.h b/include/office/word/WApplication.h new file mode 100644 index 0000000..7a49f05 --- /dev/null +++ b/include/office/word/WApplication.h @@ -0,0 +1,262 @@ +#pragma once +// WApplication wrapper class + +#include "office/VariantableDispatch.hpp" + +namespace MSO::Word { + class WApplication; + +class WApplication : public VariantableDispatch { +public: + WApplication() = default; + WApplication(LPDISPATCH pDispatch) : VariantableDispatch(pDispatch) {} + WApplication(const WApplication& dispatchSrc) : VariantableDispatch(dispatchSrc) {} + +public: + WApplication get_Application(); + long get_Creator(); + LPDISPATCH get_Parent(); + CString get_Name(); + LPDISPATCH get_Documents(); + LPDISPATCH get_Windows(); + LPDISPATCH get_ActiveDocument(); + LPDISPATCH get_ActiveWindow(); + LPDISPATCH get_Selection(); + LPDISPATCH get_WordBasic(); + LPDISPATCH get_RecentFiles(); + LPDISPATCH get_NormalTemplate(); + LPDISPATCH get_System(); + LPDISPATCH get_AutoCorrect(); + LPDISPATCH get_FontNames(); + LPDISPATCH get_LandscapeFontNames(); + LPDISPATCH get_PortraitFontNames(); + LPDISPATCH get_Languages(); + LPDISPATCH get_Assistant(); + LPDISPATCH get_Browser(); + LPDISPATCH get_FileConverters(); + LPDISPATCH get_MailingLabel(); + LPDISPATCH get_Dialogs(); + LPDISPATCH get_CaptionLabels(); + LPDISPATCH get_AutoCaptions(); + LPDISPATCH get_AddIns(); + BOOL get_Visible(); + void put_Visible(BOOL newValue); + CString get_Version(); + BOOL get_ScreenUpdating(); + void put_ScreenUpdating(BOOL newValue); + BOOL get_PrintPreview(); + void put_PrintPreview(BOOL newValue); + LPDISPATCH get_Tasks(); + BOOL get_DisplayStatusBar(); + void put_DisplayStatusBar(BOOL newValue); + BOOL get_SpecialMode(); + long get_UsableWidth(); + long get_UsableHeight(); + BOOL get_MathCoprocessorAvailable(); + BOOL get_MouseAvailable(); + VARIANT get_International(long IndexType); + CString get_Build(); + BOOL get_CapsLock(); + BOOL get_NumLock(); + CString get_UserName(); + void put_UserName(LPCTSTR newValue); + CString get_UserInitials(); + void put_UserInitials(LPCTSTR newValue); + CString get_UserAddress(); + void put_UserAddress(LPCTSTR newValue); + LPDISPATCH get_MacroContainer(); + BOOL get_DisplayRecentFiles(); + void put_DisplayRecentFiles(BOOL newValue); + LPDISPATCH get_CommandBars(); + LPDISPATCH get_SynonymInfo(LPCTSTR MSWord, VARIANT * LanguageID); + LPDISPATCH get_VBE(); + CString get_DefaultSaveFormat(); + void put_DefaultSaveFormat(LPCTSTR newValue); + LPDISPATCH get_ListGalleries(); + CString get_ActivePrinter(); + void put_ActivePrinter(LPCTSTR newValue); + LPDISPATCH get_Templates(); + LPDISPATCH get_CustomizationContext(); + void put_CustomizationContext(LPDISPATCH newValue); + LPDISPATCH get_KeyBindings(); + LPDISPATCH get_KeysBoundTo(long KeyCategory, LPCTSTR Command, VARIANT * CommandParameter); + LPDISPATCH get_FindKey(long KeyCode, VARIANT * KeyCode2); + CString get_Caption(); + void put_Caption(LPCTSTR newValue); + CString get_Path(); + BOOL get_DisplayScrollBars(); + void put_DisplayScrollBars(BOOL newValue); + CString get_StartupPath(); + void put_StartupPath(LPCTSTR newValue); + long get_BackgroundSavingStatus(); + long get_BackgroundPrintingStatus(); + long get_Left(); + void put_Left(long newValue); + long get_Top(); + void put_Top(long newValue); + long get_Width(); + void put_Width(long newValue); + long get_Height(); + void put_Height(long newValue); + long get_WindowState(); + void put_WindowState(long newValue); + BOOL get_DisplayAutoCompleteTips(); + void put_DisplayAutoCompleteTips(BOOL newValue); + LPDISPATCH get_Options(); + long get_DisplayAlerts(); + void put_DisplayAlerts(long newValue); + LPDISPATCH get_CustomDictionaries(); + CString get_PathSeparator(); + void put_StatusBar(LPCTSTR newValue); + BOOL get_MAPIAvailable(); + BOOL get_DisplayScreenTips(); + void put_DisplayScreenTips(BOOL newValue); + long get_EnableCancelKey(); + void put_EnableCancelKey(long newValue); + BOOL get_UserControl(); + LPDISPATCH get_FileSearch(); + long get_MailSystem(); + CString get_DefaultTableSeparator(); + void put_DefaultTableSeparator(LPCTSTR newValue); + BOOL get_ShowVisualBasicEditor(); + void put_ShowVisualBasicEditor(BOOL newValue); + CString get_BrowseExtraFileTypes(); + void put_BrowseExtraFileTypes(LPCTSTR newValue); + BOOL get_IsObjectValid(LPDISPATCH Object); + LPDISPATCH get_HangulHanjaDictionaries(); + LPDISPATCH get_MailMessage(); + BOOL get_FocusInMailHeader(); + void Quit(VARIANT * SaveChanges, VARIANT * OriginalFormat, VARIANT * RouteDocument); + void ScreenRefresh(); + void PrintOutOld(VARIANT * Background, VARIANT * Append, VARIANT * Range, VARIANT * OutputFileName, VARIANT * From, VARIANT * To, VARIANT * Item, VARIANT * Copies, VARIANT * Pages, VARIANT * PageType, VARIANT * PrintToFile, VARIANT * Collate, VARIANT * FileName, VARIANT * ActivePrinterMacGX, VARIANT * ManualDuplexPrint); + void LookupNameProperties(LPCTSTR Name); + void SubstituteFont(LPCTSTR UnavailableFont, LPCTSTR SubstituteFont); + BOOL Repeat(VARIANT * Times); + void DDEExecute(long Channel, LPCTSTR Command); + long DDEInitiate(LPCTSTR App, LPCTSTR Topic); + void DDEPoke(long Channel, LPCTSTR Item, LPCTSTR Data); + CString DDERequest(long Channel, LPCTSTR Item); + void DDETerminate(long Channel); + void DDETerminateAll(); + long BuildKeyCode(long Arg1, VARIANT * Arg2, VARIANT * Arg3, VARIANT * Arg4); + CString KeyString(long KeyCode, VARIANT * KeyCode2); + void OrganizerCopy(LPCTSTR src, LPCTSTR Destination, LPCTSTR Name, long Object); + void OrganizerDelete(LPCTSTR src, LPCTSTR Name, long Object); + void OrganizerRename(LPCTSTR src, LPCTSTR Name, LPCTSTR NewName, long Object); + void AddAddress(SAFEARRAY * * TagID, SAFEARRAY * * Value); + CString GetAddress(VARIANT * Name, VARIANT * AddressProperties, VARIANT * UseAutoText, VARIANT * DisplaySelectDialog, VARIANT * SelectDialog, VARIANT * CheckNamesDialog, VARIANT * RecentAddressesChoice, VARIANT * UpdateRecentAddresses); + BOOL CheckGrammar(LPCTSTR String); + BOOL CheckSpelling(LPCTSTR MSWord, VARIANT * CustomDictionary, VARIANT * IgnoreUppercase, VARIANT * MainDictionary, VARIANT * CustomDictionary2, VARIANT * CustomDictionary3, VARIANT * CustomDictionary4, VARIANT * CustomDictionary5, VARIANT * CustomDictionary6, VARIANT * CustomDictionary7, VARIANT * CustomDictionary8, VARIANT * CustomDictionary9, VARIANT * CustomDictionary10); + void ResetIgnoreAll(); + LPDISPATCH GetSpellingSuggestions(LPCTSTR MSWord, VARIANT * CustomDictionary, VARIANT * IgnoreUppercase, VARIANT * MainDictionary, VARIANT * SuggestionMode, VARIANT * CustomDictionary2, VARIANT * CustomDictionary3, VARIANT * CustomDictionary4, VARIANT * CustomDictionary5, VARIANT * CustomDictionary6, VARIANT * CustomDictionary7, VARIANT * CustomDictionary8, VARIANT * CustomDictionary9, VARIANT * CustomDictionary10); + void GoBack(); + void Help(VARIANT * HelpType); + void AutomaticChange(); + void ShowMe(); + void HelpTool(); + LPDISPATCH NewWindow(); + void ListCommands(BOOL ListAllCommands); + void ShowClipboard(); + void OnTime(VARIANT * When, LPCTSTR Name, VARIANT * Tolerance); + void NextLetter(); + short MountVolume(LPCTSTR Zone, LPCTSTR Server, LPCTSTR Volume, VARIANT * User, VARIANT * UserPassword, VARIANT * VolumePassword); + CString CleanString(LPCTSTR String); + void SendFax(); + void ChangeFileOpenDirectory(LPCTSTR Path); + void RunOld(LPCTSTR MacroName); + void GoForward(); + void Move(long Left, long Top); + void Resize(long Width, long Height); + float InchesToPoints(float Inches); + float CentimetersToPoints(float Centimeters); + float MillimetersToPoints(float Millimeters); + float PicasToPoints(float Picas); + float LinesToPoints(float Lines); + float PointsToInches(float Points); + float PointsToCentimeters(float Points); + float PointsToMillimeters(float Points); + float PointsToPicas(float Points); + float PointsToLines(float Points); + void Activate(); + float PointsToPixels(float Points, VARIANT * fVertical); + float PixelsToPoints(float Pixels, VARIANT * fVertical); + void KeyboardLatin(); + void KeyboardBidi(); + void ToggleKeyboard(); + long Keyboard(long LangId); + CString ProductCode(); + LPDISPATCH DefaultWebOptions(); + void DiscussionSupport(VARIANT * Range, VARIANT * cid, VARIANT * piCSE); + void SetDefaultTheme(LPCTSTR Name, long DocumentType); + CString GetDefaultTheme(long DocumentType); + LPDISPATCH get_EmailOptions(); + long get_Language(); + LPDISPATCH get_COMAddIns(); + BOOL get_CheckLanguage(); + void put_CheckLanguage(BOOL newValue); + LPDISPATCH get_LanguageSettings(); + BOOL get_Dummy1(); + LPDISPATCH get_AnswerWizard(); + long get_FeatureInstall(); + void put_FeatureInstall(long newValue); + void PrintOut2000(VARIANT * Background, VARIANT * Append, VARIANT * Range, VARIANT * OutputFileName, VARIANT * From, VARIANT * To, VARIANT * Item, VARIANT * Copies, VARIANT * Pages, VARIANT * PageType, VARIANT * PrintToFile, VARIANT * Collate, VARIANT * FileName, VARIANT * ActivePrinterMacGX, VARIANT * ManualDuplexPrint, VARIANT * PrintZoomColumn, VARIANT * PrintZoomRow, VARIANT * PrintZoomPaperWidth, VARIANT * PrintZoomPaperHeight); + VARIANT Run(LPCTSTR MacroName, VARIANT * varg1, VARIANT * varg2, VARIANT * varg3, VARIANT * varg4, VARIANT * varg5, VARIANT * varg6, VARIANT * varg7, VARIANT * varg8, VARIANT * varg9, VARIANT * varg10, VARIANT * varg11, VARIANT * varg12, VARIANT * varg13, VARIANT * varg14, VARIANT * varg15, VARIANT * varg16, VARIANT * varg17, VARIANT * varg18, VARIANT * varg19, VARIANT * varg20, VARIANT * varg21, VARIANT * varg22, VARIANT * varg23, VARIANT * varg24, VARIANT * varg25, VARIANT * varg26, VARIANT * varg27, VARIANT * varg28, VARIANT * varg29, VARIANT * varg30); + void PrintOut(VARIANT * Background, VARIANT * Append, VARIANT * Range, VARIANT * OutputFileName, VARIANT * From, VARIANT * To, VARIANT * Item, VARIANT * Copies, VARIANT * Pages, VARIANT * PageType, VARIANT * PrintToFile, VARIANT * Collate, VARIANT * FileName, VARIANT * ActivePrinterMacGX, VARIANT * ManualDuplexPrint, VARIANT * PrintZoomColumn, VARIANT * PrintZoomRow, VARIANT * PrintZoomPaperWidth, VARIANT * PrintZoomPaperHeight); + long get_AutomationSecurity(); + void put_AutomationSecurity(long newValue); + LPDISPATCH get_FileDialog(long FileDialogType); + CString get_EmailTemplate(); + void put_EmailTemplate(LPCTSTR newValue); + BOOL get_ShowWindowsInTaskbar(); + void put_ShowWindowsInTaskbar(BOOL newValue); + LPDISPATCH get_NewDocument(); + BOOL get_ShowStartupDialog(); + void put_ShowStartupDialog(BOOL newValue); + LPDISPATCH get_AutoCorrectEmail(); + LPDISPATCH get_TaskPanes(); + BOOL get_DefaultLegalBlackline(); + void put_DefaultLegalBlackline(BOOL newValue); + BOOL Dummy2(); + LPDISPATCH get_SmartTagRecognizers(); + LPDISPATCH get_SmartTagTypes(); + LPDISPATCH get_XMLNamespaces(); + void PutFocusInMailHeader(); + BOOL get_ArbitraryXMLSupportAvailable(); + CString get_BuildFull(); + CString get_BuildFeatureCrew(); + void LoadMasterList(LPCTSTR FileName); + LPDISPATCH CompareDocuments(LPDISPATCH OriginalDocument, LPDISPATCH RevisedDocument, long Destination, long Granularity, BOOL CompareFormatting, BOOL CompareCaseChanges, BOOL CompareWhitespace, BOOL CompareTables, BOOL CompareHeaders, BOOL CompareFootnotes, BOOL CompareTextboxes, BOOL CompareFields, BOOL CompareComments, BOOL CompareMoves, LPCTSTR RevisedAuthor, BOOL IgnoreAllComparisonWarnings); + LPDISPATCH MergeDocuments(LPDISPATCH OriginalDocument, LPDISPATCH RevisedDocument, long Destination, long Granularity, BOOL CompareFormatting, BOOL CompareCaseChanges, BOOL CompareWhitespace, BOOL CompareTables, BOOL CompareHeaders, BOOL CompareFootnotes, BOOL CompareTextboxes, BOOL CompareFields, BOOL CompareComments, BOOL CompareMoves, LPCTSTR OriginalAuthor, LPCTSTR RevisedAuthor, long FormatFrom); + LPDISPATCH get_Bibliography(); + BOOL get_ShowStylePreviews(); + void put_ShowStylePreviews(BOOL newValue); + BOOL get_RestrictLinkedStyles(); + void put_RestrictLinkedStyles(BOOL newValue); + LPDISPATCH get_OMathAutoCorrect(); + BOOL get_DisplayDocumentInformationPanel(); + void put_DisplayDocumentInformationPanel(BOOL newValue); + LPDISPATCH get_Assistance(); + BOOL get_OpenAttachmentsInFullScreen(); + void put_OpenAttachmentsInFullScreen(BOOL newValue); + long get_ActiveEncryptionSession(); + BOOL get_DontResetInsertionPointProperties(); + void put_DontResetInsertionPointProperties(BOOL newValue); + LPDISPATCH get_SmartArtLayouts(); + LPDISPATCH get_SmartArtQuickStyles(); + LPDISPATCH get_SmartArtColors(); + void ThreeWayMerge(LPDISPATCH LocalDocument, LPDISPATCH ServerDocument, LPDISPATCH BaseDocument, BOOL FavorSource); + void Dummy4(); + LPDISPATCH get_UndoRecord(); + LPDISPATCH get_PickerDialog(); + LPDISPATCH get_ProtectedViewWindows(); + LPDISPATCH get_ActiveProtectedViewWindow(); + BOOL get_IsSandboxed(); + long get_FileValidation(); + void put_FileValidation(long newValue); + BOOL get_ChartDataPointTrack(); + void put_ChartDataPointTrack(BOOL newValue); + BOOL get_ShowAnimation(); + void put_ShowAnimation(BOOL newValue); +}; + +} // namespace MSO::Word diff --git a/include/office/word/WBookmark.h b/include/office/word/WBookmark.h new file mode 100644 index 0000000..3ba69b2 --- /dev/null +++ b/include/office/word/WBookmark.h @@ -0,0 +1,34 @@ +#pragma once +// WBookmark wrapper class + +#include "office/VariantableDispatch.hpp" + +namespace MSO::Word { + class WApplication; + class WRange; + +class WBookmark : public VariantableDispatch { +public: + WBookmark() = default; + WBookmark(LPDISPATCH pDispatch) : VariantableDispatch(pDispatch) {} + WBookmark(const WBookmark& dispatchSrc) : VariantableDispatch(dispatchSrc) {} + +public: + CString get_Name(); + WRange get_Range(); + BOOL get_Empty(); + long get_Start(); + void put_Start(long newValue); + long get_End(); + void put_End(long newValue); + BOOL get_Column(); + long get_StoryType(); + WApplication get_Application(); + long get_Creator(); + LPDISPATCH get_Parent(); + void Select(); + void Delete(); + LPDISPATCH Copy(LPCTSTR Name); +}; + +} // namespace MSO::Word diff --git a/include/office/word/WBookmarks.h b/include/office/word/WBookmarks.h new file mode 100644 index 0000000..af08826 --- /dev/null +++ b/include/office/word/WBookmarks.h @@ -0,0 +1,34 @@ +#pragma once +// WBookmarks wrapper class + +#include "office/VariantableDispatch.hpp" +#include "office/MSCollection.hpp" + +namespace MSO::Word { + class WBookmark; + class WApplication; + +class WBookmarks : + public VariantableDispatch, + public MSCollection { +public: + WBookmarks() = default; + WBookmarks(LPDISPATCH pDispatch) : VariantableDispatch(pDispatch) {} + WBookmarks(const WBookmarks& dispatchSrc) : VariantableDispatch(dispatchSrc) {} + +public: + LPUNKNOWN get_NewEnum(); + long get_Count(); + long get_DefaultSorting(); + void put_DefaultSorting(long newValue); + BOOL get_ShowHidden(); + void put_ShowHidden(BOOL newValue); + WApplication get_Application(); + long get_Creator(); + LPDISPATCH get_Parent(); + WBookmark get_Item(VARIANT IndexType); + WBookmark Add(LPCTSTR Name, VARIANT * Range); + BOOL Exists(LPCTSTR Name); +}; + +} // namespace MSO::Word diff --git a/include/office/word/WCell.h b/include/office/word/WCell.h new file mode 100644 index 0000000..adce0b3 --- /dev/null +++ b/include/office/word/WCell.h @@ -0,0 +1,70 @@ +#pragma once +// WCell wrapper class + +#include "office/VariantableDispatch.hpp" + +namespace MSO::Word { + class WApplication; + class WRange; + class WColumn; + class WRow; + +class WCell : public VariantableDispatch { +public: + WCell() = default; + WCell(LPDISPATCH pDispatch) : VariantableDispatch(pDispatch) {} + WCell(const WCell& dispatchSrc) : VariantableDispatch(dispatchSrc) {} + +public: + WRange get_Range(); + WApplication get_Application(); + long get_Creator(); + LPDISPATCH get_Parent(); + long get_RowIndex(); + long get_ColumnIndex(); + float get_Width(); + void put_Width(float newValue); + float get_Height(); + void put_Height(float newValue); + long get_HeightRule(); + void put_HeightRule(long newValue); + long get_VerticalAlignment(); + void put_VerticalAlignment(long newValue); + WColumn get_Column(); + WRow get_Row(); + LPDISPATCH get_Next(); + LPDISPATCH get_Previous(); + LPDISPATCH get_Shading(); + LPDISPATCH get_Borders(); + void put_Borders(LPDISPATCH newValue); + void Select(); + void Delete(VARIANT * ShiftCells); + void Formula(VARIANT * Formula, VARIANT * NumFormat); + void SetWidth(float ColumnWidth, long RulerStyle); + void SetHeight(VARIANT * RowHeight, long HeightRule); + void Merge(LPDISPATCH MergeTo); + void Split(VARIANT * NumRows, VARIANT * NumColumns); + void AutoSum(); + LPDISPATCH get_Tables(); + long get_NestingLevel(); + BOOL get_WordWrap(); + void put_WordWrap(BOOL newValue); + float get_PreferredWidth(); + void put_PreferredWidth(float newValue); + BOOL get_FitText(); + void put_FitText(BOOL newValue); + float get_TopPadding(); + void put_TopPadding(float newValue); + float get_BottomPadding(); + void put_BottomPadding(float newValue); + float get_LeftPadding(); + void put_LeftPadding(float newValue); + float get_RightPadding(); + void put_RightPadding(float newValue); + CString get_ID(); + void put_ID(LPCTSTR newValue); + long get_PreferredWidthType(); + void put_PreferredWidthType(long newValue); +}; + +} // namespace MSO::Word diff --git a/include/office/word/WColumn.h b/include/office/word/WColumn.h new file mode 100644 index 0000000..2cfa417 --- /dev/null +++ b/include/office/word/WColumn.h @@ -0,0 +1,42 @@ +#pragma once +// WColumn wrapper class + +#include "office/VariantableDispatch.hpp" + +namespace MSO::Word { + +class WColumn : public VariantableDispatch { +public: + WColumn() = default; + WColumn(LPDISPATCH pDispatch) : VariantableDispatch(pDispatch) {} + WColumn(const WColumn& dispatchSrc) : VariantableDispatch(dispatchSrc) {} + +public: + LPDISPATCH get_Application(); + long get_Creator(); + LPDISPATCH get_Parent(); + float get_Width(); + void put_Width(float newValue); + BOOL get_IsFirst(); + BOOL get_IsLast(); + long get_Index(); + LPDISPATCH get_Cells(); + LPDISPATCH get_Borders(); + void put_Borders(LPDISPATCH newValue); + LPDISPATCH get_Shading(); + LPDISPATCH get_Next(); + LPDISPATCH get_Previous(); + void Select(); + void Delete(); + void SetWidth(float ColumnWidth, long RulerStyle); + void AutoFit(); + void SortOld(VARIANT * ExcludeHeader, VARIANT * SortFieldType, VARIANT * SortOrder, VARIANT * CaseSensitive, VARIANT * LanguageID); + void Sort(VARIANT * ExcludeHeader, VARIANT * SortFieldType, VARIANT * SortOrder, VARIANT * CaseSensitive, VARIANT * BidiSort, VARIANT * IgnoreThe, VARIANT * IgnoreKashida, VARIANT * IgnoreDiacritics, VARIANT * IgnoreHe, VARIANT * LanguageID); + long get_NestingLevel(); + float get_PreferredWidth(); + void put_PreferredWidth(float newValue); + long get_PreferredWidthType(); + void put_PreferredWidthType(long newValue); +}; + +} // namespace MSO::Word diff --git a/include/office/word/WColumns.h b/include/office/word/WColumns.h new file mode 100644 index 0000000..ee9c00f --- /dev/null +++ b/include/office/word/WColumns.h @@ -0,0 +1,46 @@ +#pragma once +// WColumns wrapper class + +#include "office/VariantableDispatch.hpp" +#include "office/MSCollection.hpp" + +namespace MSO::Word { + class WColumn; + class WApplication; + +class WColumns : + public VariantableDispatch, + public MSCollection { +public: + WColumns() = default; + WColumns(LPDISPATCH pDispatch) : VariantableDispatch(pDispatch) {} + WColumns(const WColumns& dispatchSrc) : VariantableDispatch(dispatchSrc) {} + +public: + LPUNKNOWN get_NewEnum(); + long get_Count(); + WApplication get_Application(); + long get_Creator(); + LPDISPATCH get_Parent(); + WColumn get_First(); + WColumn get_Last(); + float get_Width(); + void put_Width(float newValue); + LPDISPATCH get_Borders(); + void put_Borders(LPDISPATCH newValue); + LPDISPATCH get_Shading(); + WColumn get_Item(long IndexType); + WColumn Add(VARIANT * BeforeColumn); + void Select(); + void Delete(); + void SetWidth(float ColumnWidth, long RulerStyle); + void AutoFit(); + void DistributeWidth(); + long get_NestingLevel(); + float get_PreferredWidth(); + void put_PreferredWidth(float newValue); + long get_PreferredWidthType(); + void put_PreferredWidthType(long newValue); +}; + +} // namespace MSO::Word diff --git a/include/office/word/WComment.h b/include/office/word/WComment.h new file mode 100644 index 0000000..8dc12a8 --- /dev/null +++ b/include/office/word/WComment.h @@ -0,0 +1,40 @@ +#pragma once +// WComment wrapper class + +#include "office/VariantableDispatch.hpp" + +namespace MSO::Word { + +class WComment : public VariantableDispatch { +public: + WComment() = default; + WComment(LPDISPATCH pDispatch) : VariantableDispatch(pDispatch) {} + WComment(const WComment& dispatchSrc) : VariantableDispatch(dispatchSrc) {} + +public: + LPDISPATCH get_Application(); + long get_Creator(); + LPDISPATCH get_Parent(); + LPDISPATCH get_Range(); + LPDISPATCH get_Reference(); + LPDISPATCH get_Scope(); + long get_Index(); + CString get_Author(); + void put_Author(LPCTSTR newValue); + CString get_Initial(); + void put_Initial(LPCTSTR newValue); + BOOL get_ShowTip(); + void put_ShowTip(BOOL newValue); + void Delete(); + void Edit(); + DATE get_Date(); + BOOL get_IsInk(); + BOOL get_Done(); + void put_Done(BOOL newValue); + LPDISPATCH get_Ancestor(); + LPDISPATCH get_Contact(); + void DeleteRecursively(); + LPDISPATCH get_Replies(); +}; + +} // namespace MSO::Word diff --git a/include/office/word/WComments.h b/include/office/word/WComments.h new file mode 100644 index 0000000..8323461 --- /dev/null +++ b/include/office/word/WComments.h @@ -0,0 +1,31 @@ +#pragma once +// WComments wrapper class + +#include "office/VariantableDispatch.hpp" +#include "office/MSCollection.hpp" + +namespace MSO::Word { + class WRange; + class WComment; + +class WComments : + public VariantableDispatch, + public MSCollection { +public: + WComments() = default; + WComments(LPDISPATCH pDispatch) : VariantableDispatch(pDispatch) {} + WComments(const WComments& dispatchSrc) : VariantableDispatch(dispatchSrc) {} + +public: + LPUNKNOWN get_NewEnum(); + long get_Count(); + LPDISPATCH get_Application(); + long get_Creator(); + LPDISPATCH get_Parent(); + CString get_ShowBy(); + void put_ShowBy(LPCTSTR newValue); + LPDISPATCH get_Item(long IndexType); + LPDISPATCH Add(WRange Range, VARIANT * Text); +}; + +} // namespace MSO::Word diff --git a/include/office/word/WDocument.h b/include/office/word/WDocument.h new file mode 100644 index 0000000..20eb87f --- /dev/null +++ b/include/office/word/WDocument.h @@ -0,0 +1,457 @@ +#pragma once +// WDocument wrapper class + +#include "office/VariantableDispatch.hpp" + +namespace MSO::Word { + class WTables; + class WBookmarks; + class WApplication; + +class WDocument : public VariantableDispatch { +public: + WDocument() = default; + WDocument(LPDISPATCH pDispatch) : VariantableDispatch(pDispatch) {} + WDocument(const WDocument& dispatchSrc) : VariantableDispatch(dispatchSrc) {} + +public: + CString get_Name(); + WApplication get_Application(); + long get_Creator(); + LPDISPATCH get_Parent(); + LPDISPATCH get_BuiltInDocumentProperties(); + LPDISPATCH get_CustomDocumentProperties(); + CString get_Path(); + WBookmarks get_Bookmarks(); + WTables get_Tables(); + LPDISPATCH get_Footnotes(); + LPDISPATCH get_Endnotes(); + LPDISPATCH get_Comments(); + long get_Type(); + BOOL get_AutoHyphenation(); + void put_AutoHyphenation(BOOL newValue); + BOOL get_HyphenateCaps(); + void put_HyphenateCaps(BOOL newValue); + long get_HyphenationZone(); + void put_HyphenationZone(long newValue); + long get_ConsecutiveHyphensLimit(); + void put_ConsecutiveHyphensLimit(long newValue); + LPDISPATCH get_Sections(); + LPDISPATCH get_Paragraphs(); + LPDISPATCH get_Words(); + LPDISPATCH get_Sentences(); + LPDISPATCH get_Characters(); + LPDISPATCH get_Fields(); + LPDISPATCH get_FormFields(); + LPDISPATCH get_Styles(); + LPDISPATCH get_Frames(); + LPDISPATCH get_TablesOfFigures(); + LPDISPATCH get_Variables(); + LPDISPATCH get_MailMerge(); + LPDISPATCH get_Envelope(); + CString get_FullName(); + LPDISPATCH get_Revisions(); + LPDISPATCH get_TablesOfContents(); + LPDISPATCH get_TablesOfAuthorities(); + LPDISPATCH get_PageSetup(); + void put_PageSetup(LPDISPATCH newValue); + LPDISPATCH get_Windows(); + BOOL get_HasRoutingSlip(); + void put_HasRoutingSlip(BOOL newValue); + LPDISPATCH get_RoutingSlip(); + BOOL get_Routed(); + LPDISPATCH get_TablesOfAuthoritiesCategories(); + LPDISPATCH get_Indexes(); + BOOL get_Saved(); + void put_Saved(BOOL newValue); + LPDISPATCH get_Content(); + LPDISPATCH get_ActiveWindow(); + long get_Kind(); + void put_Kind(long newValue); + BOOL get_ReadOnly(); + LPDISPATCH get_Subdocuments(); + BOOL get_IsMasterDocument(); + float get_DefaultTabStop(); + void put_DefaultTabStop(float newValue); + BOOL get_EmbedTrueTypeFonts(); + void put_EmbedTrueTypeFonts(BOOL newValue); + BOOL get_SaveFormsData(); + void put_SaveFormsData(BOOL newValue); + BOOL get_ReadOnlyRecommended(); + void put_ReadOnlyRecommended(BOOL newValue); + BOOL get_SaveSubsetFonts(); + void put_SaveSubsetFonts(BOOL newValue); + BOOL get_Compatibility(long Type); + void put_Compatibility(long Type, BOOL newValue); + LPDISPATCH get_StoryRanges(); + LPDISPATCH get_CommandBars(); + BOOL get_IsSubdocument(); + long get_SaveFormat(); + long get_ProtectionType(); + LPDISPATCH get_Hyperlinks(); + LPDISPATCH get_Shapes(); + LPDISPATCH get_ListTemplates(); + LPDISPATCH get_Lists(); + BOOL get_UpdateStylesOnOpen(); + void put_UpdateStylesOnOpen(BOOL newValue); + VARIANT get_AttachedTemplate(); + void put_AttachedTemplate(VARIANT * newValue); + LPDISPATCH get_InlineShapes(); + LPDISPATCH get_Background(); + void put_Background(LPDISPATCH newValue); + BOOL get_GrammarChecked(); + void put_GrammarChecked(BOOL newValue); + BOOL get_SpellingChecked(); + void put_SpellingChecked(BOOL newValue); + BOOL get_ShowGrammaticalErrors(); + void put_ShowGrammaticalErrors(BOOL newValue); + BOOL get_ShowSpellingErrors(); + void put_ShowSpellingErrors(BOOL newValue); + LPDISPATCH get_Versions(); + BOOL get_ShowSummary(); + void put_ShowSummary(BOOL newValue); + long get_SummaryViewMode(); + void put_SummaryViewMode(long newValue); + long get_SummaryLength(); + void put_SummaryLength(long newValue); + BOOL get_PrintFractionalWidths(); + void put_PrintFractionalWidths(BOOL newValue); + BOOL get_PrintPostScriptOverText(); + void put_PrintPostScriptOverText(BOOL newValue); + LPDISPATCH get_Container(); + BOOL get_PrintFormsData(); + void put_PrintFormsData(BOOL newValue); + LPDISPATCH get_ListParagraphs(); + void put_Password(LPCTSTR newValue); + void put_WritePassword(LPCTSTR newValue); + BOOL get_HasPassword(); + BOOL get_WriteReserved(); + CString get_ActiveWritingStyle(VARIANT * LanguageID); + void put_ActiveWritingStyle(VARIANT * LanguageID, LPCTSTR newValue); + BOOL get_UserControl(); + void put_UserControl(BOOL newValue); + BOOL get_HasMailer(); + void put_HasMailer(BOOL newValue); + LPDISPATCH get_Mailer(); + LPDISPATCH get_ReadabilityStatistics(); + LPDISPATCH get_GrammaticalErrors(); + LPDISPATCH get_SpellingErrors(); + LPDISPATCH get_VBProject(); + BOOL get_FormsDesign(); + CString get__CodeName(); + void put__CodeName(LPCTSTR newValue); + CString get_CodeName(); + BOOL get_SnapToGrid(); + void put_SnapToGrid(BOOL newValue); + BOOL get_SnapToShapes(); + void put_SnapToShapes(BOOL newValue); + float get_GridDistanceHorizontal(); + void put_GridDistanceHorizontal(float newValue); + float get_GridDistanceVertical(); + void put_GridDistanceVertical(float newValue); + float get_GridOriginHorizontal(); + void put_GridOriginHorizontal(float newValue); + float get_GridOriginVertical(); + void put_GridOriginVertical(float newValue); + long get_GridSpaceBetweenHorizontalLines(); + void put_GridSpaceBetweenHorizontalLines(long newValue); + long get_GridSpaceBetweenVerticalLines(); + void put_GridSpaceBetweenVerticalLines(long newValue); + BOOL get_GridOriginFromMargin(); + void put_GridOriginFromMargin(BOOL newValue); + BOOL get_KerningByAlgorithm(); + void put_KerningByAlgorithm(BOOL newValue); + long get_JustificationMode(); + void put_JustificationMode(long newValue); + long get_FarEastLineBreakLevel(); + void put_FarEastLineBreakLevel(long newValue); + CString get_NoLineBreakBefore(); + void put_NoLineBreakBefore(LPCTSTR newValue); + CString get_NoLineBreakAfter(); + void put_NoLineBreakAfter(LPCTSTR newValue); + BOOL get_TrackRevisions(); + void put_TrackRevisions(BOOL newValue); + BOOL get_PrintRevisions(); + void put_PrintRevisions(BOOL newValue); + BOOL get_ShowRevisions(); + void put_ShowRevisions(BOOL newValue); + void Close(VARIANT * SaveChanges, VARIANT * OriginalFormat, VARIANT * RouteDocument); + void SaveAs2000(VARIANT * FileName, VARIANT * FileFormat, VARIANT * LockComments, VARIANT * Password, VARIANT * AddToRecentFiles, VARIANT * WritePassword, VARIANT * ReadOnlyRecommended, VARIANT * EmbedTrueTypeFonts, VARIANT * SaveNativePictureFormat, VARIANT * SaveFormsData, VARIANT * SaveAsAOCELetter); + void Repaginate(); + void FitToPages(); + void ManualHyphenation(); + void Select(); + void DataForm(); + void Route(); + void Save(); + void PrintOutOld(VARIANT * Background, VARIANT * Append, VARIANT * Range, VARIANT * OutputFileName, VARIANT * From, VARIANT * To, VARIANT * Item, VARIANT * Copies, VARIANT * Pages, VARIANT * PageType, VARIANT * PrintToFile, VARIANT * Collate, VARIANT * ActivePrinterMacGX, VARIANT * ManualDuplexPrint); + void SendMail(); + LPDISPATCH Range(VARIANT * Start, VARIANT * End); + void RunAutoMacro(long Which); + void Activate(); + void PrintPreview(); + LPDISPATCH GoTo(VARIANT * What, VARIANT * Which, VARIANT * Count, VARIANT * Name); + BOOL Undo(VARIANT * Times); + BOOL Redo(VARIANT * Times); + long ComputeStatistics(long Statistic, VARIANT * IncludeFootnotesAndEndnotes); + void MakeCompatibilityDefault(); + void Protect2002(long Type, VARIANT * NoReset, VARIANT * Password); + void Unprotect(VARIANT * Password); + void EditionOptions(long Type, long Option, LPCTSTR Name, VARIANT * Format); + void RunLetterWizard(VARIANT * LetterContent, VARIANT * WizardMode); + LPDISPATCH GetLetterContent(); + void SetLetterContent(VARIANT * LetterContent); + void CopyStylesFromTemplate(LPCTSTR Template); + void UpdateStyles(); + void CheckGrammar(); + void CheckSpelling(VARIANT * CustomDictionary, VARIANT * IgnoreUppercase, VARIANT * AlwaysSuggest, VARIANT * CustomDictionary2, VARIANT * CustomDictionary3, VARIANT * CustomDictionary4, VARIANT * CustomDictionary5, VARIANT * CustomDictionary6, VARIANT * CustomDictionary7, VARIANT * CustomDictionary8, VARIANT * CustomDictionary9, VARIANT * CustomDictionary10); + void FollowHyperlink(VARIANT * Address, VARIANT * SubAddress, VARIANT * NewWindow, VARIANT * AddHistory, VARIANT * ExtraInfo, VARIANT * Method, VARIANT * HeaderInfo); + void AddToFavorites(); + void Reload(); + LPDISPATCH AutoSummarize(VARIANT * Length, VARIANT * Mode, VARIANT * UpdateProperties); + void RemoveNumbers(VARIANT * NumberType); + void ConvertNumbersToText(VARIANT * NumberType); + long CountNumberedItems(VARIANT * NumberType, VARIANT * Level); + void Post(); + void ToggleFormsDesign(); + void Compare2000(LPCTSTR Name); + void UpdateSummaryProperties(); + VARIANT GetCrossReferenceItems(VARIANT * ReferenceType); + void AutoFormat(); + void ViewCode(); + void ViewPropertyBrowser(); + void ForwardMailer(); + void Reply(); + void ReplyAll(); + void SendMailer(VARIANT * FileFormat, VARIANT * Priority); + void UndoClear(); + void PresentIt(); + void SendFax(LPCTSTR Address, VARIANT * Subject); + void Merge2000(LPCTSTR FileName); + void ClosePrintPreview(); + void CheckConsistency(); + LPDISPATCH CreateLetterContent(LPCTSTR DateFormat, BOOL IncludeHeaderFooter, LPCTSTR PageDesign, long LetterStyle, BOOL Letterhead, long LetterheadLocation, float LetterheadSize, LPCTSTR RecipientName, LPCTSTR RecipientAddress, LPCTSTR Salutation, long SalutationType, LPCTSTR RecipientReference, LPCTSTR MailingInstructions, LPCTSTR AttentionLine, LPCTSTR Subject, LPCTSTR CCList, LPCTSTR ReturnAddress, LPCTSTR SenderName, LPCTSTR Closing, LPCTSTR SenderCompany, LPCTSTR SenderJobTitle, LPCTSTR SenderInitials, long EnclosureNumber, VARIANT * InfoBlock, VARIANT * RecipientCode, VARIANT * RecipientGender, VARIANT * ReturnAddressShortForm, VARIANT * SenderCity, VARIANT * SenderCode, VARIANT * SenderGender, VARIANT * SenderReference); + void AcceptAllRevisions(); + void RejectAllRevisions(); + void DetectLanguage(); + void ApplyTheme(LPCTSTR Name); + void RemoveTheme(); + void WebPagePreview(); + void ReloadAs(long Encoding); + CString get_ActiveTheme(); + CString get_ActiveThemeDisplayName(); + LPDISPATCH get_Email(); + LPDISPATCH get_Scripts(); + BOOL get_LanguageDetected(); + void put_LanguageDetected(BOOL newValue); + long get_FarEastLineBreakLanguage(); + void put_FarEastLineBreakLanguage(long newValue); + LPDISPATCH get_Frameset(); + VARIANT get_ClickAndTypeParagraphStyle(); + void put_ClickAndTypeParagraphStyle(VARIANT * newValue); + LPDISPATCH get_HTMLProject(); + LPDISPATCH get_WebOptions(); + long get_OpenEncoding(); + long get_SaveEncoding(); + void put_SaveEncoding(long newValue); + BOOL get_OptimizeForWord97(); + void put_OptimizeForWord97(BOOL newValue); + BOOL get_VBASigned(); + void PrintOut2000(VARIANT * Background, VARIANT * Append, VARIANT * Range, VARIANT * OutputFileName, VARIANT * From, VARIANT * To, VARIANT * Item, VARIANT * Copies, VARIANT * Pages, VARIANT * PageType, VARIANT * PrintToFile, VARIANT * Collate, VARIANT * ActivePrinterMacGX, VARIANT * ManualDuplexPrint, VARIANT * PrintZoomColumn, VARIANT * PrintZoomRow, VARIANT * PrintZoomPaperWidth, VARIANT * PrintZoomPaperHeight); + void sblt(LPCTSTR s); + void ConvertVietDoc(long CodePageOrigin); + void PrintOut(VARIANT * Background, VARIANT * Append, VARIANT * Range, VARIANT * OutputFileName, VARIANT * From, VARIANT * To, VARIANT * Item, VARIANT * Copies, VARIANT * Pages, VARIANT * PageType, VARIANT * PrintToFile, VARIANT * Collate, VARIANT * ActivePrinterMacGX, VARIANT * ManualDuplexPrint, VARIANT * PrintZoomColumn, VARIANT * PrintZoomRow, VARIANT * PrintZoomPaperWidth, VARIANT * PrintZoomPaperHeight); + LPDISPATCH get_MailEnvelope(); + BOOL get_DisableFeatures(); + void put_DisableFeatures(BOOL newValue); + BOOL get_DoNotEmbedSystemFonts(); + void put_DoNotEmbedSystemFonts(BOOL newValue); + LPDISPATCH get_Signatures(); + CString get_DefaultTargetFrame(); + void put_DefaultTargetFrame(LPCTSTR newValue); + LPDISPATCH get_HTMLDivisions(); + long get_DisableFeaturesIntroducedAfter(); + void put_DisableFeaturesIntroducedAfter(long newValue); + BOOL get_RemovePersonalInformation(); + void put_RemovePersonalInformation(BOOL newValue); + LPDISPATCH get_SmartTags(); + void Compare2002(LPCTSTR Name, VARIANT * AuthorName, VARIANT * CompareTarget, VARIANT * DetectFormatChanges, VARIANT * IgnoreAllComparisonWarnings, VARIANT * AddToRecentFiles); + void CheckIn(BOOL SaveChanges, VARIANT * Comments, BOOL MakePublic); + BOOL CanCheckin(); + void Merge(LPCTSTR FileName, VARIANT * MergeTarget, VARIANT * DetectFormatChanges, VARIANT * UseFormattingFrom, VARIANT * AddToRecentFiles); + BOOL get_EmbedSmartTags(); + void put_EmbedSmartTags(BOOL newValue); + BOOL get_SmartTagsAsXMLProps(); + void put_SmartTagsAsXMLProps(BOOL newValue); + long get_TextEncoding(); + void put_TextEncoding(long newValue); + long get_TextLineEnding(); + void put_TextLineEnding(long newValue); + void SendForReview(VARIANT * Recipients, VARIANT * Subject, VARIANT * ShowMessage, VARIANT * IncludeAttachment); + void ReplyWithChanges(VARIANT * ShowMessage); + void EndReview(); + LPDISPATCH get_StyleSheets(); + VARIANT get_DefaultTableStyle(); + CString get_PasswordEncryptionProvider(); + CString get_PasswordEncryptionAlgorithm(); + long get_PasswordEncryptionKeyLength(); + BOOL get_PasswordEncryptionFileProperties(); + void SetPasswordEncryptionOptions(LPCTSTR PasswordEncryptionProvider, LPCTSTR PasswordEncryptionAlgorithm, long PasswordEncryptionKeyLength, VARIANT * PasswordEncryptionFileProperties); + void RecheckSmartTags(); + void RemoveSmartTags(); + void SetDefaultTableStyle(VARIANT * Style, BOOL SetInTemplate); + void DeleteAllComments(); + void AcceptAllRevisionsShown(); + void RejectAllRevisionsShown(); + void DeleteAllCommentsShown(); + void ResetFormFields(); + void SaveAs(VARIANT * FileName, VARIANT * FileFormat, VARIANT * LockComments, VARIANT * Password, VARIANT * AddToRecentFiles, VARIANT * WritePassword, VARIANT * ReadOnlyRecommended, VARIANT * EmbedTrueTypeFonts, VARIANT * SaveNativePictureFormat, VARIANT * SaveFormsData, VARIANT * SaveAsAOCELetter, VARIANT * Encoding, VARIANT * InsertLineBreaks, VARIANT * AllowSubstitutions, VARIANT * LineEnding, VARIANT * AddBiDiMarks); + BOOL get_EmbedLinguisticData(); + void put_EmbedLinguisticData(BOOL newValue); + BOOL get_FormattingShowFont(); + void put_FormattingShowFont(BOOL newValue); + BOOL get_FormattingShowClear(); + void put_FormattingShowClear(BOOL newValue); + BOOL get_FormattingShowParagraph(); + void put_FormattingShowParagraph(BOOL newValue); + BOOL get_FormattingShowNumbering(); + void put_FormattingShowNumbering(BOOL newValue); + long get_FormattingShowFilter(); + void put_FormattingShowFilter(long newValue); + void CheckNewSmartTags(); + LPDISPATCH get_Permission(); + LPDISPATCH get_XMLNodes(); + LPDISPATCH get_XMLSchemaReferences(); + LPDISPATCH get_SmartDocument(); + LPDISPATCH get_SharedWorkspace(); + LPDISPATCH get_Sync(); + BOOL get_EnforceStyle(); + void put_EnforceStyle(BOOL newValue); + BOOL get_AutoFormatOverride(); + void put_AutoFormatOverride(BOOL newValue); + BOOL get_XMLSaveDataOnly(); + void put_XMLSaveDataOnly(BOOL newValue); + BOOL get_XMLHideNamespaces(); + void put_XMLHideNamespaces(BOOL newValue); + BOOL get_XMLShowAdvancedErrors(); + void put_XMLShowAdvancedErrors(BOOL newValue); + BOOL get_XMLUseXSLTWhenSaving(); + void put_XMLUseXSLTWhenSaving(BOOL newValue); + CString get_XMLSaveThroughXSLT(); + void put_XMLSaveThroughXSLT(LPCTSTR newValue); + LPDISPATCH get_DocumentLibraryVersions(); + BOOL get_ReadingModeLayoutFrozen(); + void put_ReadingModeLayoutFrozen(BOOL newValue); + BOOL get_RemoveDateAndTime(); + void put_RemoveDateAndTime(BOOL newValue); + void SendFaxOverInternet(VARIANT * Recipients, VARIANT * Subject, VARIANT * ShowMessage); + void TransformDocument(LPCTSTR Path, BOOL DataOnly); + void Protect(long Type, VARIANT * NoReset, VARIANT * Password, VARIANT * UseIRM, VARIANT * EnforceStyleLock); + void SelectAllEditableRanges(VARIANT * EditorID); + void DeleteAllEditableRanges(VARIANT * EditorID); + void DeleteAllInkAnnotations(); + void AddDocumentWorkspaceHeader(BOOL RichFormat, LPCTSTR Url, LPCTSTR Title, LPCTSTR Description, LPCTSTR ID); + void RemoveDocumentWorkspaceHeader(LPCTSTR ID); + void Compare(LPCTSTR Name, VARIANT * AuthorName, VARIANT * CompareTarget, VARIANT * DetectFormatChanges, VARIANT * IgnoreAllComparisonWarnings, VARIANT * AddToRecentFiles, VARIANT * RemovePersonalInformation, VARIANT * RemoveDateAndTime); + void RemoveLockedStyles(); + LPDISPATCH get_ChildNodeSuggestions(); + LPDISPATCH SelectSingleNode(LPCTSTR XPath, LPCTSTR PrefixMapping, BOOL FastSearchSkippingTextNodes); + LPDISPATCH SelectNodes(LPCTSTR XPath, LPCTSTR PrefixMapping, BOOL FastSearchSkippingTextNodes); + LPDISPATCH get_XMLSchemaViolations(); + long get_ReadingLayoutSizeX(); + void put_ReadingLayoutSizeX(long newValue); + long get_ReadingLayoutSizeY(); + void put_ReadingLayoutSizeY(long newValue); + long get_StyleSortMethod(); + void put_StyleSortMethod(long newValue); + LPDISPATCH get_ContentTypeProperties(); + BOOL get_TrackMoves(); + void put_TrackMoves(BOOL newValue); + BOOL get_TrackFormatting(); + void put_TrackFormatting(BOOL newValue); + void get_Dummy1(); + LPDISPATCH get_OMaths(); + void RemoveDocumentInformation(long RemoveDocInfoType); + void CheckInWithVersion(BOOL SaveChanges, VARIANT * Comments, BOOL MakePublic, VARIANT * VersionType); + void Dummy2(); + void get_Dummy3(); + LPDISPATCH get_ServerPolicy(); + LPDISPATCH get_ContentControls(); + LPDISPATCH get_DocumentInspectors(); + void LockServerFile(); + LPDISPATCH GetWorkflowTasks(); + LPDISPATCH GetWorkflowTemplates(); + void Dummy4(); + void AddMeetingWorkspaceHeader(BOOL SkipIfAbsent, LPCTSTR Url, LPCTSTR Title, LPCTSTR Description, LPCTSTR ID); + LPDISPATCH get_Bibliography(); + BOOL get_LockTheme(); + void put_LockTheme(BOOL newValue); + BOOL get_LockQuickStyleSet(); + void put_LockQuickStyleSet(BOOL newValue); + CString get_OriginalDocumentTitle(); + CString get_RevisedDocumentTitle(); + LPDISPATCH get_CustomXMLParts(); + BOOL get_FormattingShowNextLevel(); + void put_FormattingShowNextLevel(BOOL newValue); + BOOL get_FormattingShowUserStyleName(); + void put_FormattingShowUserStyleName(BOOL newValue); + void SaveAsQuickStyleSet(LPCTSTR FileName); + void ApplyQuickStyleSet(LPCTSTR Name); + LPDISPATCH get_Research(); + BOOL get_Final(); + void put_Final(BOOL newValue); + long get_OMathBreakBin(); + void put_OMathBreakBin(long newValue); + long get_OMathBreakSub(); + void put_OMathBreakSub(long newValue); + long get_OMathJc(); + void put_OMathJc(long newValue); + float get_OMathLeftMargin(); + void put_OMathLeftMargin(float newValue); + float get_OMathRightMargin(); + void put_OMathRightMargin(float newValue); + float get_OMathWrap(); + void put_OMathWrap(float newValue); + BOOL get_OMathIntSubSupLim(); + void put_OMathIntSubSupLim(BOOL newValue); + BOOL get_OMathNarySupSubLim(); + void put_OMathNarySupSubLim(BOOL newValue); + BOOL get_OMathSmallFrac(); + void put_OMathSmallFrac(BOOL newValue); + CString get_WordOpenXML(); + LPDISPATCH get_DocumentTheme(); + void ApplyDocumentTheme(LPCTSTR FileName); + BOOL get_HasVBProject(); + LPDISPATCH SelectLinkedControls(LPDISPATCH Node); + LPDISPATCH SelectUnlinkedControls(LPDISPATCH Stream); + LPDISPATCH SelectContentControlsByTitle(LPCTSTR Title); + void ExportAsFixedFormat(LPCTSTR OutputFileName, long ExportFormat, BOOL OpenAfterExport, long OptimizeFor, long Range, long From, long To, long Item, BOOL IncludeDocProps, BOOL KeepIRM, long CreateBookmarks, BOOL DocStructureTags, BOOL BitmapMissingFonts, BOOL UseISO19005_1, VARIANT * FixedFormatExtClassPtr); + void FreezeLayout(); + void UnfreezeLayout(); + CString get_OMathFontName(); + void put_OMathFontName(LPCTSTR newValue); + void DowngradeDocument(); + CString get_EncryptionProvider(); + void put_EncryptionProvider(LPCTSTR newValue); + BOOL get_UseMathDefaults(); + void put_UseMathDefaults(BOOL newValue); + long get_CurrentRsid(); + void Convert(); + LPDISPATCH SelectContentControlsByTag(LPCTSTR Tag); + void ConvertAutoHyphens(); + long get_DocID(); + void ApplyQuickStyleSet2(VARIANT * Style); + long get_CompatibilityMode(); + void SaveAs2(VARIANT * FileName, VARIANT * FileFormat, VARIANT * LockComments, VARIANT * Password, VARIANT * AddToRecentFiles, VARIANT * WritePassword, VARIANT * ReadOnlyRecommended, VARIANT * EmbedTrueTypeFonts, VARIANT * SaveNativePictureFormat, VARIANT * SaveFormsData, VARIANT * SaveAsAOCELetter, VARIANT * Encoding, VARIANT * InsertLineBreaks, VARIANT * AllowSubstitutions, VARIANT * LineEnding, VARIANT * AddBiDiMarks, VARIANT * CompatibilityMode); + LPDISPATCH get_CoAuthoring(); + void SetCompatibilityMode(long Mode); + LPDISPATCH get_Broadcast(); + long ReturnToLastReadPosition(); + BOOL get_ChartDataPointTrack(); + void put_ChartDataPointTrack(BOOL newValue); + BOOL get_IsInAutosave(); + void SaveCopyAs(VARIANT * FileName, VARIANT * FileFormat, VARIANT * LockComments, VARIANT * Password, VARIANT * AddToRecentFiles, VARIANT * WritePassword, VARIANT * ReadOnlyRecommended, VARIANT * EmbedTrueTypeFonts, VARIANT * SaveNativePictureFormat, VARIANT * SaveFormsData, VARIANT * SaveAsAOCELetter, VARIANT * Encoding, VARIANT * InsertLineBreaks, VARIANT * AllowSubstitutions, VARIANT * LineEnding, VARIANT * AddBiDiMarks, VARIANT * CompatibilityMode); + void InsertAppForOfficeTest(LPCTSTR ID, long Type, LPCTSTR Version, long StoreType, LPCTSTR StoreId, LPCTSTR AssetId, LPCTSTR AssetStoreId, long Width, long Height); +}; + +} // namespace MSO::Word diff --git a/include/office/word/WDocuments.h b/include/office/word/WDocuments.h new file mode 100644 index 0000000..cd72e1e --- /dev/null +++ b/include/office/word/WDocuments.h @@ -0,0 +1,41 @@ +#pragma once +// WDocumentsCollection wrapper class + +#include "office/VariantableDispatch.hpp" +#include "office/MSCollection.hpp" + +namespace MSO::Word { + class WApplication; + class WDocument; + +class WDocuments : + public VariantableDispatch, + public MSCollection { +public: + WDocuments() = default; + explicit WDocuments(LPDISPATCH pDispatch) : VariantableDispatch(pDispatch) {} + WDocuments(const WDocuments& dispatchSrc) : VariantableDispatch(dispatchSrc) {} + +public: + LPUNKNOWN get_NewEnum(); + long get_Count(); + WApplication get_Application(); + long get_Creator(); + LPDISPATCH get_Parent(); + WDocument get_Item(VARIANT IndexType); + void Close(VARIANT * SaveChanges, VARIANT * OriginalFormat, VARIANT * RouteDocument); + WDocument AddOld(VARIANT * Template, VARIANT * NewTemplate); + WDocument OpenOld(VARIANT * FileName, VARIANT * ConfirmConversions, VARIANT * ReadOnly, VARIANT * AddToRecentFiles, VARIANT * PasswordDocument, VARIANT * PasswordTemplate, VARIANT * Revert, VARIANT * WritePasswordDocument, VARIANT * WritePasswordTemplate, VARIANT * Format); + void Save(VARIANT * NoPrompt, VARIANT * OriginalFormat); + WDocument Add(VARIANT * Template, VARIANT * NewTemplate, VARIANT * DocumentType, VARIANT * Visible); + WDocument Open2000(VARIANT * FileName, VARIANT * ConfirmConversions, VARIANT * ReadOnly, VARIANT * AddToRecentFiles, VARIANT * PasswordDocument, VARIANT * PasswordTemplate, VARIANT * Revert, VARIANT * WritePasswordDocument, VARIANT * WritePasswordTemplate, VARIANT * Format, VARIANT * Encoding, VARIANT * Visible); + void CheckOut(LPCTSTR FileName); + BOOL CanCheckOut(LPCTSTR FileName); + WDocument Open2002(VARIANT * FileName, VARIANT * ConfirmConversions, VARIANT * ReadOnly, VARIANT * AddToRecentFiles, VARIANT * PasswordDocument, VARIANT * PasswordTemplate, VARIANT * Revert, VARIANT * WritePasswordDocument, VARIANT * WritePasswordTemplate, VARIANT * Format, VARIANT * Encoding, VARIANT * Visible, VARIANT * OpenAndRepair, VARIANT * DocumentDirection, VARIANT * NoEncodingDialog); + WDocument Open(VARIANT * FileName, VARIANT * ConfirmConversions, VARIANT * ReadOnly, VARIANT * AddToRecentFiles, VARIANT * PasswordDocument, VARIANT * PasswordTemplate, VARIANT * Revert, VARIANT * WritePasswordDocument, VARIANT * WritePasswordTemplate, VARIANT * Format, VARIANT * Encoding, VARIANT * Visible, VARIANT * OpenAndRepair, VARIANT * DocumentDirection, VARIANT * NoEncodingDialog, VARIANT * XMLTransform); + WDocument OpenNoRepairDialog(VARIANT * FileName, VARIANT * ConfirmConversions, VARIANT * ReadOnly, VARIANT * AddToRecentFiles, VARIANT * PasswordDocument, VARIANT * PasswordTemplate, VARIANT * Revert, VARIANT * WritePasswordDocument, VARIANT * WritePasswordTemplate, VARIANT * Format, VARIANT * Encoding, VARIANT * Visible, VARIANT * OpenAndRepair, VARIANT * DocumentDirection, VARIANT * NoEncodingDialog, VARIANT * XMLTransform); + LPDISPATCH AddBlogDocument(LPCTSTR ProviderID, LPCTSTR PostURL, LPCTSTR BlogName, LPCTSTR PostID); + +}; + +} // namespace MSO::Word diff --git a/include/office/word/WRange.h b/include/office/word/WRange.h new file mode 100644 index 0000000..ee65d39 --- /dev/null +++ b/include/office/word/WRange.h @@ -0,0 +1,238 @@ +#pragma once +// WRange wrapper class + +#include "office/VariantableDispatch.hpp" + +namespace MSO::Word { + class WApplication; + class WComments; + class WTables; + +class WRange : public VariantableDispatch { +public: + WRange() = default; + WRange(LPDISPATCH pDispatch) : VariantableDispatch(pDispatch) {} + WRange(const WRange& dispatchSrc) : VariantableDispatch(dispatchSrc) {} + +public: + CString get_Text(); + void put_Text(LPCTSTR newValue); + LPDISPATCH get_FormattedText(); + void put_FormattedText(LPDISPATCH newValue); + long get_Start(); + void put_Start(long newValue); + long get_End(); + void put_End(long newValue); + LPDISPATCH get_Font(); + void put_Font(LPDISPATCH newValue); + LPDISPATCH get_Duplicate(); + long get_StoryType(); + WTables get_Tables(); + LPDISPATCH get_Words(); + LPDISPATCH get_Sentences(); + LPDISPATCH get_Characters(); + LPDISPATCH get_Footnotes(); + LPDISPATCH get_Endnotes(); + WComments get_Comments(); + LPDISPATCH get_Cells(); + LPDISPATCH get_Sections(); + LPDISPATCH get_Paragraphs(); + LPDISPATCH get_Borders(); + void put_Borders(LPDISPATCH newValue); + LPDISPATCH get_Shading(); + LPDISPATCH get_TextRetrievalMode(); + void put_TextRetrievalMode(LPDISPATCH newValue); + LPDISPATCH get_Fields(); + LPDISPATCH get_FormFields(); + LPDISPATCH get_Frames(); + LPDISPATCH get_ParagraphFormat(); + void put_ParagraphFormat(LPDISPATCH newValue); + LPDISPATCH get_ListFormat(); + LPDISPATCH get_Bookmarks(); + WApplication get_Application(); + long get_Creator(); + LPDISPATCH get_Parent(); + long get_Bold(); + void put_Bold(long newValue); + long get_Italic(); + void put_Italic(long newValue); + long get_Underline(); + void put_Underline(long newValue); + long get_EmphasisMark(); + void put_EmphasisMark(long newValue); + BOOL get_DisableCharacterSpaceGrid(); + void put_DisableCharacterSpaceGrid(BOOL newValue); + LPDISPATCH get_Revisions(); + VARIANT get_Style(); + void put_Style(VARIANT * newValue); + long get_StoryLength(); + long get_LanguageID(); + void put_LanguageID(long newValue); + LPDISPATCH get_SynonymInfo(); + LPDISPATCH get_Hyperlinks(); + LPDISPATCH get_ListParagraphs(); + LPDISPATCH get_Subdocuments(); + BOOL get_GrammarChecked(); + void put_GrammarChecked(BOOL newValue); + BOOL get_SpellingChecked(); + void put_SpellingChecked(BOOL newValue); + long get_HighlightColorIndex(); + void put_HighlightColorIndex(long newValue); + LPDISPATCH get_Columns(); + LPDISPATCH get_Rows(); + long get_CanEdit(); + long get_CanPaste(); + BOOL get_IsEndOfRowMark(); + long get_BookmarkID(); + long get_PreviousBookmarkID(); + LPDISPATCH get_Find(); + LPDISPATCH get_PageSetup(); + void put_PageSetup(LPDISPATCH newValue); + LPDISPATCH get_ShapeRange(); + long get_Case(); + void put_Case(long newValue); + VARIANT get_Information(long Type); + LPDISPATCH get_ReadabilityStatistics(); + LPDISPATCH get_GrammaticalErrors(); + LPDISPATCH get_SpellingErrors(); + long get_Orientation(); + void put_Orientation(long newValue); + LPDISPATCH get_InlineShapes(); + LPDISPATCH get_NextStoryRange(); + long get_LanguageIDFarEast(); + void put_LanguageIDFarEast(long newValue); + long get_LanguageIDOther(); + void put_LanguageIDOther(long newValue); + void Select(); + void SetRange(long Start, long End); + void Collapse(VARIANT * Direction); + void InsertBefore(LPCTSTR Text); + void InsertAfter(LPCTSTR Text); + LPDISPATCH Next(VARIANT * Unit, VARIANT * Count); + LPDISPATCH Previous(VARIANT * Unit, VARIANT * Count); + long StartOf(VARIANT * Unit, VARIANT * Extend); + long EndOf(VARIANT * Unit, VARIANT * Extend); + long Move(VARIANT * Unit, VARIANT * Count); + long MoveStart(VARIANT * Unit, VARIANT * Count); + long MoveEnd(VARIANT * Unit, VARIANT * Count); + long MoveWhile(VARIANT * Cset, VARIANT * Count); + long MoveStartWhile(VARIANT * Cset, VARIANT * Count); + long MoveEndWhile(VARIANT * Cset, VARIANT * Count); + long MoveUntil(VARIANT * Cset, VARIANT * Count); + long MoveStartUntil(VARIANT * Cset, VARIANT * Count); + long MoveEndUntil(VARIANT * Cset, VARIANT * Count); + void Cut(); + void Copy(); + void Paste(); + void InsertBreak(VARIANT * Type); + void InsertFile(LPCTSTR FileName, VARIANT * Range, VARIANT * ConfirmConversions, VARIANT * Link, VARIANT * Attachment); + BOOL InStory(LPDISPATCH Range); + BOOL InRange(LPDISPATCH Range); + long Delete(VARIANT * Unit, VARIANT * Count); + void WholeStory(); + long Expand(VARIANT * Unit); + void InsertParagraph(); + void InsertParagraphAfter(); + LPDISPATCH ConvertToTableOld(VARIANT * Separator, VARIANT * NumRows, VARIANT * NumColumns, VARIANT * InitialColumnWidth, VARIANT * Format, VARIANT * ApplyBorders, VARIANT * ApplyShading, VARIANT * ApplyFont, VARIANT * ApplyColor, VARIANT * ApplyHeadingRows, VARIANT * ApplyLastRow, VARIANT * ApplyFirstColumn, VARIANT * ApplyLastColumn, VARIANT * AutoFit); + void InsertDateTimeOld(VARIANT * DateTimeFormat, VARIANT * InsertAsField, VARIANT * InsertAsFullWidth); + void InsertSymbol(long CharacterNumber, VARIANT * Font, VARIANT * Unicode, VARIANT * Bias); + void InsertCrossReference_2002(VARIANT * ReferenceType, long ReferenceKind, VARIANT * ReferenceItem, VARIANT * InsertAsHyperlink, VARIANT * IncludePosition); + void InsertCaptionXP(VARIANT * Label, VARIANT * Title, VARIANT * TitleAutoText, VARIANT * Position); + void CopyAsPicture(); + void SortOld(VARIANT * ExcludeHeader, VARIANT * FieldNumber, VARIANT * SortFieldType, VARIANT * SortOrder, VARIANT * FieldNumber2, VARIANT * SortFieldType2, VARIANT * SortOrder2, VARIANT * FieldNumber3, VARIANT * SortFieldType3, VARIANT * SortOrder3, VARIANT * SortColumn, VARIANT * Separator, VARIANT * CaseSensitive, VARIANT * LanguageID); + void SortAscending(); + void SortDescending(); + BOOL IsEqual(LPDISPATCH Range); + float Calculate(); + LPDISPATCH GoTo(VARIANT * What, VARIANT * Which, VARIANT * Count, VARIANT * Name); + LPDISPATCH GoToNext(long What); + LPDISPATCH GoToPrevious(long What); + void PasteSpecial(VARIANT * IconIndex, VARIANT * Link, VARIANT * Placement, VARIANT * DisplayAsIcon, VARIANT * DataType, VARIANT * IconFileName, VARIANT * IconLabel); + void LookupNameProperties(); + long ComputeStatistics(long Statistic); + void Relocate(long Direction); + void CheckSynonyms(); + void SubscribeTo(LPCTSTR Edition, VARIANT * Format); + void CreatePublisher(VARIANT * Edition, VARIANT * ContainsPICT, VARIANT * ContainsRTF, VARIANT * ContainsText); + void InsertAutoText(); + void InsertDatabase(VARIANT * Format, VARIANT * Style, VARIANT * LinkToSource, VARIANT * Connection, VARIANT * SQLStatement, VARIANT * SQLStatement1, VARIANT * PasswordDocument, VARIANT * PasswordTemplate, VARIANT * WritePasswordDocument, VARIANT * WritePasswordTemplate, VARIANT * DataSource, VARIANT * From, VARIANT * To, VARIANT * IncludeFields); + void AutoFormat(); + void CheckGrammar(); + void CheckSpelling(VARIANT * CustomDictionary, VARIANT * IgnoreUppercase, VARIANT * AlwaysSuggest, VARIANT * CustomDictionary2, VARIANT * CustomDictionary3, VARIANT * CustomDictionary4, VARIANT * CustomDictionary5, VARIANT * CustomDictionary6, VARIANT * CustomDictionary7, VARIANT * CustomDictionary8, VARIANT * CustomDictionary9, VARIANT * CustomDictionary10); + LPDISPATCH GetSpellingSuggestions(VARIANT * CustomDictionary, VARIANT * IgnoreUppercase, VARIANT * MainDictionary, VARIANT * SuggestionMode, VARIANT * CustomDictionary2, VARIANT * CustomDictionary3, VARIANT * CustomDictionary4, VARIANT * CustomDictionary5, VARIANT * CustomDictionary6, VARIANT * CustomDictionary7, VARIANT * CustomDictionary8, VARIANT * CustomDictionary9, VARIANT * CustomDictionary10); + void InsertParagraphBefore(); + void NextSubdocument(); + void PreviousSubdocument(); + void ConvertHangulAndHanja(VARIANT * ConversionsMode, VARIANT * FastConversion, VARIANT * CheckHangulEnding, VARIANT * EnableRecentOrdering, VARIANT * CustomDictionary); + void PasteAsNestedTable(); + void ModifyEnclosure(VARIANT * Style, VARIANT * Symbol, VARIANT * EnclosedText); + void PhoneticGuide(LPCTSTR Text, long Alignment, long Raise, long FontSize, LPCTSTR FontName); + void InsertDateTime(VARIANT * DateTimeFormat, VARIANT * InsertAsField, VARIANT * InsertAsFullWidth, VARIANT * DateLanguage, VARIANT * CalendarType); + void Sort(VARIANT * ExcludeHeader, VARIANT * FieldNumber, VARIANT * SortFieldType, VARIANT * SortOrder, VARIANT * FieldNumber2, VARIANT * SortFieldType2, VARIANT * SortOrder2, VARIANT * FieldNumber3, VARIANT * SortFieldType3, VARIANT * SortOrder3, VARIANT * SortColumn, VARIANT * Separator, VARIANT * CaseSensitive, VARIANT * BidiSort, VARIANT * IgnoreThe, VARIANT * IgnoreKashida, VARIANT * IgnoreDiacritics, VARIANT * IgnoreHe, VARIANT * LanguageID); + void DetectLanguage(); + LPDISPATCH ConvertToTable(VARIANT * Separator, VARIANT * NumRows, VARIANT * NumColumns, VARIANT * InitialColumnWidth, VARIANT * Format, VARIANT * ApplyBorders, VARIANT * ApplyShading, VARIANT * ApplyFont, VARIANT * ApplyColor, VARIANT * ApplyHeadingRows, VARIANT * ApplyLastRow, VARIANT * ApplyFirstColumn, VARIANT * ApplyLastColumn, VARIANT * AutoFit, VARIANT * AutoFitBehavior, VARIANT * DefaultTableBehavior); + void TCSCConverter(long WdTCSCConverterDirection, BOOL CommonTerms, BOOL UseVariants); + BOOL get_LanguageDetected(); + void put_LanguageDetected(BOOL newValue); + float get_FitTextWidth(); + void put_FitTextWidth(float newValue); + long get_HorizontalInVertical(); + void put_HorizontalInVertical(long newValue); + long get_TwoLinesInOne(); + void put_TwoLinesInOne(long newValue); + BOOL get_CombineCharacters(); + void put_CombineCharacters(BOOL newValue); + long get_NoProofing(); + void put_NoProofing(long newValue); + LPDISPATCH get_TopLevelTables(); + LPDISPATCH get_Scripts(); + long get_CharacterWidth(); + void put_CharacterWidth(long newValue); + long get_Kana(); + void put_Kana(long newValue); + long get_BoldBi(); + void put_BoldBi(long newValue); + long get_ItalicBi(); + void put_ItalicBi(long newValue); + CString get_ID(); + void put_ID(LPCTSTR newValue); + LPDISPATCH get_HTMLDivisions(); + LPDISPATCH get_SmartTags(); + BOOL get_ShowAll(); + void put_ShowAll(BOOL newValue); + LPDISPATCH get_Document(); + LPDISPATCH get_FootnoteOptions(); + LPDISPATCH get_EndnoteOptions(); + void PasteAndFormat(long Type); + void PasteExcelTable(BOOL LinkedToExcel, BOOL WordFormatting, BOOL RTF); + void PasteAppendTable(); + LPDISPATCH get_XMLNodes(); + LPDISPATCH get_XMLParentNode(); + LPDISPATCH get_Editors(); + CString get_XML(BOOL DataOnly); + VARIANT get_EnhMetaFileBits(); + LPDISPATCH GoToEditableRange(VARIANT * EditorID); + void InsertXML(LPCTSTR XML, VARIANT * Transform); + void InsertCaption(VARIANT * Label, VARIANT * Title, VARIANT * TitleAutoText, VARIANT * Position, VARIANT * ExcludeLabel); + void InsertCrossReference(VARIANT * ReferenceType, long ReferenceKind, VARIANT * ReferenceItem, VARIANT * InsertAsHyperlink, VARIANT * IncludePosition, VARIANT * SeparateNumbers, VARIANT * SeparatorString); + LPDISPATCH get_OMaths(); + VARIANT get_CharacterStyle(); + VARIANT get_ParagraphStyle(); + VARIANT get_ListStyle(); + VARIANT get_TableStyle(); + LPDISPATCH get_ContentControls(); + void ExportFragment(LPCTSTR FileName, long Format); + CString get_WordOpenXML(); + void SetListLevel(short Level); + void InsertAlignmentTab(long Alignment, long RelativeTo); + LPDISPATCH get_ParentContentControl(); + void ImportFragment(LPCTSTR FileName, BOOL MatchDestination); + void ExportAsFixedFormat(LPCTSTR OutputFileName, long ExportFormat, BOOL OpenAfterExport, long OptimizeFor, BOOL ExportCurrentPage, long Item, BOOL IncludeDocProps, BOOL KeepIRM, long CreateBookmarks, BOOL DocStructureTags, BOOL BitmapMissingFonts, BOOL UseISO19005_1, VARIANT * FixedFormatExtClassPtr); + LPDISPATCH get_Locks(); + LPDISPATCH get_Updates(); + LPDISPATCH get_Conflicts(); + long get_TextVisibleOnScreen(); + void SortByHeadings(VARIANT * SortFieldType, VARIANT * SortOrder, VARIANT * CaseSensitive, VARIANT * BidiSort, VARIANT * IgnoreThe, VARIANT * IgnoreKashida, VARIANT * IgnoreDiacritics, VARIANT * IgnoreHe, VARIANT * LanguageID); +}; + +} // namespace MSO::Word diff --git a/include/office/word/WRow.h b/include/office/word/WRow.h new file mode 100644 index 0000000..cb9c19a --- /dev/null +++ b/include/office/word/WRow.h @@ -0,0 +1,53 @@ +#pragma once +// WRow wrapper class + +#include "office/VariantableDispatch.hpp" + +namespace MSO::Word { + +class WRow : public VariantableDispatch { +public: + WRow() = default; + WRow(LPDISPATCH pDispatch) : VariantableDispatch(pDispatch) {} + WRow(const WRow& dispatchSrc) : VariantableDispatch(dispatchSrc) {} + +public: + LPDISPATCH get_Range(); + LPDISPATCH get_Application(); + long get_Creator(); + LPDISPATCH get_Parent(); + long get_AllowBreakAcrossPages(); + void put_AllowBreakAcrossPages(long newValue); + long get_Alignment(); + void put_Alignment(long newValue); + long get_HeadingFormat(); + void put_HeadingFormat(long newValue); + float get_SpaceBetweenColumns(); + void put_SpaceBetweenColumns(float newValue); + float get_Height(); + void put_Height(float newValue); + long get_HeightRule(); + void put_HeightRule(long newValue); + float get_LeftIndent(); + void put_LeftIndent(float newValue); + BOOL get_IsLast(); + BOOL get_IsFirst(); + long get_Index(); + LPDISPATCH get_Cells(); + LPDISPATCH get_Borders(); + void put_Borders(LPDISPATCH newValue); + LPDISPATCH get_Shading(); + LPDISPATCH get_Next(); + LPDISPATCH get_Previous(); + void Select(); + void Delete(); + void SetLeftIndent(float LeftIndent, long RulerStyle); + void SetHeight(float RowHeight, long HeightRule); + LPDISPATCH ConvertToTextOld(VARIANT * Separator); + LPDISPATCH ConvertToText(VARIANT * Separator, VARIANT * NestedTables); + long get_NestingLevel(); + CString get_ID(); + void put_ID(LPCTSTR newValue); +}; + +} // namespace MSO::Word diff --git a/include/office/word/WRows.h b/include/office/word/WRows.h new file mode 100644 index 0000000..f5592db --- /dev/null +++ b/include/office/word/WRows.h @@ -0,0 +1,77 @@ +#pragma once +// WRows wrapper class + +#include "office/VariantableDispatch.hpp" +#include "office/MSCollection.hpp" + +namespace MSO::Word { + class WRow; + +class WRows : + public VariantableDispatch, + public MSCollection { +public: + WRows() = default; + WRows(LPDISPATCH pDispatch) : VariantableDispatch(pDispatch) {} + WRows(const WRows& dispatchSrc) : VariantableDispatch(dispatchSrc) {} + +public: + LPUNKNOWN get_NewEnum(); + long get_Count(); + long get_AllowBreakAcrossPages(); + void put_AllowBreakAcrossPages(long newValue); + long get_Alignment(); + void put_Alignment(long newValue); + long get_HeadingFormat(); + void put_HeadingFormat(long newValue); + float get_SpaceBetweenColumns(); + void put_SpaceBetweenColumns(float newValue); + float get_Height(); + void put_Height(float newValue); + long get_HeightRule(); + void put_HeightRule(long newValue); + float get_LeftIndent(); + void put_LeftIndent(float newValue); + LPDISPATCH get_First(); + LPDISPATCH get_Last(); + LPDISPATCH get_Application(); + long get_Creator(); + LPDISPATCH get_Parent(); + LPDISPATCH get_Borders(); + void put_Borders(LPDISPATCH newValue); + LPDISPATCH get_Shading(); + LPDISPATCH get_Item(long IndexType); + LPDISPATCH Add(VARIANT * BeforeRow); + void Select(); + void Delete(); + void SetLeftIndent(float LeftIndent, long RulerStyle); + void SetHeight(float RowHeight, long HeightRule); + LPDISPATCH ConvertToTextOld(VARIANT * Separator); + void DistributeHeight(); + LPDISPATCH ConvertToText(VARIANT * Separator, VARIANT * NestedTables); + long get_WrapAroundText(); + void put_WrapAroundText(long newValue); + float get_DistanceTop(); + void put_DistanceTop(float newValue); + float get_DistanceBottom(); + void put_DistanceBottom(float newValue); + float get_DistanceLeft(); + void put_DistanceLeft(float newValue); + float get_DistanceRight(); + void put_DistanceRight(float newValue); + float get_HorizontalPosition(); + void put_HorizontalPosition(float newValue); + float get_VerticalPosition(); + void put_VerticalPosition(float newValue); + long get_RelativeHorizontalPosition(); + void put_RelativeHorizontalPosition(long newValue); + long get_RelativeVerticalPosition(); + void put_RelativeVerticalPosition(long newValue); + long get_AllowOverlap(); + void put_AllowOverlap(long newValue); + long get_NestingLevel(); + long get_TableDirection(); + void put_TableDirection(long newValue); +}; + +} // namespace MSO::Word diff --git a/include/office/word/WTable.h b/include/office/word/WTable.h new file mode 100644 index 0000000..aec47df --- /dev/null +++ b/include/office/word/WTable.h @@ -0,0 +1,101 @@ +#pragma once +// WTable wrapper class + +#include "office/VariantableDispatch.hpp" + +namespace MSO::Word { + class WRange; + class WApplication; + class WTables; + class WRows; + class WColumns; + class WCell; + +class WTable : public VariantableDispatch { +public: + WTable() = default; + WTable(LPDISPATCH pDispatch) : VariantableDispatch(pDispatch) {} + WTable(const WTable& dispatchSrc) : VariantableDispatch(dispatchSrc) {} + +public: + WRange get_Range(); + WApplication get_Application(); + long get_Creator(); + LPDISPATCH get_Parent(); + WColumns get_Columns(); + WRows get_Rows(); + LPDISPATCH get_Borders(); + void put_Borders(LPDISPATCH newValue); + LPDISPATCH get_Shading(); + BOOL get_Uniform(); + long get_AutoFormatType(); + void Select(); + void Delete(); + + WCell Cell(long Row, long Column); + + void SortOld(VARIANT * ExcludeHeader, VARIANT * FieldNumber, VARIANT * SortFieldType, + VARIANT * SortOrder, VARIANT * FieldNumber2, + VARIANT * SortFieldType2, VARIANT * SortOrder2, VARIANT * FieldNumber3, VARIANT * SortFieldType3, + VARIANT * SortOrder3, VARIANT * CaseSensitive, VARIANT * LanguageID); + void SortAscending(); + void SortDescending(); + + void AutoFormat(VARIANT * Format, VARIANT * ApplyBorders, VARIANT * ApplyShading, VARIANT * ApplyFont, VARIANT * ApplyColor, + VARIANT * ApplyHeadingRows, VARIANT * ApplyLastRow, VARIANT * ApplyFirstColumn, VARIANT * ApplyLastColumn, VARIANT * AutoFit); + void UpdateAutoFormat(); + LPDISPATCH ConvertToTextOld(VARIANT * Separator); + LPDISPATCH Split(VARIANT * BeforeRow); + LPDISPATCH ConvertToText(VARIANT * Separator, VARIANT * NestedTables); + void AutoFitBehavior(long Behavior); + void Sort(VARIANT * ExcludeHeader, VARIANT * FieldNumber, VARIANT * SortFieldType, VARIANT * SortOrder, + VARIANT * FieldNumber2, VARIANT * SortFieldType2, VARIANT * SortOrder2, VARIANT * FieldNumber3, + VARIANT * SortFieldType3, VARIANT * SortOrder3, VARIANT * CaseSensitive, VARIANT * BidiSort, VARIANT * IgnoreThe, + VARIANT * IgnoreKashida, VARIANT * IgnoreDiacritics, VARIANT * IgnoreHe, VARIANT * LanguageID); + + WTables get_Tables(); + long get_NestingLevel(); + BOOL get_AllowPageBreaks(); + void put_AllowPageBreaks(BOOL newValue); + BOOL get_AllowAutoFit(); + void put_AllowAutoFit(BOOL newValue); + float get_PreferredWidth(); + void put_PreferredWidth(float newValue); + long get_PreferredWidthType(); + void put_PreferredWidthType(long newValue); + float get_TopPadding(); + void put_TopPadding(float newValue); + float get_BottomPadding(); + void put_BottomPadding(float newValue); + float get_LeftPadding(); + void put_LeftPadding(float newValue); + float get_RightPadding(); + void put_RightPadding(float newValue); + float get_Spacing(); + void put_Spacing(float newValue); + long get_TableDirection(); + void put_TableDirection(long newValue); + CString get_ID(); + void put_ID(LPCTSTR newValue); + VARIANT get_Style(); + void put_Style(VARIANT * newValue); + BOOL get_ApplyStyleHeadingRows(); + void put_ApplyStyleHeadingRows(BOOL newValue); + BOOL get_ApplyStyleLastRow(); + void put_ApplyStyleLastRow(BOOL newValue); + BOOL get_ApplyStyleFirstColumn(); + void put_ApplyStyleFirstColumn(BOOL newValue); + BOOL get_ApplyStyleLastColumn(); + void put_ApplyStyleLastColumn(BOOL newValue); + BOOL get_ApplyStyleRowBands(); + void put_ApplyStyleRowBands(BOOL newValue); + BOOL get_ApplyStyleColumnBands(); + void put_ApplyStyleColumnBands(BOOL newValue); + void ApplyStyleDirectFormatting(LPCTSTR StyleName); + CString get_Title(); + void put_Title(LPCTSTR newValue); + CString get_Descr(); + void put_Descr(LPCTSTR newValue); +}; + +} // namespace MSO::Word diff --git a/include/office/word/WTables.h b/include/office/word/WTables.h new file mode 100644 index 0000000..b644b8c --- /dev/null +++ b/include/office/word/WTables.h @@ -0,0 +1,32 @@ +#pragma once +// WTables wrapper class + +#include "office/VariantableDispatch.hpp" +#include "office/MSCollection.hpp" + +namespace MSO::Word { +class WApplication; +class WTable; +class WRange; + +class WTables : + public VariantableDispatch, + public MSCollection { +public: + WTables() = default; + WTables(LPDISPATCH pDispatch) : VariantableDispatch(pDispatch) {} + WTables(const WTables& dispatchSrc) : VariantableDispatch(dispatchSrc) {} + +public: + LPUNKNOWN get_NewEnum(); + long get_Count(); + WApplication get_Application(); + long get_Creator(); + LPDISPATCH get_Parent(); + WTable get_Item(long IndexType); + WTable AddOld(LPDISPATCH Range, long NumRows, long NumColumns); + WTable Add(WRange Range, long NumRows, long NumColumns, VARIANT * DefaultTableBehavior, VARIANT * AutoFitBehavior); + long get_NestingLevel(); +}; + +} // namespace MSO::Word diff --git a/src/ExcelWrapper.cpp b/src/ExcelWrapper.cpp new file mode 100644 index 0000000..f387b29 --- /dev/null +++ b/src/ExcelWrapper.cpp @@ -0,0 +1,95 @@ +#include "stdafx.h" + +#include "office/ExcelWrapper.h" + +namespace MSO::Excel { + +ExcelWrapper::~ExcelWrapper() { + if (m_NeedClose && IsActive()) { + try { + xlApplication.Quit(); + } catch (...) { + return; + } + } +} + +void ExcelWrapper::Clear() { + linkedWb.ReleaseDispatch(); + xlApplication.ReleaseDispatch(); + m_NeedClose = TRUE; +} + +BOOL ExcelWrapper::InitApplication(BOOL isVisible) { + if (!IsActive() && !xlApplication.CreateDispatch(L"Excel.Application")) { + return FALSE; + } else { + xlApplication.put_Visible(isVisible); + return TRUE; + } +} + +EXLWorkbook ExcelWrapper::OpenDocument(const CString docPath, BOOL docVisible, + BOOL docReadOnly, BOOL closeAfter, BOOL add2Recent) { + if (!::PathFileExistsW(docPath)) { + return nullptr; + } else if (!InitApplication(docVisible)) { + return nullptr; + } else { + m_NeedClose = closeAfter; + COleVariant readOnly{ static_cast(docReadOnly) }; + COleVariant addMRU{ static_cast(add2Recent) }; + linkedWb = xlApplication.get_Workbooks().Open(_bstr_t{ docPath }, vtMissing, readOnly, vtMissing, vtMissing, + vtMissing, vtMissing, vtMissing, vtMissing, vtMissing, + vtMissing, vtMissing, addMRU, vtMissing, vtMissing); + return linkedWb; + } +} + +EXLWorkbook ExcelWrapper::NewDocument(const CString docTemplate, BOOL closeAfter) { + if (!InitApplication(TRUE)) { + return nullptr; + } else { + auto templatePath = docTemplate; + if (docTemplate.IsEmpty() || !::PathFileExistsW(docTemplate)) + templatePath.Empty(); + + m_NeedClose = closeAfter; + COleVariant vPath{ templatePath }; + linkedWb = xlApplication.get_Workbooks().Add(vPath); + return linkedWb; + } +} + +void ExcelWrapper::ReleaseDocumentAndQuit() { + m_NeedClose = TRUE; + ReleaseDocument(); +} + +void ExcelWrapper::ReleaseDocument() { + if (m_NeedClose) { + CloseApplication(); + } + Clear(); +} + +void ExcelWrapper::CloseApplication() { + if (IsActive()) { + xlApplication.Quit(); + } +} + +EXLWorkbook ExcelWrapper::GetDocument() { + return linkedWb; +} + +CString ExcelWrapper::PromptUserForPath(const CString text) { + CFileDialog dialog(TRUE, 0, LR"(*.xlsx)", 0, text); + if (dialog.DoModal() != IDOK) { + return{}; + } else { + return dialog.GetPathName(); + } +} + +} // namespace MSO::Excel \ No newline at end of file diff --git a/src/Office.cpp b/src/Office.cpp new file mode 100644 index 0000000..2945c39 --- /dev/null +++ b/src/Office.cpp @@ -0,0 +1,12 @@ +#include "stdafx.h" + +#include "office/Office.h" + +#pragma warning( push ) +#pragma warning( disable : 26426 ) // do not warn about initilizer calls + +COleVariant MSO::ovTrue{ static_cast(TRUE) }; +COleVariant MSO::ovFalse{ static_cast(FALSE) }; +COleVariant MSO::ovOptional{ static_cast(DISP_E_PARAMNOTFOUND), VT_ERROR }; + +#pragma warning( pop ) \ No newline at end of file diff --git a/src/excel/EXLApplication.cpp b/src/excel/EXLApplication.cpp new file mode 100644 index 0000000..5620c6f --- /dev/null +++ b/src/excel/EXLApplication.cpp @@ -0,0 +1,2567 @@ +#include "stdafx.h" + +#include "office/excel/EXLApplication.h" +#include "office/excel/EXLWorkbooks.h" +#include "office/excel/EXLWorkbook.h" + +#pragma warning( push ) +#pragma warning( disable : 26493 26485 26494 ) + +namespace MSO::Excel { + +EXLApplication EXLApplication::get_Application() { + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +long EXLApplication::get_Creator() { + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_Parent() { + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_ActiveCell() { + LPDISPATCH result; + InvokeHelper(0x131, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_ActiveChart() { + LPDISPATCH result; + InvokeHelper(0xb7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_ActiveDialog() { + LPDISPATCH result; + InvokeHelper(0x32f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_ActiveMenuBar() { + LPDISPATCH result; + InvokeHelper(0x2f6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +CString EXLApplication::get_ActivePrinter() { + CString result; + InvokeHelper(0x132, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_ActivePrinter(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x132, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH EXLApplication::get_ActiveSheet() { + LPDISPATCH result; + InvokeHelper(0x133, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_ActiveWindow() { + LPDISPATCH result; + InvokeHelper(0x2f7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_ActiveWorkbook() { + LPDISPATCH result; + InvokeHelper(0x134, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_AddIns() { + LPDISPATCH result; + InvokeHelper(0x225, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_Assistant() { + LPDISPATCH result; + InvokeHelper(0x59e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +void EXLApplication::Calculate() { + InvokeHelper(0x117, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +LPDISPATCH EXLApplication::get_Cells() { + LPDISPATCH result; + InvokeHelper(0xee, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_Charts() { + LPDISPATCH result; + InvokeHelper(0x79, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_Columns() { + LPDISPATCH result; + InvokeHelper(0xf1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_CommandBars() { + LPDISPATCH result; + InvokeHelper(0x59f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +long EXLApplication::get_DDEAppReturnCode() { + long result; + InvokeHelper(0x14c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void EXLApplication::DDEExecute(long Channel, LPCTSTR String) { + static BYTE parms[] = VTS_I4 VTS_BSTR; + InvokeHelper(0x14d, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Channel, String); +} + +long EXLApplication::DDEInitiate(LPCTSTR App, LPCTSTR Topic) { + long result; + static BYTE parms[] = VTS_BSTR VTS_BSTR; + InvokeHelper(0x14e, DISPATCH_METHOD, VT_I4, (void*)&result, parms, App, Topic); + return result; +} + +void EXLApplication::DDEPoke(long Channel, VARIANT Item, VARIANT Data) { + static BYTE parms[] = VTS_I4 VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x14f, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Channel, &Item, &Data); +} + +VARIANT EXLApplication::DDERequest(long Channel, LPCTSTR Item) { + VARIANT result; + static BYTE parms[] = VTS_I4 VTS_BSTR; + InvokeHelper(0x150, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, Channel, Item); + return result; +} + +void EXLApplication::DDETerminate(long Channel) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x151, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Channel); +} + +LPDISPATCH EXLApplication::get_DialogSheets() { + LPDISPATCH result; + InvokeHelper(0x2fc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +VARIANT EXLApplication::Evaluate(VARIANT Name) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x1, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Name); + return result; +} + +VARIANT EXLApplication::_Evaluate(VARIANT Name) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0xfffffffb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Name); + return result; +} + +VARIANT EXLApplication::ExecuteExcel4Macro(LPCTSTR String) { + VARIANT result; + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x15e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, String); + return result; +} + +LPDISPATCH EXLApplication::Intersect(LPDISPATCH Arg1, LPDISPATCH Arg2, VARIANT Arg3, VARIANT Arg4, VARIANT Arg5, VARIANT Arg6, VARIANT Arg7, VARIANT Arg8, VARIANT Arg9, VARIANT + Arg10, VARIANT Arg11, VARIANT Arg12, VARIANT Arg13, VARIANT Arg14, VARIANT Arg15, VARIANT Arg16, VARIANT Arg17, VARIANT Arg18, VARIANT Arg19, +VARIANT Arg20, VARIANT Arg21, VARIANT Arg22, VARIANT Arg23, VARIANT Arg24, VARIANT Arg25, VARIANT Arg26, VARIANT Arg27, VARIANT Arg28, VARIANT Arg29, VARIANT Arg30) { + LPDISPATCH result; + static BYTE parms[] = VTS_DISPATCH VTS_DISPATCH VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x2fe, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Arg1, Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +LPDISPATCH EXLApplication::get_MenuBars() { + LPDISPATCH result; + InvokeHelper(0x24d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_Modules() { + LPDISPATCH result; + InvokeHelper(0x246, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_Names() { + LPDISPATCH result; + InvokeHelper(0x1ba, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_Range(VARIANT Cell1, VARIANT Cell2) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xc5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, &Cell1, &Cell2); + return result; +} + +LPDISPATCH EXLApplication::get_Rows() { + LPDISPATCH result; + InvokeHelper(0x102, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +VARIANT EXLApplication::Run(VARIANT Macro, VARIANT Arg1, VARIANT Arg2, VARIANT Arg3, VARIANT Arg4, VARIANT Arg5, VARIANT Arg6, VARIANT Arg7, VARIANT Arg8, VARIANT Arg9, VARIANT Arg10, VARIANT Arg11, VARIANT Arg12, VARIANT Arg13, VARIANT Arg14, VARIANT Arg15, VARIANT Arg16, VARIANT Arg17, VARIANT Arg18, VARIANT Arg19, VARIANT Arg20, VARIANT Arg21, VARIANT Arg22, VARIANT Arg23, VARIANT Arg24, VARIANT Arg25, VARIANT Arg26, VARIANT Arg27, VARIANT Arg28, VARIANT Arg29, VARIANT Arg30) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x103, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Macro, &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} +VARIANT EXLApplication::_Run2(VARIANT Macro, VARIANT Arg1, VARIANT Arg2, VARIANT Arg3, VARIANT Arg4, VARIANT Arg5, VARIANT Arg6, VARIANT Arg7, VARIANT Arg8, VARIANT Arg9, VARIANT Arg10, VARIANT Arg11, VARIANT Arg12, VARIANT Arg13, VARIANT Arg14, VARIANT Arg15, VARIANT Arg16, VARIANT Arg17, VARIANT Arg18, VARIANT Arg19, VARIANT Arg20, VARIANT Arg21, VARIANT Arg22, VARIANT Arg23, VARIANT Arg24, VARIANT Arg25, VARIANT Arg26, VARIANT Arg27, VARIANT Arg28, VARIANT Arg29, VARIANT Arg30) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x326, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Macro, &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +LPDISPATCH EXLApplication::get_Selection() { + LPDISPATCH result; + InvokeHelper(0x93, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +void EXLApplication::SendKeys(VARIANT Keys, VARIANT Wait) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x17f, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Keys, &Wait); +} + +LPDISPATCH EXLApplication::get_Sheets() { + LPDISPATCH result; + InvokeHelper(0x1e5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_ShortcutMenus(long IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_I4; + InvokeHelper(0x308, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, IndexType); + return result; +} + +LPDISPATCH EXLApplication::get_ThisWorkbook() { + LPDISPATCH result; + InvokeHelper(0x30a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_Toolbars() { + LPDISPATCH result; + InvokeHelper(0x228, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLApplication::Union(LPDISPATCH Arg1, LPDISPATCH Arg2, VARIANT Arg3, VARIANT Arg4, VARIANT Arg5, VARIANT Arg6, VARIANT Arg7, VARIANT Arg8, VARIANT Arg9, VARIANT Arg10, VARIANT Arg11, VARIANT Arg12, VARIANT Arg13, VARIANT Arg14, VARIANT Arg15, VARIANT Arg16, VARIANT Arg17, VARIANT Arg18, VARIANT Arg19, VARIANT Arg20, VARIANT Arg21, VARIANT Arg22, VARIANT Arg23, VARIANT Arg24, VARIANT Arg25, VARIANT Arg26, VARIANT Arg27, VARIANT Arg28, VARIANT Arg29, VARIANT Arg30) { + LPDISPATCH result; + static BYTE parms[] = VTS_DISPATCH VTS_DISPATCH VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x30b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Arg1, Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +LPDISPATCH EXLApplication::get_Windows() { + LPDISPATCH result; + InvokeHelper(0x1ae, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +EXLWorkbooks EXLApplication::get_Workbooks() { + LPDISPATCH result; + InvokeHelper(0x23c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_WorksheetFunction() { + LPDISPATCH result; + InvokeHelper(0x5a0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_Worksheets() { + LPDISPATCH result; + InvokeHelper(0x1ee, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_Excel4IntlMacroSheets() { + LPDISPATCH result; + InvokeHelper(0x245, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_Excel4MacroSheets() { + LPDISPATCH result; + InvokeHelper(0x243, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +void EXLApplication::ActivateMicrosoftApp(long IndexType) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x447, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, IndexType); +} + +void EXLApplication::AddChartAutoFormat(VARIANT Chart, LPCTSTR Name, VARIANT Description) { + static BYTE parms[] = VTS_VARIANT VTS_BSTR VTS_VARIANT; + InvokeHelper(0xd8, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Chart, Name, &Description); +} + +void EXLApplication::AddCustomList(VARIANT ListArray, VARIANT ByRow) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x30c, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &ListArray, &ByRow); +} + +BOOL EXLApplication::get_AlertBeforeOverwriting() { + BOOL result; + InvokeHelper(0x3a2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_AlertBeforeOverwriting(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x3a2, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +CString EXLApplication::get_AltStartupPath() { + CString result; + InvokeHelper(0x139, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_AltStartupPath(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x139, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_AskToUpdateLinks() { + BOOL result; + InvokeHelper(0x3e0, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_AskToUpdateLinks(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x3e0, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_EnableAnimations() { + BOOL result; + InvokeHelper(0x49c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_EnableAnimations(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x49c, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH EXLApplication::get_AutoCorrect() { + LPDISPATCH result; + InvokeHelper(0x479, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +long EXLApplication::get_Build() { + long result; + InvokeHelper(0x13a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +BOOL EXLApplication::get_CalculateBeforeSave() { + BOOL result; + InvokeHelper(0x13b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_CalculateBeforeSave(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x13b, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long EXLApplication::get_Calculation() { + long result; + InvokeHelper(0x13c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_Calculation(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x13c, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +VARIANT EXLApplication::get_Caller(VARIANT IndexType) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x13d, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, &IndexType); + return result; +} + +BOOL EXLApplication::get_CanPlaySounds() { + BOOL result; + InvokeHelper(0x13e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +BOOL EXLApplication::get_CanRecordSounds() { + BOOL result; + InvokeHelper(0x13f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +CString EXLApplication::get_Caption() { + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_Caption(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_CellDragAndDrop() { + BOOL result; + InvokeHelper(0x140, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_CellDragAndDrop(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x140, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +double EXLApplication::CentimetersToPoints(double Centimeters) { + double result; + static BYTE parms[] = VTS_R8; + InvokeHelper(0x43e, DISPATCH_METHOD, VT_R8, (void*)&result, parms, Centimeters); + return result; +} + +BOOL EXLApplication::CheckSpelling(LPCTSTR Word, VARIANT CustomDictionary, VARIANT IgnoreUppercase) { + BOOL result; + static BYTE parms[] = VTS_BSTR VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, Word, &CustomDictionary, &IgnoreUppercase); + return result; +} + +VARIANT EXLApplication::get_ClipboardFormats(VARIANT IndexType) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x141, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, &IndexType); + return result; +} + +BOOL EXLApplication::get_DisplayClipboardWindow() { + BOOL result; + InvokeHelper(0x142, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_DisplayClipboardWindow(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x142, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_ColorButtons() { + BOOL result; + InvokeHelper(0x16d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_ColorButtons(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x16d, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long EXLApplication::get_CommandUnderlines() { + long result; + InvokeHelper(0x143, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_CommandUnderlines(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x143, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_ConstrainNumeric() { + BOOL result; + InvokeHelper(0x144, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_ConstrainNumeric(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x144, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +VARIANT EXLApplication::ConvertFormula(VARIANT Formula, long FromReferenceStyle, VARIANT ToReferenceStyle, VARIANT ToAbsolute, VARIANT RelativeTo) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x145, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Formula, FromReferenceStyle, &ToReferenceStyle, &ToAbsolute, &RelativeTo); + return result; +} + +BOOL EXLApplication::get_CopyObjectsWithCells() { + BOOL result; + InvokeHelper(0x3df, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_CopyObjectsWithCells(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x3df, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long EXLApplication::get_Cursor() { + long result; + InvokeHelper(0x489, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_Cursor(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x489, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long EXLApplication::get_CustomListCount() { + long result; + InvokeHelper(0x313, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +long EXLApplication::get_CutCopyMode() { + long result; + InvokeHelper(0x14a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_CutCopyMode(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x14a, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long EXLApplication::get_DataEntryMode() { + long result; + InvokeHelper(0x14b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_DataEntryMode(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x14b, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +VARIANT EXLApplication::Dummy1(VARIANT Arg1, VARIANT Arg2, VARIANT Arg3, VARIANT Arg4) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x6f6, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Arg1, &Arg2, &Arg3, &Arg4); + return result; +} + +VARIANT EXLApplication::Dummy2(VARIANT Arg1, VARIANT Arg2, VARIANT Arg3, VARIANT Arg4, VARIANT Arg5, VARIANT Arg6, VARIANT Arg7, VARIANT Arg8) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x6f7, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8); + return result; +} + +VARIANT EXLApplication::Dummy3() { + VARIANT result; + InvokeHelper(0x6f8, DISPATCH_METHOD, VT_VARIANT, (void*)&result, nullptr); + return result; +} + +VARIANT EXLApplication::Dummy4(VARIANT Arg1, VARIANT Arg2, VARIANT Arg3, VARIANT Arg4, VARIANT Arg5, VARIANT Arg6, VARIANT Arg7, VARIANT Arg8, VARIANT Arg9, VARIANT Arg10, VARIANT +Arg11, VARIANT Arg12, VARIANT Arg13, VARIANT Arg14, VARIANT Arg15) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x6f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15); + return result; +} + +VARIANT EXLApplication::Dummy5(VARIANT Arg1, VARIANT Arg2, VARIANT Arg3, VARIANT Arg4, VARIANT Arg5, VARIANT Arg6, VARIANT Arg7, VARIANT Arg8, VARIANT Arg9, VARIANT Arg10, VARIANT Arg11, VARIANT Arg12, VARIANT Arg13) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x6fa, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13); + return result; +} + +VARIANT EXLApplication::Dummy6() { + VARIANT result; + InvokeHelper(0x6fb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, nullptr); + return result; +} + +VARIANT EXLApplication::Dummy7() { + VARIANT result; + InvokeHelper(0x6fc, DISPATCH_METHOD, VT_VARIANT, (void*)&result, nullptr); + return result; +} + +VARIANT EXLApplication::Dummy8(VARIANT Arg1) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x6fd, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Arg1); + return result; +} + +VARIANT EXLApplication::Dummy9() { + VARIANT result; + InvokeHelper(0x6fe, DISPATCH_METHOD, VT_VARIANT, (void*)&result, nullptr); + return result; +} + +BOOL EXLApplication::Dummy10(VARIANT arg) { + BOOL result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x6ff, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, &arg); + return result; +} + +void EXLApplication::Dummy11() { + InvokeHelper(0x700, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +CString EXLApplication::get__Default() { + CString result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +CString EXLApplication::get_DefaultFilePath() { + CString result; + InvokeHelper(0x40e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_DefaultFilePath(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x40e, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +void EXLApplication::DeleteChartAutoFormat(LPCTSTR Name) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0xd9, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Name); +} + +void EXLApplication::DeleteCustomList(long ListNum) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x30f, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, ListNum); +} + +LPDISPATCH EXLApplication::get_Dialogs() { + LPDISPATCH result; + InvokeHelper(0x2f9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +BOOL EXLApplication::get_DisplayAlerts() { + BOOL result; + InvokeHelper(0x157, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_DisplayAlerts(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x157, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_DisplayFormulaBar() { + BOOL result; + InvokeHelper(0x158, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_DisplayFormulaBar(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x158, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_DisplayFullScreen() { + BOOL result; + InvokeHelper(0x425, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_DisplayFullScreen(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x425, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_DisplayNoteIndicator() { + BOOL result; + InvokeHelper(0x159, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_DisplayNoteIndicator(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x159, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long EXLApplication::get_DisplayCommentIndicator() { + long result; + InvokeHelper(0x4ac, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_DisplayCommentIndicator(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x4ac, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_DisplayExcel4Menus() { + BOOL result; + InvokeHelper(0x39f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_DisplayExcel4Menus(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x39f, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_DisplayRecentFiles() { + BOOL result; + InvokeHelper(0x39e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_DisplayRecentFiles(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x39e, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_DisplayScrollBars() { + BOOL result; + InvokeHelper(0x15a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_DisplayScrollBars(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x15a, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_DisplayStatusBar() { + BOOL result; + InvokeHelper(0x15b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_DisplayStatusBar(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x15b, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +void EXLApplication::DoubleClick() { + InvokeHelper(0x15d, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +BOOL EXLApplication::get_EditDirectlyInCell() { + BOOL result; + InvokeHelper(0x3a1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_EditDirectlyInCell(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x3a1, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_EnableAutoComplete() { + BOOL result; + InvokeHelper(0x49b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_EnableAutoComplete(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x49b, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long EXLApplication::get_EnableCancelKey() { + long result; + InvokeHelper(0x448, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_EnableCancelKey(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x448, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_EnableSound() { + BOOL result; + InvokeHelper(0x4ad, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_EnableSound(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x4ad, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_EnableTipWizard() { + BOOL result; + InvokeHelper(0x428, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_EnableTipWizard(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x428, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +VARIANT EXLApplication::get_FileConverters(VARIANT Index1, VARIANT Index2) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x3a3, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, &Index1, &Index2); + return result; +} + +LPDISPATCH EXLApplication::get_FileSearch() { + LPDISPATCH result; + InvokeHelper(0x4b0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_FileFind() { + LPDISPATCH result; + InvokeHelper(0x4b1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +void EXLApplication::_FindFile() { + InvokeHelper(0x42c, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +BOOL EXLApplication::get_FixedDecimal() { + BOOL result; + InvokeHelper(0x15f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_FixedDecimal(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x15f, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long EXLApplication::get_FixedDecimalPlaces() { + long result; + InvokeHelper(0x160, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_FixedDecimalPlaces(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x160, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +VARIANT EXLApplication::GetCustomListContents(long ListNum) { + VARIANT result; + static BYTE parms[] = VTS_I4; + InvokeHelper(0x312, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, ListNum); + return result; +} + +long EXLApplication::GetCustomListNum(VARIANT ListArray) { + long result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x311, DISPATCH_METHOD, VT_I4, (void*)&result, parms, &ListArray); + return result; +} + +VARIANT EXLApplication::GetOpenFilename(VARIANT FileFilter, VARIANT FilterIndex, VARIANT Title, VARIANT ButtonText, VARIANT MultiSelect) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x433, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &FileFilter, &FilterIndex, &Title, &ButtonText, &MultiSelect); + return result; +} + +VARIANT EXLApplication::GetSaveAsFilename(VARIANT InitialFilename, VARIANT FileFilter, VARIANT FilterIndex, VARIANT Title, VARIANT ButtonText) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x434, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &InitialFilename, &FileFilter, &FilterIndex, &Title, &ButtonText); + return result; +} + +void EXLApplication::Goto(VARIANT Reference, VARIANT Scroll) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1db, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Reference, &Scroll); +} + +double EXLApplication::get_Height() { + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_Height(double newValue) { + static BYTE parms[] = VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +void EXLApplication::Help(VARIANT HelpFile, VARIANT HelpContextID) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x162, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &HelpFile, &HelpContextID); +} + +BOOL EXLApplication::get_IgnoreRemoteRequests() { + BOOL result; + InvokeHelper(0x164, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_IgnoreRemoteRequests(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x164, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +double EXLApplication::InchesToPoints(double Inches) { + double result; + static BYTE parms[] = VTS_R8; + InvokeHelper(0x43f, DISPATCH_METHOD, VT_R8, (void*)&result, parms, Inches); + return result; +} + +VARIANT EXLApplication::InputBox(LPCTSTR Prompt, VARIANT Title, VARIANT Default, VARIANT Left, VARIANT Top, VARIANT HelpFile, VARIANT HelpContextID, VARIANT Type) { + VARIANT result; + static BYTE parms[] = VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x165, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, Prompt, &Title, &Default, &Left, &Top, &HelpFile, &HelpContextID, &Type); + return result; +} + +BOOL EXLApplication::get_Interactive() { + BOOL result; + InvokeHelper(0x169, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_Interactive(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x169, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +VARIANT EXLApplication::get_International(VARIANT IndexType) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x16a, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, &IndexType); + return result; +} + +BOOL EXLApplication::get_Iteration() { + BOOL result; + InvokeHelper(0x16b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_Iteration(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x16b, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_LargeButtons() { + BOOL result; + InvokeHelper(0x16c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_LargeButtons(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x16c, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +double EXLApplication::get_Left() { + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_Left(double newValue) { + static BYTE parms[] = VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +CString EXLApplication::get_LibraryPath() { + CString result; + InvokeHelper(0x16e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +void EXLApplication::_MacroOptions(VARIANT Macro, VARIANT Description, VARIANT HasMenu, VARIANT MenuText, VARIANT HasShortcutKey, VARIANT ShortcutKey, VARIANT Category, VARIANT +StatusBar, VARIANT HelpContextID, VARIANT HelpFile) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x46f, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Macro, &Description, &HasMenu, &MenuText, &HasShortcutKey, &ShortcutKey, &Category, &StatusBar, &HelpContextID, &HelpFile); +} + +void EXLApplication::MailLogoff() { + InvokeHelper(0x3b1, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +void EXLApplication::MailLogon(VARIANT Name, VARIANT Password, VARIANT DownloadNewMail) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x3af, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Name, &Password, &DownloadNewMail); +} + +VARIANT EXLApplication::get_MailSession() { + VARIANT result; + InvokeHelper(0x3ae, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} + +long EXLApplication::get_MailSystem() { + long result; + InvokeHelper(0x3cb, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +BOOL EXLApplication::get_MathCoprocessorAvailable() { + BOOL result; + InvokeHelper(0x16f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +double EXLApplication::get_MaxChange() { + double result; + InvokeHelper(0x170, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_MaxChange(double newValue) { + static BYTE parms[] = VTS_R8; + InvokeHelper(0x170, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long EXLApplication::get_MaxIterations() { + long result; + InvokeHelper(0x171, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_MaxIterations(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x171, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long EXLApplication::get_MemoryFree() { + long result; + InvokeHelper(0x172, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +long EXLApplication::get_MemoryTotal() { + long result; + InvokeHelper(0x173, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +long EXLApplication::get_MemoryUsed() { + long result; + InvokeHelper(0x174, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +BOOL EXLApplication::get_MouseAvailable() { + BOOL result; + InvokeHelper(0x175, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +BOOL EXLApplication::get_MoveAfterReturn() { + BOOL result; + InvokeHelper(0x176, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_MoveAfterReturn(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x176, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long EXLApplication::get_MoveAfterReturnDirection() { + long result; + InvokeHelper(0x478, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_MoveAfterReturnDirection(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x478, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH EXLApplication::get_RecentFiles() { + LPDISPATCH result; + InvokeHelper(0x4b2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +CString EXLApplication::get_Name() { + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::NextLetter() { + LPDISPATCH result; + InvokeHelper(0x3cc, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +CString EXLApplication::get_NetworkTemplatesPath() { + CString result; + InvokeHelper(0x184, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_ODBCErrors() { + LPDISPATCH result; + InvokeHelper(0x4b3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +long EXLApplication::get_ODBCTimeout() { + long result; + InvokeHelper(0x4b4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_ODBCTimeout(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x4b4, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +CString EXLApplication::get_OnCalculate() { + CString result; + InvokeHelper(0x271, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_OnCalculate(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x271, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +CString EXLApplication::get_OnData() { + CString result; + InvokeHelper(0x275, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_OnData(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x275, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +CString EXLApplication::get_OnDoubleClick() { + CString result; + InvokeHelper(0x274, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_OnDoubleClick(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x274, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +CString EXLApplication::get_OnEntry() { + CString result; + InvokeHelper(0x273, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_OnEntry(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x273, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +void EXLApplication::OnKey(LPCTSTR Key, VARIANT Procedure) { + static BYTE parms[] = VTS_BSTR VTS_VARIANT; + InvokeHelper(0x272, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Key, &Procedure); +} + +void EXLApplication::OnRepeat(LPCTSTR Text, LPCTSTR Procedure) { + static BYTE parms[] = VTS_BSTR VTS_BSTR; + InvokeHelper(0x301, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Text, Procedure); +} + +CString EXLApplication::get_OnSheetActivate() { + CString result; + InvokeHelper(0x407, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_OnSheetActivate(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x407, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + + +CString EXLApplication::get_OnSheetDeactivate() { + CString result; + InvokeHelper(0x439, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_OnSheetDeactivate(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x439, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +void EXLApplication::OnTime(VARIANT EarliestTime, LPCTSTR Procedure, VARIANT LatestTime, VARIANT Schedule) { + static BYTE parms[] = VTS_VARIANT VTS_BSTR VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x270, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &EarliestTime, Procedure, &LatestTime, &Schedule); +} + +void EXLApplication::OnUndo(LPCTSTR Text, LPCTSTR Procedure) { + static BYTE parms[] = VTS_BSTR VTS_BSTR; + InvokeHelper(0x302, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Text, Procedure); +} + +CString EXLApplication::get_OnWindow() { + CString result; + InvokeHelper(0x26f, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_OnWindow(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x26f, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +CString EXLApplication::get_OperatingSystem() { + CString result; + InvokeHelper(0x177, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +CString EXLApplication::get_OrganizationName() { + CString result; + InvokeHelper(0x178, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +CString EXLApplication::get_Path() { + CString result; + InvokeHelper(0x123, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +CString EXLApplication::get_PathSeparator() { + CString result; + InvokeHelper(0x179, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +VARIANT EXLApplication::get_PreviousSelections(VARIANT IndexType) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x17a, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, &IndexType); + return result; +} + +BOOL EXLApplication::get_PivotTableSelection() { + BOOL result; + InvokeHelper(0x4b5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_PivotTableSelection(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x4b5, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_PromptForSummaryInfo() { + BOOL result; + InvokeHelper(0x426, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_PromptForSummaryInfo(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x426, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +void EXLApplication::Quit() { + InvokeHelper(0x12e, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +void EXLApplication::RecordMacro(VARIANT BasicCode, VARIANT XlmCode) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x305, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &BasicCode, &XlmCode); +} + +BOOL EXLApplication::get_RecordRelative() { + BOOL result; + InvokeHelper(0x17b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +long EXLApplication::get_ReferenceStyle() { + long result; + InvokeHelper(0x17c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_ReferenceStyle(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x17c, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +VARIANT EXLApplication::get_RegisteredFunctions(VARIANT Index1, VARIANT Index2) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x307, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, &Index1, &Index2); + return result; +} + +BOOL EXLApplication::RegisterXLL(LPCTSTR Filename) { + BOOL result; + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x1e, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, Filename); + return result; +} + +void EXLApplication::Repeat() { + InvokeHelper(0x12d, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +void EXLApplication::ResetTipWizard() { + InvokeHelper(0x3a0, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +BOOL EXLApplication::get_RollZoom() { + BOOL result; + InvokeHelper(0x4b6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_RollZoom(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x4b6, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +void EXLApplication::Save(VARIANT Filename) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x11b, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Filename); +} + +void EXLApplication::SaveWorkspace(VARIANT Filename) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0xd4, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Filename); +} + +BOOL EXLApplication::get_ScreenUpdating() { + BOOL result; + InvokeHelper(0x17e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_ScreenUpdating(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x17e, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +void EXLApplication::SetDefaultChart(VARIANT FormatName, VARIANT Gallery) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xdb, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &FormatName, &Gallery); +} + +long EXLApplication::get_SheetsInNewWorkbook() { + long result; + InvokeHelper(0x3e1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_SheetsInNewWorkbook(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x3e1, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_ShowChartTipNames() { + BOOL result; + InvokeHelper(0x4b7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_ShowChartTipNames(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x4b7, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_ShowChartTipValues() { + BOOL result; + InvokeHelper(0x4b8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_ShowChartTipValues(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x4b8, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +CString EXLApplication::get_StandardFont() { + CString result; + InvokeHelper(0x39c, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_StandardFont(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x39c, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +double EXLApplication::get_StandardFontSize() { + double result; + InvokeHelper(0x39d, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_StandardFontSize(double newValue) { + static BYTE parms[] = VTS_R8; + InvokeHelper(0x39d, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +CString EXLApplication::get_StartupPath() { + CString result; + InvokeHelper(0x181, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +VARIANT EXLApplication::get_StatusBar() { + VARIANT result; + InvokeHelper(0x182, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_StatusBar(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x182, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} + +CString EXLApplication::get_TemplatesPath() { + CString result; + InvokeHelper(0x17d, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +BOOL EXLApplication::get_ShowToolTips() { + BOOL result; + InvokeHelper(0x183, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_ShowToolTips(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x183, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +double EXLApplication::get_Top() { + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_Top(double newValue) { + static BYTE parms[] = VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long EXLApplication::get_DefaultSaveFormat() { + long result; + InvokeHelper(0x4b9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_DefaultSaveFormat(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x4b9, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +CString EXLApplication::get_TransitionMenuKey() { + CString result; + InvokeHelper(0x136, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_TransitionMenuKey(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x136, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long EXLApplication::get_TransitionMenuKeyAction() { + long result; + InvokeHelper(0x137, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_TransitionMenuKeyAction(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x137, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_TransitionNavigKeys() { + BOOL result; + InvokeHelper(0x138, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_TransitionNavigKeys(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x138, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +void EXLApplication::Undo() { + InvokeHelper(0x12f, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +double EXLApplication::get_UsableHeight() { + double result; + InvokeHelper(0x185, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, nullptr); + return result; +} + +double EXLApplication::get_UsableWidth() { + double result; + InvokeHelper(0x186, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, nullptr); + return result; +} + +BOOL EXLApplication::get_UserControl() { + BOOL result; + InvokeHelper(0x4ba, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_UserControl(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x4ba, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +CString EXLApplication::get_UserName() { + CString result; + InvokeHelper(0x187, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_UserName(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x187, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +CString EXLApplication::get_Value() { + CString result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_VBE() { + LPDISPATCH result; + InvokeHelper(0x4bb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +CString EXLApplication::get_Version() { + CString result; + InvokeHelper(0x188, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +BOOL EXLApplication::get_Visible() { + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_Visible(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +void EXLApplication::Volatile(VARIANT Volatile) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x314, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Volatile); +} + +void EXLApplication::_Wait(VARIANT Time) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x189, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Time); +} + +double EXLApplication::get_Width() { + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_Width(double newValue) { + static BYTE parms[] = VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_WindowsForPens() { + BOOL result; + InvokeHelper(0x18b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +long EXLApplication::get_WindowState() { + long result; + InvokeHelper(0x18c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_WindowState(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x18c, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long EXLApplication::get_UILanguage() { + long result; + InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_UILanguage(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long EXLApplication::get_DefaultSheetDirection() { + long result; + InvokeHelper(0xe5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_DefaultSheetDirection(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0xe5, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long EXLApplication::get_CursorMovement() { + long result; + InvokeHelper(0xe8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_CursorMovement(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0xe8, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_ControlCharacters() { + BOOL result; + InvokeHelper(0xe9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_ControlCharacters(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0xe9, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +VARIANT EXLApplication::_WSFunction(VARIANT Arg1, VARIANT Arg2, VARIANT Arg3, VARIANT Arg4, VARIANT Arg5, VARIANT Arg6, VARIANT Arg7, VARIANT Arg8, VARIANT Arg9, VARIANT Arg10, VARIANT Arg11, VARIANT Arg12, VARIANT Arg13, VARIANT Arg14, VARIANT Arg15, VARIANT Arg16, VARIANT Arg17, VARIANT Arg18, VARIANT Arg19, VARIANT Arg20, VARIANT Arg21, VARIANT Arg22, VARIANT Arg23, VARIANT Arg24, VARIANT Arg25, VARIANT Arg26, VARIANT Arg27, VARIANT Arg28, VARIANT Arg29, VARIANT Arg30) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xa9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +BOOL EXLApplication::get_EnableEvents() { + BOOL result; + InvokeHelper(0x4bc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_EnableEvents(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x4bc, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_DisplayInfoWindow() { + BOOL result; + InvokeHelper(0x4bd, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_DisplayInfoWindow(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x4bd, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::Wait(VARIANT Time) { + BOOL result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x6ea, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, &Time); + return result; +} + +BOOL EXLApplication::get_ExtendList() { + BOOL result; + InvokeHelper(0x701, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_ExtendList(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x701, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH EXLApplication::get_OLEDBErrors() { + LPDISPATCH result; + InvokeHelper(0x702, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +CString EXLApplication::GetPhonetic(VARIANT Text) { + CString result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x703, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms, &Text); + return result; +} + +LPDISPATCH EXLApplication::get_COMAddIns() { + LPDISPATCH result; + InvokeHelper(0x704, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_DefaultWebOptions() { + LPDISPATCH result; + InvokeHelper(0x705, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +CString EXLApplication::get_ProductCode() { + CString result; + InvokeHelper(0x706, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +CString EXLApplication::get_UserLibraryPath() { + CString result; + InvokeHelper(0x707, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +BOOL EXLApplication::get_AutoPercentEntry() { + BOOL result; + InvokeHelper(0x708, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_AutoPercentEntry(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x708, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH EXLApplication::get_LanguageSettings() { + LPDISPATCH result; + InvokeHelper(0x709, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_Dummy101() { + LPDISPATCH result; + InvokeHelper(0x70a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +void EXLApplication::Dummy12(LPDISPATCH p1, LPDISPATCH p2) { + static BYTE parms[] = VTS_DISPATCH VTS_DISPATCH; + InvokeHelper(0x70b, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, p1, p2); +} + +LPDISPATCH EXLApplication::get_AnswerWizard() { + LPDISPATCH result; + InvokeHelper(0x70c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +void EXLApplication::CalculateFull() { + InvokeHelper(0x70d, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +BOOL EXLApplication::FindFile() { + BOOL result; + InvokeHelper(0x6eb, DISPATCH_METHOD, VT_BOOL, (void*)&result, nullptr); + return result; +} + +long EXLApplication::get_CalculationVersion() { + long result; + InvokeHelper(0x70e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +BOOL EXLApplication::get_ShowWindowsInTaskbar() { + BOOL result; + InvokeHelper(0x70f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_ShowWindowsInTaskbar(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x70f, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long EXLApplication::get_FeatureInstall() { + long result; + InvokeHelper(0x710, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_FeatureInstall(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x710, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_Ready() { + BOOL result; + InvokeHelper(0x78c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +VARIANT EXLApplication::Dummy13(VARIANT Arg1, VARIANT Arg2, VARIANT Arg3, VARIANT Arg4, VARIANT Arg5, VARIANT Arg6, VARIANT Arg7, VARIANT Arg8, VARIANT Arg9, VARIANT Arg10, VARIANT Arg11, VARIANT Arg12, VARIANT Arg13, VARIANT Arg14, VARIANT Arg15, VARIANT Arg16, VARIANT Arg17, VARIANT Arg18, VARIANT Arg19, VARIANT Arg20, VARIANT Arg21, VARIANT Arg22, +VARIANT Arg23, VARIANT Arg24, VARIANT Arg25, VARIANT Arg26, VARIANT Arg27, VARIANT Arg28, VARIANT Arg29, VARIANT Arg30) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x78d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +LPDISPATCH EXLApplication::get_FindFormat() { + LPDISPATCH result; + InvokeHelper(0x78e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +void EXLApplication::putref_FindFormat(LPDISPATCH newValue) { + static BYTE parms[] = VTS_DISPATCH; + InvokeHelper(0x78e, DISPATCH_PROPERTYPUTREF, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH EXLApplication::get_ReplaceFormat() { + LPDISPATCH result; + InvokeHelper(0x78f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +void EXLApplication::putref_ReplaceFormat(LPDISPATCH newValue) { + static BYTE parms[] = VTS_DISPATCH; + InvokeHelper(0x78f, DISPATCH_PROPERTYPUTREF, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH EXLApplication::get_UsedObjects() { + LPDISPATCH result; + InvokeHelper(0x790, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +long EXLApplication::get_CalculationState() { + long result; + InvokeHelper(0x791, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +long EXLApplication::get_CalculationInterruptKey() { + long result; + InvokeHelper(0x792, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_CalculationInterruptKey(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x792, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH EXLApplication::get_Watches() { + LPDISPATCH result; + InvokeHelper(0x793, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +BOOL EXLApplication::get_DisplayFunctionToolTips() { + BOOL result; + InvokeHelper(0x794, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_DisplayFunctionToolTips(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x794, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long EXLApplication::get_AutomationSecurity() { + long result; + InvokeHelper(0x795, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_AutomationSecurity(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x795, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH EXLApplication::get_FileDialog(long fileDialogType) { + LPDISPATCH result; + static BYTE parms[] = VTS_I4; + InvokeHelper(0x796, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, fileDialogType); + return result; +} + +void EXLApplication::Dummy14() { + InvokeHelper(0x798, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +void EXLApplication::CalculateFullRebuild() { + InvokeHelper(0x799, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +BOOL EXLApplication::get_DisplayPasteOptions() { + BOOL result; + InvokeHelper(0x79a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_DisplayPasteOptions(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x79a, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_DisplayInsertOptions() { + BOOL result; + InvokeHelper(0x79b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_DisplayInsertOptions(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x79b, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_GenerateGetPivotData() { + BOOL result; + InvokeHelper(0x79c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_GenerateGetPivotData(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x79c, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH EXLApplication::get_AutoRecover() { + LPDISPATCH result; + InvokeHelper(0x79d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +long EXLApplication::get_Hwnd() { + long result; + InvokeHelper(0x79e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +long EXLApplication::get_Hinstance() { + long result; + InvokeHelper(0x79f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void EXLApplication::CheckAbort(VARIANT KeepAbort) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x7a0, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &KeepAbort); +} + +LPDISPATCH EXLApplication::get_ErrorCheckingOptions() { + LPDISPATCH result; + InvokeHelper(0x7a2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +BOOL EXLApplication::get_AutoFormatAsYouTypeReplaceHyperlinks() { + BOOL result; + InvokeHelper(0x7a3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_AutoFormatAsYouTypeReplaceHyperlinks(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x7a3, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH EXLApplication::get_SmartTagRecognizers() { + LPDISPATCH result; + InvokeHelper(0x7a4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_NewWorkbook() { + LPDISPATCH result; + InvokeHelper(0x61d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_SpellingOptions() { + LPDISPATCH result; + InvokeHelper(0x7a5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_Speech() { + LPDISPATCH result; + InvokeHelper(0x7a6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +BOOL EXLApplication::get_MapPaperSize() { + BOOL result; + InvokeHelper(0x7a7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_MapPaperSize(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x7a7, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_ShowStartupDialog() { + BOOL result; + InvokeHelper(0x7a8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_ShowStartupDialog(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x7a8, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +CString EXLApplication::get_DecimalSeparator() { + CString result; + InvokeHelper(0x711, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_DecimalSeparator(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x711, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +CString EXLApplication::get_ThousandsSeparator() { + CString result; + InvokeHelper(0x712, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_ThousandsSeparator(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x712, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_UseSystemSeparators() { + BOOL result; + InvokeHelper(0x7a9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_UseSystemSeparators(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x7a9, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH EXLApplication::get_ThisCell() { + LPDISPATCH result; + InvokeHelper(0x7aa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_RTD() { + LPDISPATCH result; + InvokeHelper(0x7ab, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +BOOL EXLApplication::get_DisplayDocumentActionTaskPane() { + BOOL result; + InvokeHelper(0x8cb, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_DisplayDocumentActionTaskPane(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x8cb, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +void EXLApplication::DisplayXMLSourcePane(VARIANT XmlMap) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x8cc, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &XmlMap); +} + +BOOL EXLApplication::get_ArbitraryXMLSupportAvailable() { + BOOL result; + InvokeHelper(0x8ce, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +VARIANT EXLApplication::Support(LPDISPATCH Object, long ID, VARIANT arg) { + VARIANT result; + static BYTE parms[] = VTS_DISPATCH VTS_I4 VTS_VARIANT; + InvokeHelper(0x8cf, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, Object, ID, &arg); + return result; +} + +VARIANT EXLApplication::Dummy20(long grfCompareFunctions) { + VARIANT result; + static BYTE parms[] = VTS_I4; + InvokeHelper(0x945, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, grfCompareFunctions); + return result; +} + +long EXLApplication::get_MeasurementUnit() { + long result; + InvokeHelper(0x947, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_MeasurementUnit(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x947, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_ShowSelectionFloaties() { + BOOL result; + InvokeHelper(0x948, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_ShowSelectionFloaties(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x948, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_ShowMenuFloaties() { + BOOL result; + InvokeHelper(0x949, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_ShowMenuFloaties(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x949, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_ShowDevTools() { + BOOL result; + InvokeHelper(0x94a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_ShowDevTools(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x94a, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_EnableLivePreview() { + BOOL result; + InvokeHelper(0x94b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_EnableLivePreview(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x94b, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_DisplayDocumentInformationPanel() { + BOOL result; + InvokeHelper(0x94c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_DisplayDocumentInformationPanel(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x94c, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_AlwaysUseClearType() { + BOOL result; + InvokeHelper(0x94d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_AlwaysUseClearType(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x94d, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_WarnOnFunctionNameConflict() { + BOOL result; + InvokeHelper(0x94e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_WarnOnFunctionNameConflict(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x94e, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long EXLApplication::get_FormulaBarHeight() { + long result; + InvokeHelper(0x94f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_FormulaBarHeight(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x94f, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_DisplayFormulaAutoComplete() { + BOOL result; + InvokeHelper(0x950, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_DisplayFormulaAutoComplete(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x950, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long EXLApplication::get_GenerateTableRefs() { + long result; + InvokeHelper(0x951, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_GenerateTableRefs(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x951, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH EXLApplication::get_Assistance() { + LPDISPATCH result; + InvokeHelper(0x952, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void EXLApplication::CalculateUntilAsyncQueriesDone() { + InvokeHelper(0x953, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +BOOL EXLApplication::get_EnableLargeOperationAlert() { + BOOL result; + InvokeHelper(0x954, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_EnableLargeOperationAlert(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x954, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long EXLApplication::get_LargeOperationCellThousandCount() { + long result; + InvokeHelper(0x955, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_LargeOperationCellThousandCount(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x955, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_DeferAsyncQueries() { + BOOL result; + InvokeHelper(0x956, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_DeferAsyncQueries(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x956, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH EXLApplication::get_MultiThreadedCalculation() { + LPDISPATCH result; + InvokeHelper(0x957, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +long EXLApplication::SharePointVersion(LPCTSTR bstrUrl) { + long result; + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x958, DISPATCH_METHOD, VT_I4, (void*)&result, parms, bstrUrl); + return result; +} + +long EXLApplication::get_ActiveEncryptionSession() { + long result; + InvokeHelper(0x95a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +BOOL EXLApplication::get_HighQualityModeForGraphics() { + BOOL result; + InvokeHelper(0x95b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_HighQualityModeForGraphics(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x95b, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH EXLApplication::get_FileExportConverters() { + LPDISPATCH result; + InvokeHelper(0xad0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_SmartArtLayouts() { + LPDISPATCH result; + InvokeHelper(0xad4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_SmartArtQuickStyles() { + LPDISPATCH result; + InvokeHelper(0xad5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_SmartArtColors() { + LPDISPATCH result; + InvokeHelper(0xad6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_AddIns2() { + LPDISPATCH result; + InvokeHelper(0xad7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +BOOL EXLApplication::get_PrintCommunication() { + BOOL result; + InvokeHelper(0xad8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_PrintCommunication(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0xad8, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +void EXLApplication::MacroOptions(VARIANT Macro, VARIANT Description, VARIANT HasMenu, VARIANT MenuText, VARIANT HasShortcutKey, VARIANT ShortcutKey, VARIANT Category, VARIANT StatusBar, VARIANT HelpContextID, VARIANT HelpFile, VARIANT ArgumentDescriptions) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xad2, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Macro, &Description, &HasMenu, &MenuText, &HasShortcutKey, &ShortcutKey, &Category, &StatusBar, &HelpContextID, &HelpFile, &ArgumentDescriptions); +} + +BOOL EXLApplication::get_UseClusterConnector() { + BOOL result; + InvokeHelper(0xada, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_UseClusterConnector(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0xada, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +CString EXLApplication::get_ClusterConnector() { + CString result; + InvokeHelper(0xadb, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_ClusterConnector(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0xadb, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_Quitting() { + BOOL result; + InvokeHelper(0xadc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +BOOL EXLApplication::get_Dummy22() { + BOOL result; + InvokeHelper(0xadd, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_Dummy22(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0xadd, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_Dummy23() { + BOOL result; + InvokeHelper(0xade, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_Dummy23(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0xade, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH EXLApplication::get_ProtectedViewWindows() { + LPDISPATCH result; + InvokeHelper(0xadf, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLApplication::get_ActiveProtectedViewWindow() { + LPDISPATCH result; + InvokeHelper(0xae0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +BOOL EXLApplication::get_IsSandboxed() { + BOOL result; + InvokeHelper(0xae1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +BOOL EXLApplication::get_SaveISO8601Dates() { + BOOL result; + InvokeHelper(0xae2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_SaveISO8601Dates(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0xae2, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +VARIANT EXLApplication::get_HinstancePtr() { + VARIANT result; + InvokeHelper(0xae3, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +long EXLApplication::get_FileValidation() { + long result; + InvokeHelper(0xae4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_FileValidation(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0xae4, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long EXLApplication::get_FileValidationPivot() { + long result; + InvokeHelper(0xae5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_FileValidationPivot(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0xae5, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_ShowQuickAnalysis() { + BOOL result; + InvokeHelper(0xbb2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_ShowQuickAnalysis(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0xbb2, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH EXLApplication::get_QuickAnalysis() { + LPDISPATCH result; + InvokeHelper(0xbb3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +BOOL EXLApplication::get_FlashFill() { + BOOL result; + InvokeHelper(0xbb4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_FlashFill(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0xbb4, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_EnableMacroAnimations() { + BOOL result; + InvokeHelper(0xbb5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_EnableMacroAnimations(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0xbb5, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_ChartDataPointTrack() { + BOOL result; + InvokeHelper(0xbb6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_ChartDataPointTrack(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0xbb6, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_FlashFillMode() { + BOOL result; + InvokeHelper(0xbb7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_FlashFillMode(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0xbb7, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_MergeInstances() { + BOOL result; + InvokeHelper(0xbb8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_MergeInstances(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0xbb8, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL EXLApplication::get_EnableCheckFileExtensions() { + BOOL result; + InvokeHelper(0xc56, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void EXLApplication::put_EnableCheckFileExtensions(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0xc56, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +} // namespace MSO::Excel + +#pragma warning( pop ) \ No newline at end of file diff --git a/src/excel/EXLRange.cpp b/src/excel/EXLRange.cpp new file mode 100644 index 0000000..edc7875 --- /dev/null +++ b/src/excel/EXLRange.cpp @@ -0,0 +1,1115 @@ +#include "stdafx.h" + +#include "office/excel/EXLRange.h" + +#pragma warning( push ) +#pragma warning( disable : 26493 26485 26494 ) + +namespace MSO::Excel { + +LPDISPATCH EXLRange::get_Application() { + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long EXLRange::get_Creator() { + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLRange::get_Parent() { + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::Activate() { + VARIANT result; + InvokeHelper(0x130, DISPATCH_METHOD, VT_VARIANT, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::get_AddIndent() { + VARIANT result; + InvokeHelper(0x427, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLRange::put_AddIndent(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x427, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +CString EXLRange::get_Address(VARIANT RowAbsolute, VARIANT ColumnAbsolute, long ReferenceStyle, VARIANT External, VARIANT RelativeTo) { + CString result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xec, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms, &RowAbsolute, &ColumnAbsolute, ReferenceStyle, &External, &RelativeTo); + return result; +} +CString EXLRange::get_AddressLocal(VARIANT RowAbsolute, VARIANT ColumnAbsolute, long ReferenceStyle, VARIANT External, VARIANT RelativeTo) { + CString result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1b5, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms, &RowAbsolute, &ColumnAbsolute, ReferenceStyle, &External, &RelativeTo); + return result; +} +VARIANT EXLRange::AdvancedFilter(long Action, VARIANT CriteriaRange, VARIANT CopyToRange, VARIANT Unique) { + VARIANT result; + static BYTE parms[] = VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x36c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, Action, &CriteriaRange, &CopyToRange, &Unique); + return result; +} +VARIANT EXLRange::ApplyNames(VARIANT Names, VARIANT IgnoreRelativeAbsolute, VARIANT UseRowColumnNames, VARIANT OmitColumn, VARIANT OmitRow, long Order, VARIANT AppendLast) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT; + InvokeHelper(0x1b9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Names, &IgnoreRelativeAbsolute, &UseRowColumnNames, &OmitColumn, &OmitRow, Order, &AppendLast); + return result; +} +VARIANT EXLRange::ApplyOutlineStyles() { + VARIANT result; + InvokeHelper(0x1c0, DISPATCH_METHOD, VT_VARIANT, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLRange::get_Areas() { + LPDISPATCH result; + InvokeHelper(0x238, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +CString EXLRange::AutoComplete(LPCTSTR String) { + CString result; + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x4a1, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms, String); + return result; +} +VARIANT EXLRange::AutoFill(LPDISPATCH Destination, long Type) { + VARIANT result; + static BYTE parms[] = VTS_DISPATCH VTS_I4; + InvokeHelper(0x1c1, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, Destination, Type); + return result; +} +VARIANT EXLRange::AutoFilter(VARIANT Field, VARIANT Criteria1, long Operator, VARIANT Criteria2, VARIANT VisibleDropDown) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x319, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Field, &Criteria1, Operator, &Criteria2, &VisibleDropDown); + return result; +} +VARIANT EXLRange::AutoFit() { + VARIANT result; + InvokeHelper(0xed, DISPATCH_METHOD, VT_VARIANT, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::AutoFormat(long Format, VARIANT Number, VARIANT Font, VARIANT Alignment, VARIANT Border, VARIANT Pattern, VARIANT Width) { + VARIANT result; + static BYTE parms[] = VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x72, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, Format, &Number, &Font, &Alignment, &Border, &Pattern, &Width); + return result; +} +VARIANT EXLRange::AutoOutline() { + VARIANT result; + InvokeHelper(0x40c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::_BorderAround(VARIANT LineStyle, long Weight, long ColorIndex, VARIANT Color) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_I4 VTS_I4 VTS_VARIANT; + InvokeHelper(0x42b, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &LineStyle, Weight, ColorIndex, &Color); + return result; +} +LPDISPATCH EXLRange::get_Borders() { + LPDISPATCH result; + InvokeHelper(0x1b3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::Calculate() { + VARIANT result; + InvokeHelper(0x117, DISPATCH_METHOD, VT_VARIANT, (void*)&result, nullptr); + return result; +} +EXLRange EXLRange::get_Cells() { + LPDISPATCH result; + InvokeHelper(0xee, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLRange::get_Characters(VARIANT Start, VARIANT Length) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, &Start, &Length); + return result; +} +VARIANT EXLRange::CheckSpelling(VARIANT CustomDictionary, VARIANT IgnoreUppercase, VARIANT AlwaysSuggest, VARIANT SpellLang) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); + return result; +} +VARIANT EXLRange::Clear() { + VARIANT result; + InvokeHelper(0x6f, DISPATCH_METHOD, VT_VARIANT, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::ClearContents() { + VARIANT result; + InvokeHelper(0x71, DISPATCH_METHOD, VT_VARIANT, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::ClearFormats() { + VARIANT result; + InvokeHelper(0x70, DISPATCH_METHOD, VT_VARIANT, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::ClearNotes() { + VARIANT result; + InvokeHelper(0xef, DISPATCH_METHOD, VT_VARIANT, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::ClearOutline() { + VARIANT result; + InvokeHelper(0x40d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, nullptr); + return result; +} +long EXLRange::get_Column() { + long result; + InvokeHelper(0xf0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLRange::ColumnDifferences(VARIANT Comparison) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x1fe, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &Comparison); + return result; +} +EXLRange EXLRange::get_Columns() { + LPDISPATCH result; + InvokeHelper(0xf1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::get_ColumnWidth() { + VARIANT result; + InvokeHelper(0xf2, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLRange::put_ColumnWidth(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0xf2, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +VARIANT EXLRange::Consolidate(VARIANT Sources, VARIANT Function, VARIANT TopRow, VARIANT LeftColumn, VARIANT CreateLinks) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1e2, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Sources, &Function, &TopRow, &LeftColumn, &CreateLinks); + return result; +} +VARIANT EXLRange::Copy(VARIANT Destination) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Destination); + return result; +} +long EXLRange::CopyFromRecordset(LPUNKNOWN Data, VARIANT MaxRows, VARIANT MaxColumns) { + long result; + static BYTE parms[] = VTS_UNKNOWN VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x480, DISPATCH_METHOD, VT_I4, (void*)&result, parms, Data, &MaxRows, &MaxColumns); + return result; +} +VARIANT EXLRange::CopyPicture(long Appearance, long Format) { + VARIANT result; + static BYTE parms[] = VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, Appearance, Format); + return result; +} +long EXLRange::get_Count() { + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::CreateNames(VARIANT Top, VARIANT Left, VARIANT Bottom, VARIANT Right) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1c9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Top, &Left, &Bottom, &Right); + return result; +} +VARIANT EXLRange::CreatePublisher(VARIANT Edition, long Appearance, VARIANT ContainsPICT, VARIANT ContainsBIFF, VARIANT ContainsRTF, VARIANT ContainsVALU) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1ca, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Edition, Appearance, &ContainsPICT, &ContainsBIFF, &ContainsRTF, &ContainsVALU); + return result; +} +LPDISPATCH EXLRange::get_CurrentArray() { + LPDISPATCH result; + InvokeHelper(0x1f5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLRange::get_CurrentRegion() { + LPDISPATCH result; + InvokeHelper(0xf3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::Cut(VARIANT Destination) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Destination); + return result; +} +VARIANT EXLRange::DataSeries(VARIANT Rowcol, long Type, long Date, VARIANT Step, VARIANT Stop, VARIANT Trend) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_I4 VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1d0, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Rowcol, Type, Date, &Step, &Stop, &Trend); + return result; +} +VARIANT EXLRange::get__Default(VARIANT RowIndex, VARIANT ColumnIndex) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, &RowIndex, &ColumnIndex); + return result; +} +void EXLRange::put__Default(VARIANT RowIndex, VARIANT ColumnIndex, VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &RowIndex, &ColumnIndex, &newValue); +} +VARIANT EXLRange::Delete(VARIANT Shift) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Shift); + return result; +} +LPDISPATCH EXLRange::get_Dependents() { + LPDISPATCH result; + InvokeHelper(0x21f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::DialogBox() { + VARIANT result; + InvokeHelper(0xf5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLRange::get_DirectDependents() { + LPDISPATCH result; + InvokeHelper(0x221, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLRange::get_DirectPrecedents() { + LPDISPATCH result; + InvokeHelper(0x222, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::EditionOptions(long Type, long Option, VARIANT Name, VARIANT Reference, long Appearance, long ChartSize, VARIANT Format) { + VARIANT result; + static BYTE parms[] = VTS_I4 VTS_I4 VTS_VARIANT VTS_VARIANT VTS_I4 VTS_I4 VTS_VARIANT; + InvokeHelper(0x46b, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, Type, Option, &Name, &Reference, Appearance, ChartSize, &Format); + return result; +} +LPDISPATCH EXLRange::get_End(long Direction) { + LPDISPATCH result; + static BYTE parms[] = VTS_I4; + InvokeHelper(0x1f4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, Direction); + return result; +} +LPDISPATCH EXLRange::get_EntireColumn() { + LPDISPATCH result; + InvokeHelper(0xf6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLRange::get_EntireRow() { + LPDISPATCH result; + InvokeHelper(0xf7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::FillDown() { + VARIANT result; + InvokeHelper(0xf8, DISPATCH_METHOD, VT_VARIANT, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::FillLeft() { + VARIANT result; + InvokeHelper(0xf9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::FillRight() { + VARIANT result; + InvokeHelper(0xfa, DISPATCH_METHOD, VT_VARIANT, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::FillUp() { + VARIANT result; + InvokeHelper(0xfb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLRange::Find(VARIANT What, VARIANT After, VARIANT LookIn, VARIANT LookAt, VARIANT SearchOrder, long SearchDirection, VARIANT MatchCase, VARIANT MatchByte, VARIANT SearchFormat) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x18e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &What, &After, &LookIn, &LookAt, &SearchOrder, SearchDirection, &MatchCase, &MatchByte, &SearchFormat); + return result; +} +LPDISPATCH EXLRange::FindNext(VARIANT After) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x18f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &After); + return result; +} +LPDISPATCH EXLRange::FindPrevious(VARIANT After) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x190, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &After); + return result; +} +LPDISPATCH EXLRange::get_Font() { + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::get_Formula() { + VARIANT result; + InvokeHelper(0x105, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLRange::put_Formula(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x105, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +VARIANT EXLRange::get_FormulaArray() { + VARIANT result; + InvokeHelper(0x24a, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLRange::put_FormulaArray(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x24a, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +long EXLRange::get_FormulaLabel() { + long result; + InvokeHelper(0x564, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void EXLRange::put_FormulaLabel(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x564, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +VARIANT EXLRange::get_FormulaHidden() { + VARIANT result; + InvokeHelper(0x106, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLRange::put_FormulaHidden(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x106, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +VARIANT EXLRange::get_FormulaLocal() { + VARIANT result; + InvokeHelper(0x107, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLRange::put_FormulaLocal(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x107, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +VARIANT EXLRange::get_FormulaR1C1() { + VARIANT result; + InvokeHelper(0x108, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLRange::put_FormulaR1C1(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x108, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +VARIANT EXLRange::get_FormulaR1C1Local() { + VARIANT result; + InvokeHelper(0x109, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLRange::put_FormulaR1C1Local(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x109, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +VARIANT EXLRange::FunctionWizard() { + VARIANT result; + InvokeHelper(0x23b, DISPATCH_METHOD, VT_VARIANT, (void*)&result, nullptr); + return result; +} +BOOL EXLRange::GoalSeek(VARIANT Goal, LPDISPATCH ChangingCell) { + BOOL result; + static BYTE parms[] = VTS_VARIANT VTS_DISPATCH; + InvokeHelper(0x1d8, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, &Goal, ChangingCell); + return result; +} +VARIANT EXLRange::Group(VARIANT Start, VARIANT End, VARIANT By, VARIANT Periods) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x2e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Start, &End, &By, &Periods); + return result; +} +VARIANT EXLRange::get_HasArray() { + VARIANT result; + InvokeHelper(0x10a, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::get_HasFormula() { + VARIANT result; + InvokeHelper(0x10b, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::get_Height() { + VARIANT result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::get_Hidden() { + VARIANT result; + InvokeHelper(0x10c, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLRange::put_Hidden(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x10c, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +VARIANT EXLRange::get_HorizontalAlignment() { + VARIANT result; + InvokeHelper(0x88, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLRange::put_HorizontalAlignment(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x88, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +VARIANT EXLRange::get_IndentLevel() { + VARIANT result; + InvokeHelper(0xc9, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLRange::put_IndentLevel(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0xc9, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +void EXLRange::InsertIndent(long InsertAmount) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x565, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, InsertAmount); +} +VARIANT EXLRange::Insert(VARIANT Shift, VARIANT CopyOrigin) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xfc, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Shift, &CopyOrigin); + return result; +} +LPDISPATCH EXLRange::get_Interior() { + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +EXLRange EXLRange::get_Item(VARIANT RowIndex, VARIANT ColumnIndex) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, &RowIndex, &ColumnIndex); + return result.pdispVal; +} +void EXLRange::put_Item(long RowIndex, long ColumnIndex, const VARIANT& newValue) { + put_Item(_variant_t(RowIndex), _variant_t(ColumnIndex), newValue); +} +void EXLRange::put_Item(VARIANT RowIndex, VARIANT ColumnIndex, VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &RowIndex, &ColumnIndex, &newValue); +} +VARIANT EXLRange::Justify() { + VARIANT result; + InvokeHelper(0x1ef, DISPATCH_METHOD, VT_VARIANT, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::get_Left() { + VARIANT result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +long EXLRange::get_ListHeaderRows() { + long result; + InvokeHelper(0x4a3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::ListNames() { + VARIANT result; + InvokeHelper(0xfd, DISPATCH_METHOD, VT_VARIANT, (void*)&result, nullptr); + return result; +} +long EXLRange::get_LocationInTable() { + long result; + InvokeHelper(0x2b3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::get_Locked() { + VARIANT result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLRange::put_Locked(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +void EXLRange::Merge(VARIANT Across) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x234, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Across); +} +void EXLRange::UnMerge() { + InvokeHelper(0x568, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +LPDISPATCH EXLRange::get_MergeArea() { + LPDISPATCH result; + InvokeHelper(0x569, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::get_MergeCells() { + VARIANT result; + InvokeHelper(0xd0, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLRange::put_MergeCells(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0xd0, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +VARIANT EXLRange::get_Name() { + VARIANT result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLRange::put_Name(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +VARIANT EXLRange::NavigateArrow(VARIANT TowardPrecedent, VARIANT ArrowNumber, VARIANT LinkNumber) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x408, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &TowardPrecedent, &ArrowNumber, &LinkNumber); + return result; +} +LPUNKNOWN EXLRange::get_NewEnum() { + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLRange::get_Next() { + LPDISPATCH result; + InvokeHelper(0x1f6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +CString EXLRange::NoteText(VARIANT Text, VARIANT Start, VARIANT Length) { + CString result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x467, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms, &Text, &Start, &Length); + return result; +} +VARIANT EXLRange::get_NumberFormat() { + VARIANT result; + InvokeHelper(0xc1, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLRange::put_NumberFormat(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0xc1, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +VARIANT EXLRange::get_NumberFormatLocal() { + VARIANT result; + InvokeHelper(0x449, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLRange::put_NumberFormatLocal(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x449, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +LPDISPATCH EXLRange::get_Offset(VARIANT RowOffset, VARIANT ColumnOffset) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xfe, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, &RowOffset, &ColumnOffset); + return result; +} +VARIANT EXLRange::get_Orientation() { + VARIANT result; + InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLRange::put_Orientation(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +VARIANT EXLRange::get_OutlineLevel() { + VARIANT result; + InvokeHelper(0x10f, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLRange::put_OutlineLevel(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x10f, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +long EXLRange::get_PageBreak() { + long result; + InvokeHelper(0xff, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void EXLRange::put_PageBreak(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0xff, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +VARIANT EXLRange::Parse(VARIANT ParseLine, VARIANT Destination) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1dd, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &ParseLine, &Destination); + return result; +} +VARIANT EXLRange::_PasteSpecial(long Paste, long Operation, VARIANT SkipBlanks, VARIANT Transpose) { + VARIANT result; + static BYTE parms[] = VTS_I4 VTS_I4 VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x403, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, Paste, Operation, &SkipBlanks, &Transpose); + return result; +} +LPDISPATCH EXLRange::get_PivotField() { + LPDISPATCH result; + InvokeHelper(0x2db, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLRange::get_PivotItem() { + LPDISPATCH result; + InvokeHelper(0x2e4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLRange::get_PivotTable() { + LPDISPATCH result; + InvokeHelper(0x2cc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLRange::get_Precedents() { + LPDISPATCH result; + InvokeHelper(0x220, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::get_PrefixCharacter() { + VARIANT result; + InvokeHelper(0x1f8, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLRange::get_Previous() { + LPDISPATCH result; + InvokeHelper(0x1f7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::__PrintOut(VARIANT From, VARIANT To, VARIANT Copies, VARIANT Preview, VARIANT ActivePrinter, VARIANT PrintToFile, VARIANT Collate) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x389, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate); + return result; +} +VARIANT EXLRange::PrintPreview(VARIANT EnableChanges) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x119, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &EnableChanges); + return result; +} +LPDISPATCH EXLRange::get_QueryTable() { + LPDISPATCH result; + InvokeHelper(0x56a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLRange::get_Range(VARIANT Cell1, VARIANT Cell2) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xc5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, &Cell1, &Cell2); + return result; +} +VARIANT EXLRange::RemoveSubtotal() { + VARIANT result; + InvokeHelper(0x373, DISPATCH_METHOD, VT_VARIANT, (void*)&result, nullptr); + return result; +} +BOOL EXLRange::Replace(VARIANT What, VARIANT Replacement, VARIANT LookAt, VARIANT SearchOrder, VARIANT MatchCase, VARIANT MatchByte, VARIANT SearchFormat, VARIANT ReplaceFormat) { + BOOL result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xe2, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, &What, &Replacement, &LookAt, &SearchOrder, &MatchCase, &MatchByte, &SearchFormat, &ReplaceFormat); + return result; +} +LPDISPATCH EXLRange::get_Resize(VARIANT RowSize, VARIANT ColumnSize) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x100, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, &RowSize, &ColumnSize); + return result; +} +long EXLRange::get_Row() { + long result; + InvokeHelper(0x101, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLRange::RowDifferences(VARIANT Comparison) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x1ff, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &Comparison); + return result; +} +VARIANT EXLRange::get_RowHeight() { + VARIANT result; + InvokeHelper(0x110, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLRange::put_RowHeight(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x110, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +EXLRange EXLRange::get_Rows() { + LPDISPATCH result; + InvokeHelper(0x102, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::Run(VARIANT Arg1, VARIANT Arg2, VARIANT Arg3, VARIANT Arg4, VARIANT Arg5, VARIANT Arg6, VARIANT Arg7, VARIANT Arg8, VARIANT Arg9, VARIANT Arg10, VARIANT Arg11, VARIANT Arg12, VARIANT Arg13, VARIANT Arg14, VARIANT Arg15, VARIANT Arg16, VARIANT Arg17, VARIANT Arg18, VARIANT Arg19, VARIANT Arg20, VARIANT Arg21, VARIANT Arg22, VARIANT Arg23, VARIANT Arg24, VARIANT Arg25, VARIANT Arg26, VARIANT Arg27, VARIANT Arg28, VARIANT Arg29, VARIANT Arg30) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x103, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} +VARIANT EXLRange::Select() { + VARIANT result; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::Show() { + VARIANT result; + InvokeHelper(0x1f0, DISPATCH_METHOD, VT_VARIANT, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::ShowDependents(VARIANT Remove) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x36d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Remove); + return result; +} +VARIANT EXLRange::get_ShowDetail() { + VARIANT result; + InvokeHelper(0x249, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLRange::put_ShowDetail(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x249, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +VARIANT EXLRange::ShowErrors() { + VARIANT result; + InvokeHelper(0x36e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::ShowPrecedents(VARIANT Remove) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x36f, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Remove); + return result; +} +VARIANT EXLRange::get_ShrinkToFit() { + VARIANT result; + InvokeHelper(0xd1, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLRange::put_ShrinkToFit(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0xd1, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +VARIANT EXLRange::Sort(VARIANT Key1, long Order1, VARIANT Key2, VARIANT Type, long Order2, VARIANT Key3, long Order3, long Header, VARIANT OrderCustom, VARIANT MatchCase, long Orientation, long SortMethod, long DataOption1, long DataOption2, long DataOption3) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT VTS_I4 VTS_I4 VTS_VARIANT VTS_VARIANT VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4; + InvokeHelper(0x370, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Key1, Order1, &Key2, &Type, Order2, &Key3, Order3, Header, &OrderCustom, &MatchCase, Orientation, SortMethod, DataOption1, DataOption2, DataOption3); + return result; +} +VARIANT EXLRange::SortSpecial(long SortMethod, VARIANT Key1, long Order1, VARIANT Type, VARIANT Key2, long Order2, VARIANT Key3, long Order3, long Header, VARIANT OrderCustom, VARIANT MatchCase, long Orientation, long DataOption1, long DataOption2, long DataOption3) { + VARIANT result; + static BYTE parms[] = VTS_I4 VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT VTS_I4 VTS_I4 VTS_VARIANT VTS_VARIANT VTS_I4 VTS_I4 VTS_I4 VTS_I4; + InvokeHelper(0x371, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, SortMethod, &Key1, Order1, &Type, &Key2, Order2, &Key3, Order3, Header, &OrderCustom, &MatchCase, Orientation, DataOption1, DataOption2, DataOption3); + return result; +} +LPDISPATCH EXLRange::get_SoundNote() { + LPDISPATCH result; + InvokeHelper(0x394, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLRange::SpecialCells(long Type, VARIANT Value) { + LPDISPATCH result; + static BYTE parms[] = VTS_I4 VTS_VARIANT; + InvokeHelper(0x19a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Type, &Value); + return result; +} +VARIANT EXLRange::get_Style() { + VARIANT result; + InvokeHelper(0x104, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLRange::put_Style(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x104, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +VARIANT EXLRange::SubscribeTo(LPCTSTR Edition, long Format) { + VARIANT result; + static BYTE parms[] = VTS_BSTR VTS_I4; + InvokeHelper(0x1e1, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, Edition, Format); + return result; +} +VARIANT EXLRange::Subtotal(long GroupBy, long Function, VARIANT TotalList, VARIANT Replace, VARIANT PageBreaks, long SummaryBelowData) { + VARIANT result; + static BYTE parms[] = VTS_I4 VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_I4; + InvokeHelper(0x372, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, GroupBy, Function, &TotalList, &Replace, &PageBreaks, SummaryBelowData); + return result; +} +VARIANT EXLRange::get_Summary() { + VARIANT result; + InvokeHelper(0x111, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::Table(VARIANT RowInput, VARIANT ColumnInput) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f1, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &RowInput, &ColumnInput); + return result; +} +VARIANT EXLRange::get_Text() { + VARIANT result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::TextToColumns(VARIANT Destination, long DataType, long TextQualifier, VARIANT ConsecutiveDelimiter, VARIANT Tab, VARIANT Semicolon, VARIANT Comma, VARIANT Space, VARIANT Other, VARIANT OtherChar, VARIANT FieldInfo, VARIANT DecimalSeparator, VARIANT ThousandsSeparator, VARIANT TrailingMinusNumbers) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_I4 VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x410, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Destination, DataType, TextQualifier, &ConsecutiveDelimiter, &Tab, &Semicolon, &Comma, &Space, &Other, &OtherChar, &FieldInfo, &DecimalSeparator, &ThousandsSeparator, &TrailingMinusNumbers); + return result; +} +VARIANT EXLRange::get_Top() { + VARIANT result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::Ungroup() { + VARIANT result; + InvokeHelper(0xf4, DISPATCH_METHOD, VT_VARIANT, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::get_UseStandardHeight() { + VARIANT result; + InvokeHelper(0x112, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLRange::put_UseStandardHeight(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x112, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +VARIANT EXLRange::get_UseStandardWidth() { + VARIANT result; + InvokeHelper(0x113, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLRange::put_UseStandardWidth(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x113, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +LPDISPATCH EXLRange::get_Validation() { + LPDISPATCH result; + InvokeHelper(0x56b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::get_Value(VARIANT RangeValueDataType) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, &RangeValueDataType); + return result; +} +void EXLRange::put_Value(VARIANT RangeValueDataType, VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &RangeValueDataType, &newValue); +} +VARIANT EXLRange::get_Value2() { + VARIANT result; + InvokeHelper(0x56c, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLRange::put_Value2(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x56c, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +VARIANT EXLRange::get_VerticalAlignment() { + VARIANT result; + InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLRange::put_VerticalAlignment(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x89, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +VARIANT EXLRange::get_Width() { + VARIANT result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLRange::get_Worksheet() { + LPDISPATCH result; + InvokeHelper(0x15c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::get_WrapText() { + VARIANT result; + InvokeHelper(0x114, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLRange::put_WrapText(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x114, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +LPDISPATCH EXLRange::AddComment(VARIANT Text) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x56d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &Text); + return result; +} +LPDISPATCH EXLRange::get_Comment() { + LPDISPATCH result; + InvokeHelper(0x38e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void EXLRange::ClearComments() { + InvokeHelper(0x56e, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +LPDISPATCH EXLRange::get_Phonetic() { + LPDISPATCH result; + InvokeHelper(0x56f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLRange::get_FormatConditions() { + LPDISPATCH result; + InvokeHelper(0x570, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long EXLRange::get_ReadingOrder() { + long result; + InvokeHelper(0x3cf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void EXLRange::put_ReadingOrder(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x3cf, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH EXLRange::get_Hyperlinks() { + LPDISPATCH result; + InvokeHelper(0x571, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLRange::get_Phonetics() { + LPDISPATCH result; + InvokeHelper(0x713, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void EXLRange::SetPhonetic() { + InvokeHelper(0x714, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +CString EXLRange::get_ID() { + CString result; + InvokeHelper(0x715, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void EXLRange::put_ID(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x715, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +VARIANT EXLRange::_PrintOut(VARIANT From, VARIANT To, VARIANT Copies, VARIANT Preview, VARIANT ActivePrinter, VARIANT PrintToFile, VARIANT Collate, VARIANT PrToFileName) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x6ec, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate, &PrToFileName); + return result; +} +LPDISPATCH EXLRange::get_PivotCell() { + LPDISPATCH result; + InvokeHelper(0x7dd, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void EXLRange::Dirty() { + InvokeHelper(0x7de, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +LPDISPATCH EXLRange::get_Errors() { + LPDISPATCH result; + InvokeHelper(0x7df, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLRange::get_SmartTags() { + LPDISPATCH result; + InvokeHelper(0x7e0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void EXLRange::Speak(VARIANT SpeakDirection, VARIANT SpeakFormulas) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x7e1, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &SpeakDirection, &SpeakFormulas); +} +VARIANT EXLRange::PasteSpecial(long Paste, long Operation, VARIANT SkipBlanks, VARIANT Transpose) { + VARIANT result; + static BYTE parms[] = VTS_I4 VTS_I4 VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x788, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, Paste, Operation, &SkipBlanks, &Transpose); + return result; +} +BOOL EXLRange::get_AllowEdit() { + BOOL result; + InvokeHelper(0x7e4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLRange::get_ListObject() { + LPDISPATCH result; + InvokeHelper(0x8d1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLRange::get_XPath() { + LPDISPATCH result; + InvokeHelper(0x8d2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLRange::get_ServerActions() { + LPDISPATCH result; + InvokeHelper(0x9bb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void EXLRange::RemoveDuplicates(VARIANT Columns, long Header) { + static BYTE parms[] = VTS_VARIANT VTS_I4; + InvokeHelper(0x9bc, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Columns, Header); +} +VARIANT EXLRange::PrintOut(VARIANT From, VARIANT To, VARIANT Copies, VARIANT Preview, VARIANT ActivePrinter, VARIANT PrintToFile, VARIANT Collate, VARIANT PrToFileName) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x939, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate, &PrToFileName); + return result; +} +CString EXLRange::get_MDX() { + CString result; + InvokeHelper(0x84b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void EXLRange::ExportAsFixedFormat(long Type, VARIANT Filename, VARIANT Quality, VARIANT IncludeDocProperties, VARIANT IgnorePrintAreas, VARIANT From, VARIANT To, VARIANT OpenAfterPublish, VARIANT FixedFormatExtClassPtr) { + static BYTE parms[] = VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x9bd, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Type, &Filename, &Quality, &IncludeDocProperties, &IgnorePrintAreas, &From, &To, &OpenAfterPublish, &FixedFormatExtClassPtr); +} +VARIANT EXLRange::get_CountLarge() { + VARIANT result; + InvokeHelper(0x9c3, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::CalculateRowMajorOrder() { + VARIANT result; + InvokeHelper(0x93c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLRange::get_SparklineGroups() { + LPDISPATCH result; + InvokeHelper(0xb25, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void EXLRange::ClearHyperlinks() { + InvokeHelper(0xb26, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +LPDISPATCH EXLRange::get_DisplayFormat() { + LPDISPATCH result; + InvokeHelper(0x29a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +VARIANT EXLRange::BorderAround(VARIANT LineStyle, long Weight, long ColorIndex, VARIANT Color, VARIANT ThemeColor) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT VTS_I4 VTS_I4 VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xad3, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &LineStyle, Weight, ColorIndex, &Color, &ThemeColor); + return result; +} +void EXLRange::AllocateChanges() { + InvokeHelper(0xb27, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void EXLRange::DiscardChanges() { + InvokeHelper(0xb28, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void EXLRange::FlashFill() { + InvokeHelper(0xbb4, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +} // namespace MSO::Excel + +#pragma warning( pop ) \ No newline at end of file diff --git a/src/excel/EXLRanges.cpp b/src/excel/EXLRanges.cpp new file mode 100644 index 0000000..f321cbc --- /dev/null +++ b/src/excel/EXLRanges.cpp @@ -0,0 +1,58 @@ +#include "stdafx.h" + +#include "office/excel/EXLRanges.h" + +#include "office/excel/EXLRange.h" + +#pragma warning( push ) +#pragma warning( disable : 26493 26485 26494 ) + +namespace MSO::Excel { + +LPDISPATCH EXLRanges::get_Application() { + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +long EXLRanges::get_Creator() { + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLRanges::get_Parent() { + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLRanges::get__Default(VARIANT IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, &IndexType); + return result; +} + +LPUNKNOWN EXLRanges::get_NewEnum() { + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLRanges::get_Item(VARIANT IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, &IndexType); + return result; +} + +long EXLRanges::get_Count() { + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +} // namespace MSO::Excel + +#pragma warning( pop ) \ No newline at end of file diff --git a/src/excel/EXLWorkbook.cpp b/src/excel/EXLWorkbook.cpp new file mode 100644 index 0000000..de2faf5 --- /dev/null +++ b/src/excel/EXLWorkbook.cpp @@ -0,0 +1,1209 @@ +#include "stdafx.h" + +#include "office/excel/EXLWorkbook.h" +#include "office/excel/EXLWorksheets.h" + +#pragma warning( push ) +#pragma warning( disable : 26493 26485 26494 ) + +namespace MSO::Excel { + +LPDISPATCH EXLWorkbook::get_Application() { + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long EXLWorkbook::get_Creator() { + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorkbook::get_Parent() { + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL EXLWorkbook::get_AcceptLabelsInFormulas() { + BOOL result; + InvokeHelper(0x5a1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_AcceptLabelsInFormulas(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x5a1, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +void EXLWorkbook::Activate() { + InvokeHelper(0x130, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +LPDISPATCH EXLWorkbook::get_ActiveChart() { + LPDISPATCH result; + InvokeHelper(0xb7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorkbook::get_ActiveSheet() { + LPDISPATCH result; + InvokeHelper(0x133, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +CString EXLWorkbook::get_Author() { + CString result; + InvokeHelper(0x23e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_Author(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x23e, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long EXLWorkbook::get_AutoUpdateFrequency() { + long result; + InvokeHelper(0x5a2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_AutoUpdateFrequency(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x5a2, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL EXLWorkbook::get_AutoUpdateSaveChanges() { + BOOL result; + InvokeHelper(0x5a3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_AutoUpdateSaveChanges(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x5a3, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long EXLWorkbook::get_ChangeHistoryDuration() { + long result; + InvokeHelper(0x5a4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_ChangeHistoryDuration(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x5a4, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH EXLWorkbook::get_BuiltinDocumentProperties() { + LPDISPATCH result; + InvokeHelper(0x498, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::ChangeFileAccess(long Mode, VARIANT WritePassword, VARIANT Notify) { + static BYTE parms[] = VTS_I4 VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x3dd, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Mode, &WritePassword, &Notify); +} +void EXLWorkbook::ChangeLink(LPCTSTR Name, LPCTSTR NewName, long Type) { + static BYTE parms[] = VTS_BSTR VTS_BSTR VTS_I4; + InvokeHelper(0x322, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Name, NewName, Type); +} +LPDISPATCH EXLWorkbook::get_Charts() { + LPDISPATCH result; + InvokeHelper(0x79, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::Close(VARIANT SaveChanges, VARIANT Filename, VARIANT RouteWorkbook) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x115, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &SaveChanges, &Filename, &RouteWorkbook); +} +CString EXLWorkbook::get_CodeName() { + CString result; + InvokeHelper(0x55d, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +CString EXLWorkbook::get__CodeName() { + CString result; + InvokeHelper(0x80010000, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put__CodeName(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x80010000, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +VARIANT EXLWorkbook::get_Colors(VARIANT IndexType) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x11e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, &IndexType); + return result; +} +void EXLWorkbook::put_Colors(VARIANT IndexType, VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x11e, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &IndexType, &newValue); +} +LPDISPATCH EXLWorkbook::get_CommandBars() { + LPDISPATCH result; + InvokeHelper(0x59f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +CString EXLWorkbook::get_Comments() { + CString result; + InvokeHelper(0x23f, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_Comments(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x23f, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long EXLWorkbook::get_ConflictResolution() { + long result; + InvokeHelper(0x497, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_ConflictResolution(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x497, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH EXLWorkbook::get_Container() { + LPDISPATCH result; + InvokeHelper(0x4a6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL EXLWorkbook::get_CreateBackup() { + BOOL result; + InvokeHelper(0x11f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorkbook::get_CustomDocumentProperties() { + LPDISPATCH result; + InvokeHelper(0x499, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL EXLWorkbook::get_Date1904() { + BOOL result; + InvokeHelper(0x193, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_Date1904(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x193, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +void EXLWorkbook::DeleteNumberFormat(LPCTSTR NumberFormat) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x18d, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, NumberFormat); +} +LPDISPATCH EXLWorkbook::get_DialogSheets() { + LPDISPATCH result; + InvokeHelper(0x2fc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long EXLWorkbook::get_DisplayDrawingObjects() { + long result; + InvokeHelper(0x194, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_DisplayDrawingObjects(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x194, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL EXLWorkbook::ExclusiveAccess() { + BOOL result; + InvokeHelper(0x490, DISPATCH_METHOD, VT_BOOL, (void*)&result, nullptr); + return result; +} +long EXLWorkbook::get_FileFormat() { + long result; + InvokeHelper(0x120, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::ForwardMailer() { + InvokeHelper(0x3cd, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +CString EXLWorkbook::get_FullName() { + CString result; + InvokeHelper(0x121, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +BOOL EXLWorkbook::get_HasMailer() { + BOOL result; + InvokeHelper(0x3d0, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_HasMailer(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x3d0, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL EXLWorkbook::get_HasPassword() { + BOOL result; + InvokeHelper(0x122, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +BOOL EXLWorkbook::get_HasRoutingSlip() { + BOOL result; + InvokeHelper(0x3b6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_HasRoutingSlip(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x3b6, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL EXLWorkbook::get_IsAddin() { + BOOL result; + InvokeHelper(0x5a5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_IsAddin(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x5a5, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +CString EXLWorkbook::get_Keywords() { + CString result; + InvokeHelper(0x241, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_Keywords(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x241, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +VARIANT EXLWorkbook::LinkInfo(LPCTSTR Name, long LinkInfo, VARIANT Type, VARIANT EditionRef) { + VARIANT result; + static BYTE parms[] = VTS_BSTR VTS_I4 VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x327, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, Name, LinkInfo, &Type, &EditionRef); + return result; +} +VARIANT EXLWorkbook::LinkSources(VARIANT Type) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x328, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Type); + return result; +} +LPDISPATCH EXLWorkbook::get_Mailer() { + LPDISPATCH result; + InvokeHelper(0x3d3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::MergeWorkbook(VARIANT Filename) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x5a6, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Filename); +} +LPDISPATCH EXLWorkbook::get_Modules() { + LPDISPATCH result; + InvokeHelper(0x246, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL EXLWorkbook::get_MultiUserEditing() { + BOOL result; + InvokeHelper(0x491, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +CString EXLWorkbook::get_Name() { + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorkbook::get_Names() { + LPDISPATCH result; + InvokeHelper(0x1ba, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorkbook::NewWindow() { + LPDISPATCH result; + InvokeHelper(0x118, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +CString EXLWorkbook::get_OnSave() { + CString result; + InvokeHelper(0x49a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_OnSave(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x49a, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +CString EXLWorkbook::get_OnSheetActivate() { + CString result; + InvokeHelper(0x407, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_OnSheetActivate(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x407, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +CString EXLWorkbook::get_OnSheetDeactivate() { + CString result; + InvokeHelper(0x439, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_OnSheetDeactivate(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x439, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +void EXLWorkbook::OpenLinks(LPCTSTR Name, VARIANT ReadOnly, VARIANT Type) { + static BYTE parms[] = VTS_BSTR VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x323, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Name, &ReadOnly, &Type); +} +CString EXLWorkbook::get_Path() { + CString result; + InvokeHelper(0x123, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +BOOL EXLWorkbook::get_PersonalViewListSettings() { + BOOL result; + InvokeHelper(0x5a7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_PersonalViewListSettings(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x5a7, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL EXLWorkbook::get_PersonalViewPrintSettings() { + BOOL result; + InvokeHelper(0x5a8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_PersonalViewPrintSettings(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x5a8, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH EXLWorkbook::PivotCaches() { + LPDISPATCH result; + InvokeHelper(0x5a9, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::Post(VARIANT DestName) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x48e, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &DestName); +} +BOOL EXLWorkbook::get_PrecisionAsDisplayed() { + BOOL result; + InvokeHelper(0x195, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_PrecisionAsDisplayed(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x195, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +void EXLWorkbook::__PrintOut(VARIANT From, VARIANT To, VARIANT Copies, VARIANT Preview, VARIANT ActivePrinter, VARIANT PrintToFile, VARIANT Collate) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x389, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate); +} +void EXLWorkbook::PrintPreview(VARIANT EnableChanges) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x119, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &EnableChanges); +} +void EXLWorkbook::_Protect(VARIANT Password, VARIANT Structure, VARIANT Windows) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x11a, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Password, &Structure, &Windows); +} +void EXLWorkbook::_ProtectSharing(VARIANT Filename, VARIANT Password, VARIANT WriteResPassword, VARIANT ReadOnlyRecommended, VARIANT CreateBackup, VARIANT SharingPassword) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x5aa, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Filename, &Password, &WriteResPassword, &ReadOnlyRecommended, &CreateBackup, &SharingPassword); +} +BOOL EXLWorkbook::get_ProtectStructure() { + BOOL result; + InvokeHelper(0x24c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +BOOL EXLWorkbook::get_ProtectWindows() { + BOOL result; + InvokeHelper(0x127, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +BOOL EXLWorkbook::get_ReadOnly() { + BOOL result; + InvokeHelper(0x128, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +BOOL EXLWorkbook::get__ReadOnlyRecommended() { + BOOL result; + InvokeHelper(0x129, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::RefreshAll() { + InvokeHelper(0x5ac, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void EXLWorkbook::Reply() { + InvokeHelper(0x3d1, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void EXLWorkbook::ReplyAll() { + InvokeHelper(0x3d2, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void EXLWorkbook::RemoveUser(long IndexType) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x5ad, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, IndexType); +} +long EXLWorkbook::get_RevisionNumber() { + long result; + InvokeHelper(0x494, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::Route() { + InvokeHelper(0x3b2, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +BOOL EXLWorkbook::get_Routed() { + BOOL result; + InvokeHelper(0x3b7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorkbook::get_RoutingSlip() { + LPDISPATCH result; + InvokeHelper(0x3b5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::RunAutoMacros(long Which) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x27a, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Which); +} +void EXLWorkbook::Save() { + InvokeHelper(0x11b, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void EXLWorkbook::_SaveAs(VARIANT Filename, VARIANT FileFormat, VARIANT Password, VARIANT WriteResPassword, VARIANT ReadOnlyRecommended, VARIANT CreateBackup, long AccessMode, VARIANT ConflictResolution, VARIANT AddToMru, VARIANT TextCodepage, VARIANT TextVisualLayout) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x11c, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Filename, &FileFormat, &Password, &WriteResPassword, &ReadOnlyRecommended, &CreateBackup, AccessMode, &ConflictResolution, &AddToMru, &TextCodepage, &TextVisualLayout); +} +void EXLWorkbook::SaveCopyAs(VARIANT Filename) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0xaf, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Filename); +} +BOOL EXLWorkbook::get_Saved() { + BOOL result; + InvokeHelper(0x12a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_Saved(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x12a, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL EXLWorkbook::get_SaveLinkValues() { + BOOL result; + InvokeHelper(0x196, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_SaveLinkValues(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x196, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +void EXLWorkbook::SendMail(VARIANT Recipients, VARIANT Subject, VARIANT ReturnReceipt) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x3b3, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Recipients, &Subject, &ReturnReceipt); +} +void EXLWorkbook::SendMailer(VARIANT FileFormat, long Priority) { + static BYTE parms[] = VTS_VARIANT VTS_I4; + InvokeHelper(0x3d4, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &FileFormat, Priority); +} +void EXLWorkbook::SetLinkOnData(LPCTSTR Name, VARIANT Procedure) { + static BYTE parms[] = VTS_BSTR VTS_VARIANT; + InvokeHelper(0x329, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Name, &Procedure); +} +LPDISPATCH EXLWorkbook::get_Sheets() { + LPDISPATCH result; + InvokeHelper(0x1e5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL EXLWorkbook::get_ShowConflictHistory() { + BOOL result; + InvokeHelper(0x493, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_ShowConflictHistory(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x493, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH EXLWorkbook::get_Styles() { + LPDISPATCH result; + InvokeHelper(0x1ed, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +CString EXLWorkbook::get_Subject() { + CString result; + InvokeHelper(0x3b9, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_Subject(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x3b9, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +CString EXLWorkbook::get_Title() { + CString result; + InvokeHelper(0xc7, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_Title(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0xc7, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +void EXLWorkbook::Unprotect(VARIANT Password) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x11d, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Password); +} +void EXLWorkbook::UnprotectSharing(VARIANT SharingPassword) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x5af, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &SharingPassword); +} +void EXLWorkbook::UpdateFromFile() { + InvokeHelper(0x3e3, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void EXLWorkbook::UpdateLink(VARIANT Name, VARIANT Type) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x324, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Name, &Type); +} +BOOL EXLWorkbook::get_UpdateRemoteReferences() { + BOOL result; + InvokeHelper(0x19b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_UpdateRemoteReferences(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x19b, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL EXLWorkbook::get_UserControl() { + BOOL result; + InvokeHelper(0x4ba, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_UserControl(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x4ba, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +VARIANT EXLWorkbook::get_UserStatus() { + VARIANT result; + InvokeHelper(0x495, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorkbook::get_CustomViews() { + LPDISPATCH result; + InvokeHelper(0x5b0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorkbook::get_Windows() { + LPDISPATCH result; + InvokeHelper(0x1ae, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +EXLWorksheets EXLWorkbook::get_Worksheets() { + LPDISPATCH result; + InvokeHelper(0x1ee, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL EXLWorkbook::get_WriteReserved() { + BOOL result; + InvokeHelper(0x12b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +CString EXLWorkbook::get_WriteReservedBy() { + CString result; + InvokeHelper(0x12c, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorkbook::get_Excel4IntlMacroSheets() { + LPDISPATCH result; + InvokeHelper(0x245, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorkbook::get_Excel4MacroSheets() { + LPDISPATCH result; + InvokeHelper(0x243, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL EXLWorkbook::get_TemplateRemoveExtData() { + BOOL result; + InvokeHelper(0x5b1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_TemplateRemoveExtData(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x5b1, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +void EXLWorkbook::HighlightChangesOptions(VARIANT When, VARIANT Who, VARIANT Where) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x5b2, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &When, &Who, &Where); +} +BOOL EXLWorkbook::get_HighlightChangesOnScreen() { + BOOL result; + InvokeHelper(0x5b5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_HighlightChangesOnScreen(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x5b5, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL EXLWorkbook::get_KeepChangeHistory() { + BOOL result; + InvokeHelper(0x5b6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_KeepChangeHistory(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x5b6, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL EXLWorkbook::get_ListChangesOnNewSheet() { + BOOL result; + InvokeHelper(0x5b7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_ListChangesOnNewSheet(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x5b7, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +void EXLWorkbook::PurgeChangeHistoryNow(long Days, VARIANT SharingPassword) { + static BYTE parms[] = VTS_I4 VTS_VARIANT; + InvokeHelper(0x5b8, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Days, &SharingPassword); +} +void EXLWorkbook::AcceptAllChanges(VARIANT When, VARIANT Who, VARIANT Where) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x5ba, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &When, &Who, &Where); +} +void EXLWorkbook::RejectAllChanges(VARIANT When, VARIANT Who, VARIANT Where) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x5bb, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &When, &Who, &Where); +} +void EXLWorkbook::PivotTableWizard(VARIANT SourceType, VARIANT DataStream, VARIANT TableDestination, VARIANT TableName, VARIANT RowGrand, VARIANT ColumnGrand, VARIANT SaveData, VARIANT HasAutoFormat, VARIANT AutoPage, VARIANT Reserved, VARIANT BackgroundQuery, VARIANT OptimizeCache, VARIANT PageFieldOrder, VARIANT PageFieldWrapCount, VARIANT ReadData, VARIANT Connection) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x2ac, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &SourceType, &DataStream, &TableDestination, &TableName, &RowGrand, &ColumnGrand, &SaveData, &HasAutoFormat, &AutoPage, &Reserved, &BackgroundQuery, &OptimizeCache, &PageFieldOrder, &PageFieldWrapCount, &ReadData, &Connection); +} +void EXLWorkbook::ResetColors() { + InvokeHelper(0x5bc, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +LPDISPATCH EXLWorkbook::get_VBProject() { + LPDISPATCH result; + InvokeHelper(0x5bd, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::FollowHyperlink(LPCTSTR Address, VARIANT SubAddress, VARIANT NewWindow, VARIANT AddHistory, VARIANT ExtraInfo, VARIANT Method, VARIANT HeaderInfo) { + static BYTE parms[] = VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x5be, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Address, &SubAddress, &NewWindow, &AddHistory, &ExtraInfo, &Method, &HeaderInfo); +} +void EXLWorkbook::AddToFavorites() { + InvokeHelper(0x5c4, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +BOOL EXLWorkbook::get_IsInplace() { + BOOL result; + InvokeHelper(0x6e9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::_PrintOut(VARIANT From, VARIANT To, VARIANT Copies, VARIANT Preview, VARIANT ActivePrinter, VARIANT PrintToFile, VARIANT Collate, VARIANT PrToFileName) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x6ec, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate, &PrToFileName); +} +void EXLWorkbook::WebPagePreview() { + InvokeHelper(0x71a, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +LPDISPATCH EXLWorkbook::get_PublishObjects() { + LPDISPATCH result; + InvokeHelper(0x71b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorkbook::get_WebOptions() { + LPDISPATCH result; + InvokeHelper(0x71c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::ReloadAs(long Encoding) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x71d, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Encoding); +} +LPDISPATCH EXLWorkbook::get_HTMLProject() { + LPDISPATCH result; + InvokeHelper(0x71f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL EXLWorkbook::get_EnvelopeVisible() { + BOOL result; + InvokeHelper(0x720, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_EnvelopeVisible(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x720, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long EXLWorkbook::get_CalculationVersion() { + long result; + InvokeHelper(0x70e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::Dummy17(long calcid) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x7fc, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, calcid); +} +void EXLWorkbook::sblt(LPCTSTR s) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x722, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, s); +} +BOOL EXLWorkbook::get_VBASigned() { + BOOL result; + InvokeHelper(0x724, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +BOOL EXLWorkbook::get_ShowPivotTableFieldList() { + BOOL result; + InvokeHelper(0x7fe, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_ShowPivotTableFieldList(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x7fe, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long EXLWorkbook::get_UpdateLinks() { + long result; + InvokeHelper(0x360, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_UpdateLinks(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x360, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +void EXLWorkbook::BreakLink(LPCTSTR Name, long Type) { + static BYTE parms[] = VTS_BSTR VTS_I4; + InvokeHelper(0x7ff, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Name, Type); +} +void EXLWorkbook::Dummy16() { + InvokeHelper(0x800, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void EXLWorkbook::SaveAs(VARIANT Filename, VARIANT FileFormat, VARIANT Password, + VARIANT WriteResPassword, VARIANT ReadOnlyRecommended, VARIANT CreateBackup, long AccessMode, + VARIANT ConflictResolution, VARIANT AddToMru, VARIANT TextCodepage, + VARIANT TextVisualLayout, VARIANT Local) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x785, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Filename, &FileFormat, &Password, &WriteResPassword, + &ReadOnlyRecommended, &CreateBackup, &AccessMode, &ConflictResolution, &AddToMru, &TextCodepage, &TextVisualLayout, &Local); +} +BOOL EXLWorkbook::get_EnableAutoRecover() { + BOOL result; + InvokeHelper(0x801, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_EnableAutoRecover(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x801, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL EXLWorkbook::get_RemovePersonalInformation() { + BOOL result; + InvokeHelper(0x802, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_RemovePersonalInformation(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x802, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +CString EXLWorkbook::get_FullNameURLEncoded() { + CString result; + InvokeHelper(0x787, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::CheckIn(VARIANT SaveChanges, VARIANT Comments, VARIANT MakePublic) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x803, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &SaveChanges, &Comments, &MakePublic); +} +BOOL EXLWorkbook::CanCheckIn() { + BOOL result; + InvokeHelper(0x805, DISPATCH_METHOD, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::SendForReview(VARIANT Recipients, VARIANT Subject, VARIANT ShowMessage, VARIANT IncludeAttachment) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x806, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Recipients, &Subject, &ShowMessage, &IncludeAttachment); +} +void EXLWorkbook::ReplyWithChanges(VARIANT ShowMessage) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x809, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &ShowMessage); +} +void EXLWorkbook::EndReview() { + InvokeHelper(0x80a, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +CString EXLWorkbook::get_Password() { + CString result; + InvokeHelper(0x1ad, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_Password(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x1ad, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +CString EXLWorkbook::get_WritePassword() { + CString result; + InvokeHelper(0x468, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_WritePassword(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x468, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +CString EXLWorkbook::get_PasswordEncryptionProvider() { + CString result; + InvokeHelper(0x80b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +CString EXLWorkbook::get_PasswordEncryptionAlgorithm() { + CString result; + InvokeHelper(0x80c, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +long EXLWorkbook::get_PasswordEncryptionKeyLength() { + long result; + InvokeHelper(0x80d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::SetPasswordEncryptionOptions(VARIANT PasswordEncryptionProvider, VARIANT PasswordEncryptionAlgorithm, VARIANT PasswordEncryptionKeyLength, VARIANT PasswordEncryptionFileProperties) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x80e, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &PasswordEncryptionProvider, &PasswordEncryptionAlgorithm, &PasswordEncryptionKeyLength, &PasswordEncryptionFileProperties); +} +BOOL EXLWorkbook::get_PasswordEncryptionFileProperties() { + BOOL result; + InvokeHelper(0x80f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +BOOL EXLWorkbook::get_ReadOnlyRecommended() { + BOOL result; + InvokeHelper(0x7d5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_ReadOnlyRecommended(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x7d5, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +void EXLWorkbook::Protect(VARIANT Password, VARIANT Structure, VARIANT Windows) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x7ed, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Password, &Structure, &Windows); +} +LPDISPATCH EXLWorkbook::get_SmartTagOptions() { + LPDISPATCH result; + InvokeHelper(0x810, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::RecheckSmartTags() { + InvokeHelper(0x811, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +LPDISPATCH EXLWorkbook::get_Permission() { + LPDISPATCH result; + InvokeHelper(0x8d8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorkbook::get_SharedWorkspace() { + LPDISPATCH result; + InvokeHelper(0x8d9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorkbook::get_Sync() { + LPDISPATCH result; + InvokeHelper(0x8da, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::SendFaxOverInternet(VARIANT Recipients, VARIANT Subject, VARIANT ShowMessage) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x8db, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Recipients, &Subject, &ShowMessage); +} +LPDISPATCH EXLWorkbook::get_XmlNamespaces() { + LPDISPATCH result; + InvokeHelper(0x8dc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorkbook::get_XmlMaps() { + LPDISPATCH result; + InvokeHelper(0x8dd, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long EXLWorkbook::XmlImport(LPCTSTR Url, LPDISPATCH* ImportMap, VARIANT Overwrite, VARIANT Destination) { + long result; + static BYTE parms[] = VTS_BSTR VTS_PDISPATCH VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x8de, DISPATCH_METHOD, VT_I4, (void*)&result, parms, Url, ImportMap, &Overwrite, &Destination); + return result; +} +LPDISPATCH EXLWorkbook::get_SmartDocument() { + LPDISPATCH result; + InvokeHelper(0x8e1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorkbook::get_DocumentLibraryVersions() { + LPDISPATCH result; + InvokeHelper(0x8e2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL EXLWorkbook::get_InactiveListBorderVisible() { + BOOL result; + InvokeHelper(0x8e3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_InactiveListBorderVisible(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x8e3, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL EXLWorkbook::get_DisplayInkComments() { + BOOL result; + InvokeHelper(0x8e4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_DisplayInkComments(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x8e4, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long EXLWorkbook::XmlImportXml(LPCTSTR Data, LPDISPATCH* ImportMap, VARIANT Overwrite, VARIANT Destination) { + long result; + static BYTE parms[] = VTS_BSTR VTS_PDISPATCH VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x8e5, DISPATCH_METHOD, VT_I4, (void*)&result, parms, Data, ImportMap, &Overwrite, &Destination); + return result; +} +void EXLWorkbook::SaveAsXMLData(LPCTSTR Filename, LPDISPATCH Map) { + static BYTE parms[] = VTS_BSTR VTS_DISPATCH; + InvokeHelper(0x8e6, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Filename, Map); +} +void EXLWorkbook::ToggleFormsDesign() { + InvokeHelper(0x8e7, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +LPDISPATCH EXLWorkbook::get_ContentTypeProperties() { + LPDISPATCH result; + InvokeHelper(0x9d0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorkbook::get_Connections() { + LPDISPATCH result; + InvokeHelper(0x9d1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::RemoveDocumentInformation(long RemoveDocInfoType) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x9d2, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, RemoveDocInfoType); +} +LPDISPATCH EXLWorkbook::get_Signatures() { + LPDISPATCH result; + InvokeHelper(0x9d4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::CheckInWithVersion(VARIANT SaveChanges, VARIANT Comments, VARIANT MakePublic, VARIANT VersionType) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x9d5, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &SaveChanges, &Comments, &MakePublic, &VersionType); +} +LPDISPATCH EXLWorkbook::get_ServerPolicy() { + LPDISPATCH result; + InvokeHelper(0x9d7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::LockServerFile() { + InvokeHelper(0x9d8, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +LPDISPATCH EXLWorkbook::get_DocumentInspectors() { + LPDISPATCH result; + InvokeHelper(0x9d9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorkbook::GetWorkflowTasks() { + LPDISPATCH result; + InvokeHelper(0x9da, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorkbook::GetWorkflowTemplates() { + LPDISPATCH result; + InvokeHelper(0x9db, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::PrintOut(VARIANT From, VARIANT To, VARIANT Copies, VARIANT Preview, VARIANT ActivePrinter, VARIANT PrintToFile, VARIANT Collate, VARIANT PrToFileName, VARIANT IgnorePrintAreas) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x939, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate, &PrToFileName, &IgnorePrintAreas); +} +LPDISPATCH EXLWorkbook::get_ServerViewableItems() { + LPDISPATCH result; + InvokeHelper(0x9dc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorkbook::get_TableStyles() { + LPDISPATCH result; + InvokeHelper(0x9dd, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +VARIANT EXLWorkbook::get_DefaultTableStyle() { + VARIANT result; + InvokeHelper(0x9de, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_DefaultTableStyle(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x9de, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +VARIANT EXLWorkbook::get_DefaultPivotTableStyle() { + VARIANT result; + InvokeHelper(0x9df, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_DefaultPivotTableStyle(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x9df, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +BOOL EXLWorkbook::get_CheckCompatibility() { + BOOL result; + InvokeHelper(0x9e0, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_CheckCompatibility(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x9e0, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL EXLWorkbook::get_HasVBProject() { + BOOL result; + InvokeHelper(0x9e1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorkbook::get_CustomXMLParts() { + LPDISPATCH result; + InvokeHelper(0x9e2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL EXLWorkbook::get_Final() { + BOOL result; + InvokeHelper(0x9e3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_Final(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x9e3, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH EXLWorkbook::get_Research() { + LPDISPATCH result; + InvokeHelper(0x9e4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorkbook::get_Theme() { + LPDISPATCH result; + InvokeHelper(0x9e5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::ApplyTheme(LPCTSTR Filename) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x9e6, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Filename); +} +BOOL EXLWorkbook::get_Excel8CompatibilityMode() { + BOOL result; + InvokeHelper(0x9e7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +BOOL EXLWorkbook::get_ConnectionsDisabled() { + BOOL result; + InvokeHelper(0x9e8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::EnableConnections() { + InvokeHelper(0x9e9, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +BOOL EXLWorkbook::get_ShowPivotChartActiveFields() { + BOOL result; + InvokeHelper(0x9ea, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_ShowPivotChartActiveFields(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x9ea, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +void EXLWorkbook::ExportAsFixedFormat(long Type, VARIANT Filename, VARIANT Quality, VARIANT IncludeDocProperties, VARIANT IgnorePrintAreas, VARIANT From, VARIANT To, VARIANT OpenAfterPublish, VARIANT FixedFormatExtClassPtr) { + static BYTE parms[] = VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x9bd, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Type, &Filename, &Quality, &IncludeDocProperties, &IgnorePrintAreas, &From, &To, &OpenAfterPublish, &FixedFormatExtClassPtr); +} +LPDISPATCH EXLWorkbook::get_IconSets() { + LPDISPATCH result; + InvokeHelper(0x9eb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +CString EXLWorkbook::get_EncryptionProvider() { + CString result; + InvokeHelper(0x9ec, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_EncryptionProvider(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x9ec, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL EXLWorkbook::get_DoNotPromptForConvert() { + BOOL result; + InvokeHelper(0x9ed, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_DoNotPromptForConvert(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x9ed, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL EXLWorkbook::get_ForceFullCalculation() { + BOOL result; + InvokeHelper(0x9ee, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_ForceFullCalculation(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x9ee, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +void EXLWorkbook::ProtectSharing(VARIANT Filename, VARIANT Password, VARIANT WriteResPassword, VARIANT ReadOnlyRecommended, VARIANT CreateBackup, VARIANT SharingPassword, VARIANT FileFormat) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x9ef, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Filename, &Password, &WriteResPassword, &ReadOnlyRecommended, &CreateBackup, &SharingPassword, &FileFormat); +} +LPDISPATCH EXLWorkbook::get_SlicerCaches() { + LPDISPATCH result; + InvokeHelper(0xb32, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorkbook::get_ActiveSlicer() { + LPDISPATCH result; + InvokeHelper(0xb33, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +VARIANT EXLWorkbook::get_DefaultSlicerStyle() { + VARIANT result; + InvokeHelper(0xb34, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_DefaultSlicerStyle(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0xb34, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +void EXLWorkbook::Dummy26() { + InvokeHelper(0xb35, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void EXLWorkbook::Dummy27() { + InvokeHelper(0xb36, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +long EXLWorkbook::get_AccuracyVersion() { + long result; + InvokeHelper(0xb37, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_AccuracyVersion(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0xb37, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL EXLWorkbook::get_CaseSensitive() { + BOOL result; + InvokeHelper(0xbf0, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +BOOL EXLWorkbook::get_UseWholeCellCriteria() { + BOOL result; + InvokeHelper(0xbf1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +BOOL EXLWorkbook::get_UseWildcards() { + BOOL result; + InvokeHelper(0xbf2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorkbook::get_PivotTables() { + LPDISPATCH result; + InvokeHelper(0x2b2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorkbook::get_Model() { + LPDISPATCH result; + InvokeHelper(0xbf3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL EXLWorkbook::get_ChartDataPointTrack() { + BOOL result; + InvokeHelper(0xbb6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_ChartDataPointTrack(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0xbb6, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +VARIANT EXLWorkbook::get_DefaultTimelineStyle() { + VARIANT result; + InvokeHelper(0xbf4, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::put_DefaultTimelineStyle(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0xbf4, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +LPDISPATCH EXLWorkbook::get_Queries() { + LPDISPATCH result; + InvokeHelper(0xc60, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void EXLWorkbook::CreateForecastSheet(LPDISPATCH Timeline, LPDISPATCH Values, VARIANT ForecastStart, VARIANT ForecastEnd, VARIANT ConfInt, VARIANT Seasonality, VARIANT DataCompletion, VARIANT Aggregation, VARIANT ChartType, VARIANT ShowStatsTable) { + static BYTE parms[] = VTS_DISPATCH VTS_DISPATCH VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xc5f, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Timeline, Values, &ForecastStart, &ForecastEnd, &ConfInt, &Seasonality, &DataCompletion, &Aggregation, &ChartType, &ShowStatsTable); +} + +} // namespace MSO::Excel + +#pragma warning( pop ) \ No newline at end of file diff --git a/src/excel/EXLWorkbooks.cpp b/src/excel/EXLWorkbooks.cpp new file mode 100644 index 0000000..57296f6 --- /dev/null +++ b/src/excel/EXLWorkbooks.cpp @@ -0,0 +1,120 @@ +#include "stdafx.h" + +#include "office/excel/EXLWorkbooks.h" + +#include "office/excel/EXLWorkbook.h" + +#pragma warning( push ) +#pragma warning( disable : 26493 26485 26494 ) + +namespace MSO::Excel { + +LPDISPATCH EXLWorkbooks::get_Application() { + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long EXLWorkbooks::get_Creator() { + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorkbooks::get_Parent() { + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +EXLWorkbook EXLWorkbooks::Add(VARIANT Template) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &Template); + return result; +} +void EXLWorkbooks::Close() { + InvokeHelper(0x115, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +long EXLWorkbooks::get_Count() { + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorkbooks::get_Item(VARIANT IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, &IndexType); + return result; +} +LPUNKNOWN EXLWorkbooks::get_NewEnum() { + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, nullptr); + return result; +} + +EXLWorkbook EXLWorkbooks::_Open(LPCTSTR Filename, VARIANT UpdateLinks, VARIANT ReadOnly, VARIANT Format, + VARIANT Password, VARIANT WriteResPassword, VARIANT IgnoreReadOnlyRecommended, VARIANT Origin, VARIANT Delimiter, + VARIANT Editable, VARIANT Notify, VARIANT Converter, VARIANT AddToMru) { + LPDISPATCH result; + static BYTE parms[] = VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x2aa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Filename, &UpdateLinks, &ReadOnly, &Format, &Password, &WriteResPassword, &IgnoreReadOnlyRecommended, &Origin, &Delimiter, &Editable, &Notify, &Converter, &AddToMru); + return result; +} +void EXLWorkbooks::__OpenText(LPCTSTR Filename, VARIANT Origin, VARIANT StartRow, VARIANT DataType, long TextQualifier, VARIANT ConsecutiveDelimiter, VARIANT Tab, VARIANT Semicolon, VARIANT Comma, VARIANT Space, VARIANT Other, VARIANT OtherChar, VARIANT FieldInfo, VARIANT TextVisualLayout) { + static BYTE parms[] = VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x2ab, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Filename, &Origin, &StartRow, &DataType, TextQualifier, &ConsecutiveDelimiter, &Tab, &Semicolon, &Comma, &Space, &Other, &OtherChar, &FieldInfo, &TextVisualLayout); +} +LPDISPATCH EXLWorkbooks::get__Default(VARIANT IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, &IndexType); + return result; +} +void EXLWorkbooks::_OpenText(LPCTSTR Filename, VARIANT Origin, VARIANT StartRow, VARIANT DataType, long TextQualifier, VARIANT ConsecutiveDelimiter, VARIANT Tab, VARIANT Semicolon, VARIANT Comma, VARIANT Space, VARIANT Other, VARIANT OtherChar, VARIANT FieldInfo, VARIANT TextVisualLayout, VARIANT DecimalSeparator, VARIANT ThousandsSeparator) { + static BYTE parms[] = VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x6ed, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Filename, &Origin, &StartRow, &DataType, TextQualifier, &ConsecutiveDelimiter, &Tab, &Semicolon, &Comma, &Space, &Other, &OtherChar, &FieldInfo, &TextVisualLayout, &DecimalSeparator, &ThousandsSeparator); +} + +EXLWorkbook EXLWorkbooks::Open(LPCTSTR Filename, VARIANT UpdateLinks, VARIANT ReadOnly, + VARIANT Format, VARIANT Password, VARIANT WriteResPassword, VARIANT IgnoreReadOnlyRecommended, + VARIANT Origin, VARIANT Delimiter, VARIANT Editable, VARIANT Notify, VARIANT Converter, + VARIANT AddToMru, VARIANT Local, VARIANT CorruptLoad) { + LPDISPATCH result; + static BYTE parms[] = VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x783, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Filename, &UpdateLinks, &ReadOnly, &Format, &Password, &WriteResPassword, &IgnoreReadOnlyRecommended, &Origin, &Delimiter, &Editable, &Notify, &Converter, &AddToMru, &Local, &CorruptLoad); + return result; +} +void EXLWorkbooks::OpenText(LPCTSTR Filename, VARIANT Origin, VARIANT StartRow, VARIANT DataType, long TextQualifier, VARIANT ConsecutiveDelimiter, VARIANT Tab, VARIANT Semicolon, VARIANT Comma, VARIANT Space, VARIANT Other, VARIANT OtherChar, VARIANT FieldInfo, VARIANT TextVisualLayout, VARIANT DecimalSeparator, VARIANT ThousandsSeparator, VARIANT TrailingMinusNumbers, VARIANT Local) { + static BYTE parms[] = VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x784, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Filename, &Origin, &StartRow, &DataType, TextQualifier, &ConsecutiveDelimiter, &Tab, &Semicolon, &Comma, &Space, &Other, &OtherChar, &FieldInfo, &TextVisualLayout, &DecimalSeparator, &ThousandsSeparator, &TrailingMinusNumbers, &Local); +} +LPDISPATCH EXLWorkbooks::OpenDatabase(LPCTSTR Filename, VARIANT CommandText, VARIANT CommandType, VARIANT BackgroundQuery, VARIANT ImportDataAs) { + LPDISPATCH result; + static BYTE parms[] = VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x813, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Filename, &CommandText, &CommandType, &BackgroundQuery, &ImportDataAs); + return result; +} +void EXLWorkbooks::CheckOut(LPCTSTR Filename) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x815, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Filename); +} +BOOL EXLWorkbooks::CanCheckOut(LPCTSTR Filename) { + BOOL result; + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x816, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, Filename); + return result; +} +LPDISPATCH EXLWorkbooks::_OpenXML(LPCTSTR Filename, VARIANT Stylesheets) { + LPDISPATCH result; + static BYTE parms[] = VTS_BSTR VTS_VARIANT; + InvokeHelper(0x817, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Filename, &Stylesheets); + return result; +} +LPDISPATCH EXLWorkbooks::OpenXML(LPCTSTR Filename, VARIANT Stylesheets, VARIANT LoadOption) { + LPDISPATCH result; + static BYTE parms[] = VTS_BSTR VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x8e8, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Filename, &Stylesheets, &LoadOption); + return result; +} + +} // namespace MSO::Excel + +#pragma warning( pop ) \ No newline at end of file diff --git a/src/excel/EXLWorksheet.cpp b/src/excel/EXLWorksheet.cpp new file mode 100644 index 0000000..44e2ae8 --- /dev/null +++ b/src/excel/EXLWorksheet.cpp @@ -0,0 +1,707 @@ +#include "stdafx.h" + +#include "office/excel/EXLWorksheet.h" + +#include "office/excel/EXLRange.h" + +#pragma warning( push ) +#pragma warning( disable : 26493 26485 26494 ) + +namespace MSO::Excel { + +LPDISPATCH EXLWorksheet::get_Application() { + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long EXLWorksheet::get_Creator() { + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorksheet::get_Parent() { + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::Activate() { + InvokeHelper(0x130, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void EXLWorksheet::Copy(VARIANT Before, VARIANT After) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x227, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Before, &After); +} +void EXLWorksheet::Delete() { + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +CString EXLWorksheet::get_CodeName() { + CString result; + InvokeHelper(0x55d, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +CString EXLWorksheet::get__CodeName() { + CString result; + InvokeHelper(0x80010000, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::put__CodeName(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x80010000, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long EXLWorksheet::get_Index() { + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::Move(VARIANT Before, VARIANT After) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x27d, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Before, &After); +} +CString EXLWorksheet::get_Name() { + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::put_Name(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH EXLWorksheet::get_Next() { + LPDISPATCH result; + InvokeHelper(0x1f6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +CString EXLWorksheet::get_OnDoubleClick() { + CString result; + InvokeHelper(0x274, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::put_OnDoubleClick(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x274, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +CString EXLWorksheet::get_OnSheetActivate() { + CString result; + InvokeHelper(0x407, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::put_OnSheetActivate(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x407, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +CString EXLWorksheet::get_OnSheetDeactivate() { + CString result; + InvokeHelper(0x439, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::put_OnSheetDeactivate(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x439, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH EXLWorksheet::get_PageSetup() { + LPDISPATCH result; + InvokeHelper(0x3e6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorksheet::get_Previous() { + LPDISPATCH result; + InvokeHelper(0x1f7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::__PrintOut(VARIANT From, VARIANT To, VARIANT Copies, VARIANT Preview, VARIANT ActivePrinter, VARIANT PrintToFile, VARIANT Collate) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x389, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate); +} +void EXLWorksheet::PrintPreview(VARIANT EnableChanges) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x119, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &EnableChanges); +} +void EXLWorksheet::_Protect(VARIANT Password, VARIANT DrawingObjects, VARIANT Contents, VARIANT Scenarios, VARIANT UserInterfaceOnly) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x11a, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Password, &DrawingObjects, &Contents, &Scenarios, &UserInterfaceOnly); +} +BOOL EXLWorksheet::get_ProtectContents() { + BOOL result; + InvokeHelper(0x124, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +BOOL EXLWorksheet::get_ProtectDrawingObjects() { + BOOL result; + InvokeHelper(0x125, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +BOOL EXLWorksheet::get_ProtectionMode() { + BOOL result; + InvokeHelper(0x487, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +BOOL EXLWorksheet::get_ProtectScenarios() { + BOOL result; + InvokeHelper(0x126, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::_SaveAs(LPCTSTR Filename, VARIANT FileFormat, VARIANT Password, VARIANT WriteResPassword, VARIANT ReadOnlyRecommended, VARIANT CreateBackup, VARIANT AddToMru, VARIANT TextCodepage, VARIANT TextVisualLayout) { + static BYTE parms[] = VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x11c, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Filename, &FileFormat, &Password, &WriteResPassword, &ReadOnlyRecommended, &CreateBackup, &AddToMru, &TextCodepage, &TextVisualLayout); +} +void EXLWorksheet::Select(VARIANT Replace) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Replace); +} +void EXLWorksheet::Unprotect(VARIANT Password) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x11d, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Password); +} +long EXLWorksheet::get_Visible() { + long result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::put_Visible(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH EXLWorksheet::get_Shapes() { + LPDISPATCH result; + InvokeHelper(0x561, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL EXLWorksheet::get_TransitionExpEval() { + BOOL result; + InvokeHelper(0x191, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::put_TransitionExpEval(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x191, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH EXLWorksheet::Arcs(VARIANT IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x2f8, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &IndexType); + return result; +} +BOOL EXLWorksheet::get_AutoFilterMode() { + BOOL result; + InvokeHelper(0x318, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::put_AutoFilterMode(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x318, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +void EXLWorksheet::SetBackgroundPicture(LPCTSTR Filename) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x4a4, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Filename); +} +LPDISPATCH EXLWorksheet::Buttons(VARIANT IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x22d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &IndexType); + return result; +} +void EXLWorksheet::Calculate() { + InvokeHelper(0x117, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +BOOL EXLWorksheet::get_EnableCalculation() { + BOOL result; + InvokeHelper(0x590, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::put_EnableCalculation(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x590, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +EXLRange EXLWorksheet::get_Cells() { + LPDISPATCH result; + InvokeHelper(0xee, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorksheet::ChartObjects(VARIANT IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x424, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &IndexType); + return result; +} +LPDISPATCH EXLWorksheet::CheckBoxes(VARIANT IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x338, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &IndexType); + return result; +} +void EXLWorksheet::CheckSpelling(VARIANT CustomDictionary, VARIANT IgnoreUppercase, VARIANT AlwaysSuggest, VARIANT SpellLang) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); +} +LPDISPATCH EXLWorksheet::get_CircularReference() { + LPDISPATCH result; + InvokeHelper(0x42d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::ClearArrows() { + InvokeHelper(0x3ca, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +EXLRange EXLWorksheet::get_Columns() { + LPDISPATCH result; + InvokeHelper(0xf1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long EXLWorksheet::get_ConsolidationFunction() { + long result; + InvokeHelper(0x315, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +VARIANT EXLWorksheet::get_ConsolidationOptions() { + VARIANT result; + InvokeHelper(0x316, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +VARIANT EXLWorksheet::get_ConsolidationSources() { + VARIANT result; + InvokeHelper(0x317, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +BOOL EXLWorksheet::get_DisplayAutomaticPageBreaks() { + BOOL result; + InvokeHelper(0x283, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::put_DisplayAutomaticPageBreaks(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x283, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH EXLWorksheet::Drawings(VARIANT IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x304, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &IndexType); + return result; +} +LPDISPATCH EXLWorksheet::DrawingObjects(VARIANT IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x58, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &IndexType); + return result; +} +LPDISPATCH EXLWorksheet::DropDowns(VARIANT IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x344, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &IndexType); + return result; +} +BOOL EXLWorksheet::get_EnableAutoFilter() { + BOOL result; + InvokeHelper(0x484, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::put_EnableAutoFilter(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x484, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long EXLWorksheet::get_EnableSelection() { + long result; + InvokeHelper(0x591, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::put_EnableSelection(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x591, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL EXLWorksheet::get_EnableOutlining() { + BOOL result; + InvokeHelper(0x485, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::put_EnableOutlining(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x485, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL EXLWorksheet::get_EnablePivotTable() { + BOOL result; + InvokeHelper(0x486, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::put_EnablePivotTable(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x486, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +VARIANT EXLWorksheet::Evaluate(VARIANT Name) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x1, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Name); + return result; +} +VARIANT EXLWorksheet::_Evaluate(VARIANT Name) { + VARIANT result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0xfffffffb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &Name); + return result; +} +BOOL EXLWorksheet::get_FilterMode() { + BOOL result; + InvokeHelper(0x320, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::ResetAllPageBreaks() { + InvokeHelper(0x592, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +LPDISPATCH EXLWorksheet::GroupBoxes(VARIANT IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x342, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &IndexType); + return result; +} +LPDISPATCH EXLWorksheet::GroupObjects(VARIANT IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x459, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &IndexType); + return result; +} +LPDISPATCH EXLWorksheet::Labels(VARIANT IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x349, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &IndexType); + return result; +} +LPDISPATCH EXLWorksheet::Lines(VARIANT IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x2ff, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &IndexType); + return result; +} +LPDISPATCH EXLWorksheet::ListBoxes(VARIANT IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x340, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &IndexType); + return result; +} +LPDISPATCH EXLWorksheet::get_Names() { + LPDISPATCH result; + InvokeHelper(0x1ba, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorksheet::OLEObjects(VARIANT IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x31f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &IndexType); + return result; +} +CString EXLWorksheet::get_OnCalculate() { + CString result; + InvokeHelper(0x271, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::put_OnCalculate(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x271, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +CString EXLWorksheet::get_OnData() { + CString result; + InvokeHelper(0x275, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::put_OnData(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x275, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +CString EXLWorksheet::get_OnEntry() { + CString result; + InvokeHelper(0x273, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::put_OnEntry(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x273, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH EXLWorksheet::OptionButtons(VARIANT IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x33a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &IndexType); + return result; +} +LPDISPATCH EXLWorksheet::get_Outline() { + LPDISPATCH result; + InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorksheet::Ovals(VARIANT IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x321, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &IndexType); + return result; +} +void EXLWorksheet::Paste(VARIANT Destination, VARIANT Link) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xd3, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Destination, &Link); +} +void EXLWorksheet::_PasteSpecial(VARIANT Format, VARIANT Link, VARIANT DisplayAsIcon, VARIANT IconFileName, VARIANT IconIndex, VARIANT IconLabel) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x403, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Format, &Link, &DisplayAsIcon, &IconFileName, &IconIndex, &IconLabel); +} +LPDISPATCH EXLWorksheet::Pictures(VARIANT IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x303, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &IndexType); + return result; +} +LPDISPATCH EXLWorksheet::PivotTables(VARIANT IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x2b2, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &IndexType); + return result; +} +LPDISPATCH EXLWorksheet::PivotTableWizard(VARIANT SourceType, VARIANT DataStream, VARIANT TableDestination, VARIANT TableName, VARIANT RowGrand, VARIANT ColumnGrand, VARIANT SaveData, VARIANT HasAutoFormat, VARIANT AutoPage, VARIANT Reserved, VARIANT BackgroundQuery, VARIANT OptimizeCache, VARIANT PageFieldOrder, VARIANT PageFieldWrapCount, VARIANT ReadData, VARIANT Connection) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x2ac, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &SourceType, &DataStream, &TableDestination, &TableName, &RowGrand, &ColumnGrand, &SaveData, &HasAutoFormat, &AutoPage, &Reserved, &BackgroundQuery, &OptimizeCache, &PageFieldOrder, &PageFieldWrapCount, &ReadData, &Connection); + return result; +} +LPDISPATCH EXLWorksheet::get_Range(VARIANT Cell1, VARIANT Cell2) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xc5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, &Cell1, &Cell2); + return result; +} +LPDISPATCH EXLWorksheet::Rectangles(VARIANT IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x306, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &IndexType); + return result; +} +EXLRange EXLWorksheet::get_Rows() { + LPDISPATCH result; + InvokeHelper(0x102, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorksheet::Scenarios(VARIANT IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x38c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &IndexType); + return result; +} +CString EXLWorksheet::get_ScrollArea() { + CString result; + InvokeHelper(0x599, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::put_ScrollArea(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x599, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH EXLWorksheet::ScrollBars(VARIANT IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x33e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &IndexType); + return result; +} +void EXLWorksheet::ShowAllData() { + InvokeHelper(0x31a, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void EXLWorksheet::ShowDataForm() { + InvokeHelper(0x199, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +LPDISPATCH EXLWorksheet::Spinners(VARIANT IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x346, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &IndexType); + return result; +} +double EXLWorksheet::get_StandardHeight() { + double result; + InvokeHelper(0x197, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, nullptr); + return result; +} +double EXLWorksheet::get_StandardWidth() { + double result; + InvokeHelper(0x198, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::put_StandardWidth(double newValue) { + static BYTE parms[] = VTS_R8; + InvokeHelper(0x198, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH EXLWorksheet::TextBoxes(VARIANT IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x309, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &IndexType); + return result; +} +BOOL EXLWorksheet::get_TransitionFormEntry() { + BOOL result; + InvokeHelper(0x192, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::put_TransitionFormEntry(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x192, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long EXLWorksheet::get_Type() { + long result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +EXLRange EXLWorksheet::get_UsedRange() { + LPDISPATCH result; + InvokeHelper(0x19c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorksheet::get_HPageBreaks() { + LPDISPATCH result; + InvokeHelper(0x58a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorksheet::get_VPageBreaks() { + LPDISPATCH result; + InvokeHelper(0x58b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorksheet::get_QueryTables() { + LPDISPATCH result; + InvokeHelper(0x59a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL EXLWorksheet::get_DisplayPageBreaks() { + BOOL result; + InvokeHelper(0x59b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::put_DisplayPageBreaks(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x59b, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH EXLWorksheet::get_Comments() { + LPDISPATCH result; + InvokeHelper(0x23f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorksheet::get_Hyperlinks() { + LPDISPATCH result; + InvokeHelper(0x571, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::ClearCircles() { + InvokeHelper(0x59c, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void EXLWorksheet::CircleInvalid() { + InvokeHelper(0x59d, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +long EXLWorksheet::get__DisplayRightToLeft() { + long result; + InvokeHelper(0x288, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::put__DisplayRightToLeft(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x288, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH EXLWorksheet::get_AutoFilter() { + LPDISPATCH result; + InvokeHelper(0x319, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL EXLWorksheet::get_DisplayRightToLeft() { + BOOL result; + InvokeHelper(0x6ee, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::put_DisplayRightToLeft(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x6ee, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH EXLWorksheet::get_Scripts() { + LPDISPATCH result; + InvokeHelper(0x718, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::_PrintOut(VARIANT From, VARIANT To, VARIANT Copies, VARIANT Preview, VARIANT ActivePrinter, VARIANT PrintToFile, VARIANT Collate, VARIANT PrToFileName) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x6ec, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate, &PrToFileName); +} +void EXLWorksheet::_CheckSpelling(VARIANT CustomDictionary, VARIANT IgnoreUppercase, VARIANT AlwaysSuggest, VARIANT SpellLang, VARIANT IgnoreFinalYaa, VARIANT SpellScript) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x719, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang, &IgnoreFinalYaa, &SpellScript); +} +LPDISPATCH EXLWorksheet::get_Tab() { + LPDISPATCH result; + InvokeHelper(0x411, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorksheet::get_MailEnvelope() { + LPDISPATCH result; + InvokeHelper(0x7e5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::SaveAs(LPCTSTR Filename, VARIANT FileFormat, VARIANT Password, VARIANT WriteResPassword, VARIANT ReadOnlyRecommended, VARIANT CreateBackup, VARIANT AddToMru, VARIANT TextCodepage, VARIANT TextVisualLayout, VARIANT Local) { + static BYTE parms[] = VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x785, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Filename, &FileFormat, &Password, &WriteResPassword, &ReadOnlyRecommended, &CreateBackup, &AddToMru, &TextCodepage, &TextVisualLayout, &Local); +} +LPDISPATCH EXLWorksheet::get_CustomProperties() { + LPDISPATCH result; + InvokeHelper(0x7ee, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorksheet::get_SmartTags() { + LPDISPATCH result; + InvokeHelper(0x7e0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorksheet::get_Protection() { + LPDISPATCH result; + InvokeHelper(0xb0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::PasteSpecial(VARIANT Format, VARIANT Link, VARIANT DisplayAsIcon, VARIANT IconFileName, VARIANT IconIndex, VARIANT IconLabel, VARIANT NoHTMLFormatting) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x788, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Format, &Link, &DisplayAsIcon, &IconFileName, &IconIndex, &IconLabel, &NoHTMLFormatting); +} +void EXLWorksheet::Protect(VARIANT Password, VARIANT DrawingObjects, VARIANT Contents, VARIANT Scenarios, VARIANT UserInterfaceOnly, VARIANT AllowFormattingCells, VARIANT AllowFormattingColumns, VARIANT AllowFormattingRows, VARIANT AllowInsertingColumns, VARIANT AllowInsertingRows, VARIANT AllowInsertingHyperlinks, VARIANT AllowDeletingColumns, VARIANT AllowDeletingRows, VARIANT AllowSorting, VARIANT AllowFiltering, VARIANT AllowUsingPivotTables) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x7ed, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Password, &DrawingObjects, &Contents, &Scenarios, &UserInterfaceOnly, &AllowFormattingCells, &AllowFormattingColumns, &AllowFormattingRows, &AllowInsertingColumns, &AllowInsertingRows, &AllowInsertingHyperlinks, &AllowDeletingColumns, &AllowDeletingRows, &AllowSorting, &AllowFiltering, &AllowUsingPivotTables); +} +LPDISPATCH EXLWorksheet::get_ListObjects() { + LPDISPATCH result; + InvokeHelper(0x8d3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorksheet::XmlDataQuery(LPCTSTR XPath, VARIANT SelectionNamespaces, VARIANT Map) { + LPDISPATCH result; + static BYTE parms[] = VTS_BSTR VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x8d4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, XPath, &SelectionNamespaces, &Map); + return result; +} +LPDISPATCH EXLWorksheet::XmlMapQuery(LPCTSTR XPath, VARIANT SelectionNamespaces, VARIANT Map) { + LPDISPATCH result; + static BYTE parms[] = VTS_BSTR VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x8d7, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, XPath, &SelectionNamespaces, &Map); + return result; +} +void EXLWorksheet::PrintOut(VARIANT From, VARIANT To, VARIANT Copies, VARIANT Preview, VARIANT ActivePrinter, VARIANT PrintToFile, VARIANT Collate, VARIANT PrToFileName, VARIANT IgnorePrintAreas) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x939, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate, &PrToFileName, &IgnorePrintAreas); +} +BOOL EXLWorksheet::get_EnableFormatConditionsCalculation() { + BOOL result; + InvokeHelper(0x9cf, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::put_EnableFormatConditionsCalculation(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x9cf, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH EXLWorksheet::get_Sort() { + LPDISPATCH result; + InvokeHelper(0x370, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void EXLWorksheet::ExportAsFixedFormat(long Type, VARIANT Filename, VARIANT Quality, VARIANT IncludeDocProperties, VARIANT IgnorePrintAreas, VARIANT From, VARIANT To, VARIANT OpenAfterPublish, VARIANT FixedFormatExtClassPtr) { + static BYTE parms[] = VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x9bd, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Type, &Filename, &Quality, &IncludeDocProperties, &IgnorePrintAreas, &From, &To, &OpenAfterPublish, &FixedFormatExtClassPtr); +} +long EXLWorksheet::get_PrintedCommentPages() { + long result; + InvokeHelper(0xb29, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +} // namespace MSO::Excel + +#pragma warning( pop ) \ No newline at end of file diff --git a/src/excel/EXLWorksheets.cpp b/src/excel/EXLWorksheets.cpp new file mode 100644 index 0000000..ccdb309 --- /dev/null +++ b/src/excel/EXLWorksheets.cpp @@ -0,0 +1,129 @@ +#include "stdafx.h" + +#include "office/excel/EXLWorksheets.h" + +#include "office/excel/EXLWorksheet.h" + +#pragma warning( push ) +#pragma warning( disable : 26493 26485 26494 ) + +namespace MSO::Excel { + +LPDISPATCH EXLWorksheets::get_Application() { + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +long EXLWorksheets::get_Creator() { + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +LPDISPATCH EXLWorksheets::get_Parent() { + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +EXLWorksheet EXLWorksheets::Add(const EXLWorksheet& Before, const EXLWorksheet& After, VARIANT Count, VARIANT Type) { + VARIANT vBefore(Before); + VARIANT vAfter(After); + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &vBefore, &vAfter, &Count, &Type); + return result; +} + +void EXLWorksheets::Copy(const EXLWorksheet& Before, const EXLWorksheet& After) { + VARIANT vBefore(Before); + VARIANT vAfter(After); + static BYTE parms[] = VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x227, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &vBefore, &vAfter); +} +EXLWorksheets::size_type EXLWorksheets::get_Count() { + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void EXLWorksheets::Delete() { + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void EXLWorksheets::FillAcrossSheets(LPDISPATCH Range, long Type) { + static BYTE parms[] = VTS_DISPATCH VTS_I4; + InvokeHelper(0x1d5, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Range, Type); +} +EXLWorksheet EXLWorksheets::get_Item(VARIANT IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, &IndexType); + return result; +} +void EXLWorksheets::Move(const EXLWorksheet& Before, const EXLWorksheet& After) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x27d, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Before, &After); +} +LPUNKNOWN EXLWorksheets::get_NewEnum() { + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, nullptr); + return result; +} +void EXLWorksheets::__PrintOut(VARIANT From, VARIANT To, VARIANT Copies, VARIANT Preview, VARIANT ActivePrinter, VARIANT PrintToFile, VARIANT Collate) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x389, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate); +} +void EXLWorksheets::PrintPreview(VARIANT EnableChanges) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x119, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &EnableChanges); +} +void EXLWorksheets::Select(VARIANT Replace) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &Replace); +} +LPDISPATCH EXLWorksheets::get_HPageBreaks() { + LPDISPATCH result; + InvokeHelper(0x58a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH EXLWorksheets::get_VPageBreaks() { + LPDISPATCH result; + InvokeHelper(0x58b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +VARIANT EXLWorksheets::get_Visible() { + VARIANT result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void EXLWorksheets::put_Visible(VARIANT newValue) { + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, &newValue); +} +LPDISPATCH EXLWorksheets::get__Default(VARIANT IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, &IndexType); + return result; +} +void EXLWorksheets::_PrintOut(VARIANT From, VARIANT To, VARIANT Copies, VARIANT Preview, VARIANT ActivePrinter, VARIANT PrintToFile, VARIANT Collate, VARIANT PrToFileName) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x6ec, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate, &PrToFileName); +} +void EXLWorksheets::PrintOut(VARIANT From, VARIANT To, VARIANT Copies, VARIANT Preview, VARIANT ActivePrinter, VARIANT PrintToFile, VARIANT Collate, VARIANT PrToFileName, VARIANT IgnorePrintAreas) { + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x939, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, &From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate, &PrToFileName, &IgnorePrintAreas); +} + +EXLWorksheet EXLWorksheets::Add2(const EXLWorksheet& Before, const EXLWorksheet& After, VARIANT Count, VARIANT NewLayout) { + VARIANT vBefore(Before); + VARIANT vAfter(After); + LPDISPATCH result; + static BYTE parms[] = VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xbee, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &vBefore, &vAfter, &Count, &NewLayout); + return result; +} + +} // namespace MSO::Excel + +#pragma warning( pop ) \ No newline at end of file diff --git a/src/stdafx.cpp b/src/stdafx.cpp new file mode 100644 index 0000000..7715608 --- /dev/null +++ b/src/stdafx.cpp @@ -0,0 +1,6 @@ +// stdafx.cpp : source file that includes just the standard includes +// stdafx.pch will be the pre-compiled header +// stdafx.obj will contain the pre-compiled opType information + +#include "stdafx.h" + diff --git a/src/word/WApplication.cpp b/src/word/WApplication.cpp new file mode 100644 index 0000000..c83ff10 --- /dev/null +++ b/src/word/WApplication.cpp @@ -0,0 +1,1167 @@ +#include "stdafx.h" + +#include "office/word/WApplication.h" + +#pragma warning( push ) +#pragma warning( disable : 26493 26485 26494 ) + +namespace MSO::Word { + +WApplication WApplication::get_Application() { + LPDISPATCH result; + InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long WApplication::get_Creator() { + long result; + InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_Parent() { + LPDISPATCH result; + InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +CString WApplication::get_Name() { + CString result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_Documents() { + LPDISPATCH result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_Windows() { + LPDISPATCH result; + InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_ActiveDocument() { + LPDISPATCH result; + InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_ActiveWindow() { + LPDISPATCH result; + InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_Selection() { + LPDISPATCH result; + InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_WordBasic() { + LPDISPATCH result; + InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_RecentFiles() { + LPDISPATCH result; + InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_NormalTemplate() { + LPDISPATCH result; + InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_System() { + LPDISPATCH result; + InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_AutoCorrect() { + LPDISPATCH result; + InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_FontNames() { + LPDISPATCH result; + InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_LandscapeFontNames() { + LPDISPATCH result; + InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_PortraitFontNames() { + LPDISPATCH result; + InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_Languages() { + LPDISPATCH result; + InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_Assistant() { + LPDISPATCH result; + InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_Browser() { + LPDISPATCH result; + InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_FileConverters() { + LPDISPATCH result; + InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_MailingLabel() { + LPDISPATCH result; + InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_Dialogs() { + LPDISPATCH result; + InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_CaptionLabels() { + LPDISPATCH result; + InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_AutoCaptions() { + LPDISPATCH result; + InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_AddIns() { + LPDISPATCH result; + InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL WApplication::get_Visible() { + BOOL result; + InvokeHelper(0x17, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WApplication::put_Visible(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x17, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +CString WApplication::get_Version() { + CString result; + InvokeHelper(0x18, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +BOOL WApplication::get_ScreenUpdating() { + BOOL result; + InvokeHelper(0x1a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WApplication::put_ScreenUpdating(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x1a, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WApplication::get_PrintPreview() { + BOOL result; + InvokeHelper(0x1b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WApplication::put_PrintPreview(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x1b, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WApplication::get_Tasks() { + LPDISPATCH result; + InvokeHelper(0x1c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL WApplication::get_DisplayStatusBar() { + BOOL result; + InvokeHelper(0x1d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WApplication::put_DisplayStatusBar(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x1d, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WApplication::get_SpecialMode() { + BOOL result; + InvokeHelper(0x1e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +long WApplication::get_UsableWidth() { + long result; + InvokeHelper(0x21, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +long WApplication::get_UsableHeight() { + long result; + InvokeHelper(0x22, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +BOOL WApplication::get_MathCoprocessorAvailable() { + BOOL result; + InvokeHelper(0x24, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +BOOL WApplication::get_MouseAvailable() { + BOOL result; + InvokeHelper(0x25, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +VARIANT WApplication::get_International(long IndexType) { + VARIANT result; + static BYTE parms[] = VTS_I4; + InvokeHelper(0x2e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, IndexType); + return result; +} +CString WApplication::get_Build() { + CString result; + InvokeHelper(0x2f, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +BOOL WApplication::get_CapsLock() { + BOOL result; + InvokeHelper(0x30, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +BOOL WApplication::get_NumLock() { + BOOL result; + InvokeHelper(0x31, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +CString WApplication::get_UserName() { + CString result; + InvokeHelper(0x34, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void WApplication::put_UserName(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x34, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +CString WApplication::get_UserInitials() { + CString result; + InvokeHelper(0x35, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void WApplication::put_UserInitials(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x35, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +CString WApplication::get_UserAddress() { + CString result; + InvokeHelper(0x36, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void WApplication::put_UserAddress(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x36, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WApplication::get_MacroContainer() { + LPDISPATCH result; + InvokeHelper(0x37, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL WApplication::get_DisplayRecentFiles() { + BOOL result; + InvokeHelper(0x38, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WApplication::put_DisplayRecentFiles(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x38, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WApplication::get_CommandBars() { + LPDISPATCH result; + InvokeHelper(0x39, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_SynonymInfo(LPCTSTR MSWord, VARIANT * LanguageID) { + LPDISPATCH result; + static BYTE parms[] = VTS_BSTR VTS_PVARIANT; + InvokeHelper(0x3b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, MSWord, LanguageID); + return result; +} +LPDISPATCH WApplication::get_VBE() { + LPDISPATCH result; + InvokeHelper(0x3d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +CString WApplication::get_DefaultSaveFormat() { + CString result; + InvokeHelper(0x40, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void WApplication::put_DefaultSaveFormat(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x40, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WApplication::get_ListGalleries() { + LPDISPATCH result; + InvokeHelper(0x41, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +CString WApplication::get_ActivePrinter() { + CString result; + InvokeHelper(0x42, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void WApplication::put_ActivePrinter(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x42, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WApplication::get_Templates() { + LPDISPATCH result; + InvokeHelper(0x43, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_CustomizationContext() { + LPDISPATCH result; + InvokeHelper(0x44, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void WApplication::put_CustomizationContext(LPDISPATCH newValue) { + static BYTE parms[] = VTS_DISPATCH; + InvokeHelper(0x44, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WApplication::get_KeyBindings() { + LPDISPATCH result; + InvokeHelper(0x45, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_KeysBoundTo(long KeyCategory, LPCTSTR Command, VARIANT * CommandParameter) { + LPDISPATCH result; + static BYTE parms[] = VTS_I4 VTS_BSTR VTS_PVARIANT; + InvokeHelper(0x46, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, KeyCategory, Command, CommandParameter); + return result; +} +LPDISPATCH WApplication::get_FindKey(long KeyCode, VARIANT * KeyCode2) { + LPDISPATCH result; + static BYTE parms[] = VTS_I4 VTS_PVARIANT; + InvokeHelper(0x47, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, KeyCode, KeyCode2); + return result; +} +CString WApplication::get_Caption() { + CString result; + InvokeHelper(0x50, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void WApplication::put_Caption(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x50, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +CString WApplication::get_Path() { + CString result; + InvokeHelper(0x51, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +BOOL WApplication::get_DisplayScrollBars() { + BOOL result; + InvokeHelper(0x52, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WApplication::put_DisplayScrollBars(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x52, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +CString WApplication::get_StartupPath() { + CString result; + InvokeHelper(0x53, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void WApplication::put_StartupPath(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x53, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WApplication::get_BackgroundSavingStatus() { + long result; + InvokeHelper(0x55, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +long WApplication::get_BackgroundPrintingStatus() { + long result; + InvokeHelper(0x56, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +long WApplication::get_Left() { + long result; + InvokeHelper(0x57, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WApplication::put_Left(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x57, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WApplication::get_Top() { + long result; + InvokeHelper(0x58, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WApplication::put_Top(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x58, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WApplication::get_Width() { + long result; + InvokeHelper(0x59, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WApplication::put_Width(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x59, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WApplication::get_Height() { + long result; + InvokeHelper(0x5a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WApplication::put_Height(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x5a, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WApplication::get_WindowState() { + long result; + InvokeHelper(0x5b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WApplication::put_WindowState(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x5b, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WApplication::get_DisplayAutoCompleteTips() { + BOOL result; + InvokeHelper(0x5c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WApplication::put_DisplayAutoCompleteTips(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x5c, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WApplication::get_Options() { + LPDISPATCH result; + InvokeHelper(0x5d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long WApplication::get_DisplayAlerts() { + long result; + InvokeHelper(0x5e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WApplication::put_DisplayAlerts(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x5e, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WApplication::get_CustomDictionaries() { + LPDISPATCH result; + InvokeHelper(0x5f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +CString WApplication::get_PathSeparator() { + CString result; + InvokeHelper(0x60, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void WApplication::put_StatusBar(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x61, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WApplication::get_MAPIAvailable() { + BOOL result; + InvokeHelper(0x62, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +BOOL WApplication::get_DisplayScreenTips() { + BOOL result; + InvokeHelper(0x63, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WApplication::put_DisplayScreenTips(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x63, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WApplication::get_EnableCancelKey() { + long result; + InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WApplication::put_EnableCancelKey(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WApplication::get_UserControl() { + BOOL result; + InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_FileSearch() { + LPDISPATCH result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long WApplication::get_MailSystem() { + long result; + InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +CString WApplication::get_DefaultTableSeparator() { + CString result; + InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void WApplication::put_DefaultTableSeparator(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x69, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WApplication::get_ShowVisualBasicEditor() { + BOOL result; + InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WApplication::put_ShowVisualBasicEditor(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x6a, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +CString WApplication::get_BrowseExtraFileTypes() { + CString result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void WApplication::put_BrowseExtraFileTypes(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x6c, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WApplication::get_IsObjectValid(LPDISPATCH Object) { + BOOL result; + static BYTE parms[] = VTS_DISPATCH; + InvokeHelper(0x6d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms, Object); + return result; +} +LPDISPATCH WApplication::get_HangulHanjaDictionaries() { + LPDISPATCH result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_MailMessage() { + LPDISPATCH result; + InvokeHelper(0x15c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL WApplication::get_FocusInMailHeader() { + BOOL result; + InvokeHelper(0x182, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WApplication::Quit(VARIANT * SaveChanges, VARIANT * OriginalFormat, VARIANT * RouteDocument) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x451, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, SaveChanges, OriginalFormat, RouteDocument); +} +void WApplication::ScreenRefresh() { + InvokeHelper(0x12d, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WApplication::PrintOutOld(VARIANT * Background, VARIANT * Append, VARIANT * Range, VARIANT * OutputFileName, VARIANT * From, VARIANT * To, VARIANT * Item, VARIANT * Copies, VARIANT * Pages, VARIANT * PageType, VARIANT * PrintToFile, VARIANT * Collate, VARIANT * FileName, VARIANT * ActivePrinterMacGX, VARIANT * ManualDuplexPrint) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x12e, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Background, Append, Range, OutputFileName, From, To, Item, Copies, Pages, PageType, PrintToFile, Collate, FileName, ActivePrinterMacGX, ManualDuplexPrint); +} +void WApplication::LookupNameProperties(LPCTSTR Name) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x12f, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Name); +} +void WApplication::SubstituteFont(LPCTSTR UnavailableFont, LPCTSTR SubstituteFont) { + static BYTE parms[] = VTS_BSTR VTS_BSTR; + InvokeHelper(0x130, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, UnavailableFont, SubstituteFont); +} +BOOL WApplication::Repeat(VARIANT * Times) { + BOOL result; + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0x131, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, Times); + return result; +} +void WApplication::DDEExecute(long Channel, LPCTSTR Command) { + static BYTE parms[] = VTS_I4 VTS_BSTR; + InvokeHelper(0x136, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Channel, Command); +} +long WApplication::DDEInitiate(LPCTSTR App, LPCTSTR Topic) { + long result; + static BYTE parms[] = VTS_BSTR VTS_BSTR; + InvokeHelper(0x137, DISPATCH_METHOD, VT_I4, (void*)&result, parms, App, Topic); + return result; +} +void WApplication::DDEPoke(long Channel, LPCTSTR Item, LPCTSTR Data) { + static BYTE parms[] = VTS_I4 VTS_BSTR VTS_BSTR; + InvokeHelper(0x138, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Channel, Item, Data); +} +CString WApplication::DDERequest(long Channel, LPCTSTR Item) { + CString result; + static BYTE parms[] = VTS_I4 VTS_BSTR; + InvokeHelper(0x139, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms, Channel, Item); + return result; +} +void WApplication::DDETerminate(long Channel) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x13a, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Channel); +} +void WApplication::DDETerminateAll() { + InvokeHelper(0x13b, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +long WApplication::BuildKeyCode(long Arg1, VARIANT * Arg2, VARIANT * Arg3, VARIANT * Arg4) { + long result; + static BYTE parms[] = VTS_I4 VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x13c, DISPATCH_METHOD, VT_I4, (void*)&result, parms, Arg1, Arg2, Arg3, Arg4); + return result; +} +CString WApplication::KeyString(long KeyCode, VARIANT * KeyCode2) { + CString result; + static BYTE parms[] = VTS_I4 VTS_PVARIANT; + InvokeHelper(0x13d, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms, KeyCode, KeyCode2); + return result; +} +void WApplication::OrganizerCopy(LPCTSTR src, LPCTSTR Destination, LPCTSTR Name, long Object) { + static BYTE parms[] = VTS_BSTR VTS_BSTR VTS_BSTR VTS_I4; + InvokeHelper(0x13e, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, src, Destination, Name, Object); +} +void WApplication::OrganizerDelete(LPCTSTR src, LPCTSTR Name, long Object) { + static BYTE parms[] = VTS_BSTR VTS_BSTR VTS_I4; + InvokeHelper(0x13f, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, src, Name, Object); +} +void WApplication::OrganizerRename(LPCTSTR src, LPCTSTR Name, LPCTSTR NewName, long Object) { + static BYTE parms[] = VTS_BSTR VTS_BSTR VTS_BSTR VTS_I4; + InvokeHelper(0x140, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, src, Name, NewName, Object); +} +void WApplication::AddAddress(SAFEARRAY * * TagID, SAFEARRAY * * Value) { + static BYTE parms[] = VTS_UNKNOWN VTS_UNKNOWN; + InvokeHelper(0x141, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, TagID, Value); +} +CString WApplication::GetAddress(VARIANT * Name, VARIANT * AddressProperties, VARIANT * UseAutoText, VARIANT * DisplaySelectDialog, VARIANT * SelectDialog, VARIANT * CheckNamesDialog, VARIANT * RecentAddressesChoice, VARIANT * UpdateRecentAddresses) { + CString result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x142, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms, Name, AddressProperties, UseAutoText, DisplaySelectDialog, SelectDialog, CheckNamesDialog, RecentAddressesChoice, UpdateRecentAddresses); + return result; +} +BOOL WApplication::CheckGrammar(LPCTSTR String) { + BOOL result; + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x143, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, String); + return result; +} +BOOL WApplication::CheckSpelling(LPCTSTR MSWord, VARIANT * CustomDictionary, VARIANT * IgnoreUppercase, VARIANT * MainDictionary, VARIANT * CustomDictionary2, VARIANT * CustomDictionary3, VARIANT * CustomDictionary4, VARIANT * CustomDictionary5, VARIANT * CustomDictionary6, VARIANT * CustomDictionary7, VARIANT * CustomDictionary8, VARIANT * CustomDictionary9, VARIANT * CustomDictionary10) { + BOOL result; + static BYTE parms[] = VTS_BSTR VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x144, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, MSWord, CustomDictionary, IgnoreUppercase, MainDictionary, CustomDictionary2, CustomDictionary3, CustomDictionary4, CustomDictionary5, CustomDictionary6, CustomDictionary7, CustomDictionary8, CustomDictionary9, CustomDictionary10); + return result; +} +void WApplication::ResetIgnoreAll() { + InvokeHelper(0x146, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +LPDISPATCH WApplication::GetSpellingSuggestions(LPCTSTR MSWord, VARIANT * CustomDictionary, VARIANT * IgnoreUppercase, VARIANT * MainDictionary, VARIANT * SuggestionMode, VARIANT * CustomDictionary2, VARIANT * CustomDictionary3, VARIANT * CustomDictionary4, VARIANT * CustomDictionary5, VARIANT * CustomDictionary6, VARIANT * CustomDictionary7, VARIANT * CustomDictionary8, VARIANT * CustomDictionary9, VARIANT * CustomDictionary10) { + LPDISPATCH result; + static BYTE parms[] = VTS_BSTR VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x147, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, MSWord, CustomDictionary, IgnoreUppercase, MainDictionary, SuggestionMode, CustomDictionary2, CustomDictionary3, CustomDictionary4, CustomDictionary5, CustomDictionary6, CustomDictionary7, CustomDictionary8, CustomDictionary9, CustomDictionary10); + return result; +} +void WApplication::GoBack() { + InvokeHelper(0x148, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WApplication::Help(VARIANT * HelpType) { + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0x149, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, HelpType); +} +void WApplication::AutomaticChange() { + InvokeHelper(0x14a, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WApplication::ShowMe() { + InvokeHelper(0x14b, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WApplication::HelpTool() { + InvokeHelper(0x14c, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +LPDISPATCH WApplication::NewWindow() { + LPDISPATCH result; + InvokeHelper(0x159, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void WApplication::ListCommands(BOOL ListAllCommands) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x15a, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, ListAllCommands); +} +void WApplication::ShowClipboard() { + InvokeHelper(0x15d, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WApplication::OnTime(VARIANT * When, LPCTSTR Name, VARIANT * Tolerance) { + static BYTE parms[] = VTS_PVARIANT VTS_BSTR VTS_PVARIANT; + InvokeHelper(0x15e, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, When, Name, Tolerance); +} +void WApplication::NextLetter() { + InvokeHelper(0x15f, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +short WApplication::MountVolume(LPCTSTR Zone, LPCTSTR Server, LPCTSTR Volume, VARIANT * User, VARIANT * UserPassword, VARIANT * VolumePassword) { + short result; + static BYTE parms[] = VTS_BSTR VTS_BSTR VTS_BSTR VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x161, DISPATCH_METHOD, VT_I2, (void*)&result, parms, Zone, Server, Volume, User, UserPassword, VolumePassword); + return result; +} +CString WApplication::CleanString(LPCTSTR String) { + CString result; + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x162, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms, String); + return result; +} +void WApplication::SendFax() { + InvokeHelper(0x164, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WApplication::ChangeFileOpenDirectory(LPCTSTR Path) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x165, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Path); +} +void WApplication::RunOld(LPCTSTR MacroName) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x166, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, MacroName); +} +void WApplication::GoForward() { + InvokeHelper(0x167, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WApplication::Move(long Left, long Top) { + static BYTE parms[] = VTS_I4 VTS_I4; + InvokeHelper(0x168, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Left, Top); +} +void WApplication::Resize(long Width, long Height) { + static BYTE parms[] = VTS_I4 VTS_I4; + InvokeHelper(0x169, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Width, Height); +} +float WApplication::InchesToPoints(float Inches) { + float result; + static BYTE parms[] = VTS_R4; + InvokeHelper(0x172, DISPATCH_METHOD, VT_R4, (void*)&result, parms, Inches); + return result; +} +float WApplication::CentimetersToPoints(float Centimeters) { + float result; + static BYTE parms[] = VTS_R4; + InvokeHelper(0x173, DISPATCH_METHOD, VT_R4, (void*)&result, parms, Centimeters); + return result; +} +float WApplication::MillimetersToPoints(float Millimeters) { + float result; + static BYTE parms[] = VTS_R4; + InvokeHelper(0x174, DISPATCH_METHOD, VT_R4, (void*)&result, parms, Millimeters); + return result; +} +float WApplication::PicasToPoints(float Picas) { + float result; + static BYTE parms[] = VTS_R4; + InvokeHelper(0x175, DISPATCH_METHOD, VT_R4, (void*)&result, parms, Picas); + return result; +} +float WApplication::LinesToPoints(float Lines) { + float result; + static BYTE parms[] = VTS_R4; + InvokeHelper(0x176, DISPATCH_METHOD, VT_R4, (void*)&result, parms, Lines); + return result; +} +float WApplication::PointsToInches(float Points) { + float result; + static BYTE parms[] = VTS_R4; + InvokeHelper(0x17c, DISPATCH_METHOD, VT_R4, (void*)&result, parms, Points); + return result; +} +float WApplication::PointsToCentimeters(float Points) { + float result; + static BYTE parms[] = VTS_R4; + InvokeHelper(0x17d, DISPATCH_METHOD, VT_R4, (void*)&result, parms, Points); + return result; +} +float WApplication::PointsToMillimeters(float Points) { + float result; + static BYTE parms[] = VTS_R4; + InvokeHelper(0x17e, DISPATCH_METHOD, VT_R4, (void*)&result, parms, Points); + return result; +} +float WApplication::PointsToPicas(float Points) { + float result; + static BYTE parms[] = VTS_R4; + InvokeHelper(0x17f, DISPATCH_METHOD, VT_R4, (void*)&result, parms, Points); + return result; +} +float WApplication::PointsToLines(float Points) { + float result; + static BYTE parms[] = VTS_R4; + InvokeHelper(0x180, DISPATCH_METHOD, VT_R4, (void*)&result, parms, Points); + return result; +} +void WApplication::Activate() { + InvokeHelper(0x181, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +float WApplication::PointsToPixels(float Points, VARIANT * fVertical) { + float result; + static BYTE parms[] = VTS_R4 VTS_PVARIANT; + InvokeHelper(0x183, DISPATCH_METHOD, VT_R4, (void*)&result, parms, Points, fVertical); + return result; +} +float WApplication::PixelsToPoints(float Pixels, VARIANT * fVertical) { + float result; + static BYTE parms[] = VTS_R4 VTS_PVARIANT; + InvokeHelper(0x184, DISPATCH_METHOD, VT_R4, (void*)&result, parms, Pixels, fVertical); + return result; +} +void WApplication::KeyboardLatin() { + InvokeHelper(0x190, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WApplication::KeyboardBidi() { + InvokeHelper(0x191, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WApplication::ToggleKeyboard() { + InvokeHelper(0x192, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +long WApplication::Keyboard(long LangId) { + long result; + static BYTE parms[] = VTS_I4; + InvokeHelper(0x1be, DISPATCH_METHOD, VT_I4, (void*)&result, parms, LangId); + return result; +} +CString WApplication::ProductCode() { + CString result; + InvokeHelper(0x194, DISPATCH_METHOD, VT_BSTR, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::DefaultWebOptions() { + LPDISPATCH result; + InvokeHelper(0x195, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void WApplication::DiscussionSupport(VARIANT * Range, VARIANT * cid, VARIANT * piCSE) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x197, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Range, cid, piCSE); +} +void WApplication::SetDefaultTheme(LPCTSTR Name, long DocumentType) { + static BYTE parms[] = VTS_BSTR VTS_I4; + InvokeHelper(0x19e, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Name, DocumentType); +} +CString WApplication::GetDefaultTheme(long DocumentType) { + CString result; + static BYTE parms[] = VTS_I4; + InvokeHelper(0x1a0, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms, DocumentType); + return result; +} +LPDISPATCH WApplication::get_EmailOptions() { + LPDISPATCH result; + InvokeHelper(0x185, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long WApplication::get_Language() { + long result; + InvokeHelper(0x187, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_COMAddIns() { + LPDISPATCH result; + InvokeHelper(0x6f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL WApplication::get_CheckLanguage() { + BOOL result; + InvokeHelper(0x70, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WApplication::put_CheckLanguage(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x70, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WApplication::get_LanguageSettings() { + LPDISPATCH result; + InvokeHelper(0x193, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL WApplication::get_Dummy1() { + BOOL result; + InvokeHelper(0x196, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_AnswerWizard() { + LPDISPATCH result; + InvokeHelper(0x199, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long WApplication::get_FeatureInstall() { + long result; + InvokeHelper(0x1bf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WApplication::put_FeatureInstall(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x1bf, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +void WApplication::PrintOut2000(VARIANT * Background, VARIANT * Append, VARIANT * Range, VARIANT * OutputFileName, VARIANT * From, VARIANT * To, VARIANT * Item, VARIANT * Copies, VARIANT * Pages, VARIANT * PageType, VARIANT * PrintToFile, VARIANT * Collate, VARIANT * FileName, VARIANT * ActivePrinterMacGX, VARIANT * ManualDuplexPrint, VARIANT * PrintZoomColumn, VARIANT * PrintZoomRow, VARIANT * PrintZoomPaperWidth, VARIANT * PrintZoomPaperHeight) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x1bc, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Background, Append, Range, OutputFileName, From, To, Item, Copies, Pages, PageType, PrintToFile, Collate, FileName, ActivePrinterMacGX, ManualDuplexPrint, PrintZoomColumn, PrintZoomRow, PrintZoomPaperWidth, PrintZoomPaperHeight); +} +VARIANT WApplication::Run(LPCTSTR MacroName, VARIANT * varg1, VARIANT * varg2, VARIANT * varg3, VARIANT * varg4, VARIANT * varg5, VARIANT * varg6, VARIANT * varg7, VARIANT * varg8, VARIANT * varg9, VARIANT * varg10, VARIANT * varg11, VARIANT * varg12, VARIANT * varg13, VARIANT * varg14, VARIANT * varg15, VARIANT * varg16, VARIANT * varg17, VARIANT * varg18, VARIANT * varg19, VARIANT * varg20, VARIANT * varg21, VARIANT * varg22, VARIANT * varg23, VARIANT * varg24, VARIANT * varg25, VARIANT * varg26, VARIANT * varg27, VARIANT * varg28, VARIANT * varg29, VARIANT * varg30) { + VARIANT result; + static BYTE parms[] = VTS_BSTR VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x1bd, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, MacroName, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13, varg14, varg15, varg16, varg17, varg18, varg19, varg20, varg21, varg22, varg23, varg24, varg25, varg26, varg27, varg28, varg29, varg30); + return result; +} +void WApplication::PrintOut(VARIANT * Background, VARIANT * Append, VARIANT * Range, VARIANT * OutputFileName, VARIANT * From, VARIANT * To, VARIANT * Item, VARIANT * Copies, VARIANT * Pages, VARIANT * PageType, VARIANT * PrintToFile, VARIANT * Collate, VARIANT * FileName, VARIANT * ActivePrinterMacGX, VARIANT * ManualDuplexPrint, VARIANT * PrintZoomColumn, VARIANT * PrintZoomRow, VARIANT * PrintZoomPaperWidth, VARIANT * PrintZoomPaperHeight) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x1c0, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Background, Append, Range, OutputFileName, From, To, Item, Copies, Pages, PageType, PrintToFile, Collate, FileName, ActivePrinterMacGX, ManualDuplexPrint, PrintZoomColumn, PrintZoomRow, PrintZoomPaperWidth, PrintZoomPaperHeight); +} +long WApplication::get_AutomationSecurity() { + long result; + InvokeHelper(0x1c1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WApplication::put_AutomationSecurity(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x1c1, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WApplication::get_FileDialog(long FileDialogType) { + LPDISPATCH result; + static BYTE parms[] = VTS_I4; + InvokeHelper(0x1c2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, FileDialogType); + return result; +} +CString WApplication::get_EmailTemplate() { + CString result; + InvokeHelper(0x1c3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void WApplication::put_EmailTemplate(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x1c3, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WApplication::get_ShowWindowsInTaskbar() { + BOOL result; + InvokeHelper(0x1c4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WApplication::put_ShowWindowsInTaskbar(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x1c4, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WApplication::get_NewDocument() { + LPDISPATCH result; + InvokeHelper(0x1c6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL WApplication::get_ShowStartupDialog() { + BOOL result; + InvokeHelper(0x1c7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WApplication::put_ShowStartupDialog(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x1c7, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WApplication::get_AutoCorrectEmail() { + LPDISPATCH result; + InvokeHelper(0x1c8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_TaskPanes() { + LPDISPATCH result; + InvokeHelper(0x1c9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL WApplication::get_DefaultLegalBlackline() { + BOOL result; + InvokeHelper(0x1cb, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WApplication::put_DefaultLegalBlackline(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x1cb, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WApplication::Dummy2() { + BOOL result; + InvokeHelper(0x1ca, DISPATCH_METHOD, VT_BOOL, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_SmartTagRecognizers() { + LPDISPATCH result; + InvokeHelper(0x1cc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_SmartTagTypes() { + LPDISPATCH result; + InvokeHelper(0x1cd, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_XMLNamespaces() { + LPDISPATCH result; + InvokeHelper(0x1cf, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void WApplication::PutFocusInMailHeader() { + InvokeHelper(0x1d0, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +BOOL WApplication::get_ArbitraryXMLSupportAvailable() { + BOOL result; + InvokeHelper(0x1d1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +CString WApplication::get_BuildFull() { + CString result; + InvokeHelper(0x1d2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +CString WApplication::get_BuildFeatureCrew() { + CString result; + InvokeHelper(0x1d3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void WApplication::LoadMasterList(LPCTSTR FileName) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x1d5, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, FileName); +} +LPDISPATCH WApplication::CompareDocuments(LPDISPATCH OriginalDocument, LPDISPATCH RevisedDocument, long Destination, long Granularity, BOOL CompareFormatting, BOOL CompareCaseChanges, BOOL CompareWhitespace, BOOL CompareTables, BOOL CompareHeaders, BOOL CompareFootnotes, BOOL CompareTextboxes, BOOL CompareFields, BOOL CompareComments, BOOL CompareMoves, LPCTSTR RevisedAuthor, BOOL IgnoreAllComparisonWarnings) { + LPDISPATCH result; + static BYTE parms[] = VTS_DISPATCH VTS_DISPATCH VTS_I4 VTS_I4 VTS_BOOL VTS_BOOL VTS_BOOL VTS_BOOL VTS_BOOL VTS_BOOL VTS_BOOL VTS_BOOL VTS_BOOL VTS_BOOL VTS_BSTR VTS_BOOL; + InvokeHelper(0x1d6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, OriginalDocument, RevisedDocument, Destination, Granularity, CompareFormatting, CompareCaseChanges, CompareWhitespace, CompareTables, CompareHeaders, CompareFootnotes, CompareTextboxes, CompareFields, CompareComments, CompareMoves, RevisedAuthor, IgnoreAllComparisonWarnings); + return result; +} +LPDISPATCH WApplication::MergeDocuments(LPDISPATCH OriginalDocument, LPDISPATCH RevisedDocument, long Destination, long Granularity, BOOL CompareFormatting, BOOL CompareCaseChanges, BOOL CompareWhitespace, BOOL CompareTables, BOOL CompareHeaders, BOOL CompareFootnotes, BOOL CompareTextboxes, BOOL CompareFields, BOOL CompareComments, BOOL CompareMoves, LPCTSTR OriginalAuthor, LPCTSTR RevisedAuthor, long FormatFrom) { + LPDISPATCH result; + static BYTE parms[] = VTS_DISPATCH VTS_DISPATCH VTS_I4 VTS_I4 VTS_BOOL VTS_BOOL VTS_BOOL VTS_BOOL VTS_BOOL VTS_BOOL VTS_BOOL VTS_BOOL VTS_BOOL VTS_BOOL VTS_BSTR VTS_BSTR VTS_I4; + InvokeHelper(0x1d7, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, OriginalDocument, RevisedDocument, Destination, Granularity, CompareFormatting, CompareCaseChanges, CompareWhitespace, CompareTables, CompareHeaders, CompareFootnotes, CompareTextboxes, CompareFields, CompareComments, CompareMoves, OriginalAuthor, RevisedAuthor, FormatFrom); + return result; +} +LPDISPATCH WApplication::get_Bibliography() { + LPDISPATCH result; + InvokeHelper(0x1d8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL WApplication::get_ShowStylePreviews() { + BOOL result; + InvokeHelper(0x1d9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WApplication::put_ShowStylePreviews(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x1d9, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WApplication::get_RestrictLinkedStyles() { + BOOL result; + InvokeHelper(0x1da, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WApplication::put_RestrictLinkedStyles(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x1da, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WApplication::get_OMathAutoCorrect() { + LPDISPATCH result; + InvokeHelper(0x1db, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL WApplication::get_DisplayDocumentInformationPanel() { + BOOL result; + InvokeHelper(0x1dc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WApplication::put_DisplayDocumentInformationPanel(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x1dc, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WApplication::get_Assistance() { + LPDISPATCH result; + InvokeHelper(0x1dd, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL WApplication::get_OpenAttachmentsInFullScreen() { + BOOL result; + InvokeHelper(0x1de, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WApplication::put_OpenAttachmentsInFullScreen(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x1de, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WApplication::get_ActiveEncryptionSession() { + long result; + InvokeHelper(0x1df, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +BOOL WApplication::get_DontResetInsertionPointProperties() { + BOOL result; + InvokeHelper(0x1e0, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WApplication::put_DontResetInsertionPointProperties(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x1e0, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WApplication::get_SmartArtLayouts() { + LPDISPATCH result; + InvokeHelper(0x1e1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_SmartArtQuickStyles() { + LPDISPATCH result; + InvokeHelper(0x1e2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_SmartArtColors() { + LPDISPATCH result; + InvokeHelper(0x1e3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void WApplication::ThreeWayMerge(LPDISPATCH LocalDocument, LPDISPATCH ServerDocument, LPDISPATCH BaseDocument, BOOL FavorSource) { + static BYTE parms[] = VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH VTS_BOOL; + InvokeHelper(0x1e4, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, LocalDocument, ServerDocument, BaseDocument, FavorSource); +} +void WApplication::Dummy4() { + InvokeHelper(0x1e5, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +LPDISPATCH WApplication::get_UndoRecord() { + LPDISPATCH result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_PickerDialog() { + LPDISPATCH result; + InvokeHelper(0x1e9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_ProtectedViewWindows() { + LPDISPATCH result; + InvokeHelper(0x1ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WApplication::get_ActiveProtectedViewWindow() { + LPDISPATCH result; + InvokeHelper(0x1eb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL WApplication::get_IsSandboxed() { + BOOL result; + InvokeHelper(0x1ec, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +long WApplication::get_FileValidation() { + long result; + InvokeHelper(0x1ed, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WApplication::put_FileValidation(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x1ed, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WApplication::get_ChartDataPointTrack() { + BOOL result; + InvokeHelper(0x1ee, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WApplication::put_ChartDataPointTrack(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x1ee, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WApplication::get_ShowAnimation() { + BOOL result; + InvokeHelper(0x1ef, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WApplication::put_ShowAnimation(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x1ef, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +} // namespace MSO::Word + +#pragma warning( pop ) \ No newline at end of file diff --git a/src/word/WBookmark.cpp b/src/word/WBookmark.cpp new file mode 100644 index 0000000..5b338e4 --- /dev/null +++ b/src/word/WBookmark.cpp @@ -0,0 +1,86 @@ +#include "stdafx.h" + +#include "office/word/WBookmark.h" + +#include "office/word/WRange.h" +#include "office/word/WApplication.h" + +#pragma warning( push ) +#pragma warning( disable : 26493 26485 26494 ) + +namespace MSO::Word { + +CString WBookmark::get_Name() { + CString result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +WRange WBookmark::get_Range() { + LPDISPATCH result; + InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL WBookmark::get_Empty() { + BOOL result; + InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +long WBookmark::get_Start() { + long result; + InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WBookmark::put_Start(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WBookmark::get_End() { + long result; + InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WBookmark::put_End(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WBookmark::get_Column() { + BOOL result; + InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +long WBookmark::get_StoryType() { + long result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +WApplication WBookmark::get_Application() { + LPDISPATCH result; + InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long WBookmark::get_Creator() { + long result; + InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +LPDISPATCH WBookmark::get_Parent() { + LPDISPATCH result; + InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void WBookmark::Select() { + InvokeHelper(0xffff, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WBookmark::Delete() { + InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +LPDISPATCH WBookmark::Copy(LPCTSTR Name) { + LPDISPATCH result; + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0xc, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Name); + return result; +} + +} // namespace MSO::Word + +#pragma warning( pop ) \ No newline at end of file diff --git a/src/word/WBookmarks.cpp b/src/word/WBookmarks.cpp new file mode 100644 index 0000000..ec0d51f --- /dev/null +++ b/src/word/WBookmarks.cpp @@ -0,0 +1,77 @@ +#include "stdafx.h" + +#include "office/word/WBookmarks.h" + +#include "office/word/WBookmark.h" +#include "office/word/WApplication.h" + +#pragma warning( push ) +#pragma warning( disable : 26493 26485 26494 ) + +namespace MSO::Word { + +LPUNKNOWN WBookmarks::get_NewEnum() { + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, nullptr); + return result; +} +long WBookmarks::get_Count() { + long result; + InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +long WBookmarks::get_DefaultSorting() { + long result; + InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WBookmarks::put_DefaultSorting(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WBookmarks::get_ShowHidden() { + BOOL result; + InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WBookmarks::put_ShowHidden(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +WApplication WBookmarks::get_Application() { + LPDISPATCH result; + InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long WBookmarks::get_Creator() { + long result; + InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +LPDISPATCH WBookmarks::get_Parent() { + LPDISPATCH result; + InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +WBookmark WBookmarks::get_Item(VARIANT IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &IndexType); + return result; +} +WBookmark WBookmarks::Add(LPCTSTR Name, VARIANT * Range) { + LPDISPATCH result; + static BYTE parms[] = VTS_BSTR VTS_PVARIANT; + InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Name, Range); + return result; +} +BOOL WBookmarks::Exists(LPCTSTR Name) { + BOOL result; + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x6, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, Name); + return result; +} + +} // namespace MSO::Word + +#pragma warning( pop ) \ No newline at end of file diff --git a/src/word/WCell.cpp b/src/word/WCell.cpp new file mode 100644 index 0000000..84de537 --- /dev/null +++ b/src/word/WCell.cpp @@ -0,0 +1,239 @@ +#include "stdafx.h" + +#include "office/word/WCell.h" + +#include "office/word/WApplication.h" +#include "office/word/WRange.h" +#include "office/word/WColumn.h" +#include "office/word/WRow.h" + +#pragma warning( push ) +#pragma warning( disable : 26493 26485 26494 ) + +namespace MSO::Word { + +WRange WCell::get_Range() { + LPDISPATCH result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +WApplication WCell::get_Application() { + LPDISPATCH result; + InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long WCell::get_Creator() { + long result; + InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +LPDISPATCH WCell::get_Parent() { + LPDISPATCH result; + InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long WCell::get_RowIndex() { + long result; + InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +long WCell::get_ColumnIndex() { + long result; + InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +float WCell::get_Width() { + float result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WCell::put_Width(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +float WCell::get_Height() { + float result; + InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WCell::put_Height(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WCell::get_HeightRule() { + long result; + InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WCell::put_HeightRule(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WCell::get_VerticalAlignment() { + long result; + InvokeHelper(0x450, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WCell::put_VerticalAlignment(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x450, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +WColumn WCell::get_Column() { + LPDISPATCH result; + InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +WRow WCell::get_Row() { + LPDISPATCH result; + InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WCell::get_Next() { + LPDISPATCH result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WCell::get_Previous() { + LPDISPATCH result; + InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WCell::get_Shading() { + LPDISPATCH result; + InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WCell::get_Borders() { + LPDISPATCH result; + InvokeHelper(0x44c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void WCell::put_Borders(LPDISPATCH newValue) { + static BYTE parms[] = VTS_DISPATCH; + InvokeHelper(0x44c, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +void WCell::Select() { + InvokeHelper(0xffff, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WCell::Delete(VARIANT * ShiftCells) { + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0xc8, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, ShiftCells); +} +void WCell::Formula(VARIANT * Formula, VARIANT * NumFormat) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0xc9, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Formula, NumFormat); +} +void WCell::SetWidth(float ColumnWidth, long RulerStyle) { + static BYTE parms[] = VTS_R4 VTS_I4; + InvokeHelper(0xca, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, ColumnWidth, RulerStyle); +} +void WCell::SetHeight(VARIANT * RowHeight, long HeightRule) { + static BYTE parms[] = VTS_PVARIANT VTS_I4; + InvokeHelper(0xcb, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, RowHeight, HeightRule); +} +void WCell::Merge(LPDISPATCH MergeTo) { + static BYTE parms[] = VTS_DISPATCH; + InvokeHelper(0xcc, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, MergeTo); +} +void WCell::Split(VARIANT * NumRows, VARIANT * NumColumns) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0xcd, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, NumRows, NumColumns); +} +void WCell::AutoSum() { + InvokeHelper(0xce, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +LPDISPATCH WCell::get_Tables() { + LPDISPATCH result; + InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long WCell::get_NestingLevel() { + long result; + InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +BOOL WCell::get_WordWrap() { + BOOL result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WCell::put_WordWrap(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x6c, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +float WCell::get_PreferredWidth() { + float result; + InvokeHelper(0x6d, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WCell::put_PreferredWidth(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x6d, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WCell::get_FitText() { + BOOL result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WCell::put_FitText(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +float WCell::get_TopPadding() { + float result; + InvokeHelper(0x6f, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WCell::put_TopPadding(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x6f, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +float WCell::get_BottomPadding() { + float result; + InvokeHelper(0x70, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WCell::put_BottomPadding(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x70, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +float WCell::get_LeftPadding() { + float result; + InvokeHelper(0x71, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WCell::put_LeftPadding(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x71, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +float WCell::get_RightPadding() { + float result; + InvokeHelper(0x72, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WCell::put_RightPadding(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x72, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +CString WCell::get_ID() { + CString result; + InvokeHelper(0x73, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void WCell::put_ID(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x73, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WCell::get_PreferredWidthType() { + long result; + InvokeHelper(0x74, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WCell::put_PreferredWidthType(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x74, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +} // namespace MSO::Word + +#pragma warning( pop ) \ No newline at end of file diff --git a/src/word/WColumn.cpp b/src/word/WColumn.cpp new file mode 100644 index 0000000..e62723e --- /dev/null +++ b/src/word/WColumn.cpp @@ -0,0 +1,127 @@ +#include "stdafx.h" + +#include "office/word/WColumn.h" + +#include "office/word/WApplication.h" + +#pragma warning( push ) +#pragma warning( disable : 26493 26485 26494 ) + +namespace MSO::Word { + +LPDISPATCH WColumn::get_Application() { + LPDISPATCH result; + InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long WColumn::get_Creator() { + long result; + InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +LPDISPATCH WColumn::get_Parent() { + LPDISPATCH result; + InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +float WColumn::get_Width() { + float result; + InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WColumn::put_Width(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WColumn::get_IsFirst() { + BOOL result; + InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +BOOL WColumn::get_IsLast() { + BOOL result; + InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +long WColumn::get_Index() { + long result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +LPDISPATCH WColumn::get_Cells() { + LPDISPATCH result; + InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WColumn::get_Borders() { + LPDISPATCH result; + InvokeHelper(0x44c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void WColumn::put_Borders(LPDISPATCH newValue) { + static BYTE parms[] = VTS_DISPATCH; + InvokeHelper(0x44c, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WColumn::get_Shading() { + LPDISPATCH result; + InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WColumn::get_Next() { + LPDISPATCH result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WColumn::get_Previous() { + LPDISPATCH result; + InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void WColumn::Select() { + InvokeHelper(0xffff, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WColumn::Delete() { + InvokeHelper(0xc8, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WColumn::SetWidth(float ColumnWidth, long RulerStyle) { + static BYTE parms[] = VTS_R4 VTS_I4; + InvokeHelper(0xc9, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, ColumnWidth, RulerStyle); +} +void WColumn::AutoFit() { + InvokeHelper(0xca, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WColumn::SortOld(VARIANT * ExcludeHeader, VARIANT * SortFieldType, VARIANT * SortOrder, VARIANT * CaseSensitive, VARIANT * LanguageID) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0xcb, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, ExcludeHeader, SortFieldType, SortOrder, CaseSensitive, LanguageID); +} +void WColumn::Sort(VARIANT * ExcludeHeader, VARIANT * SortFieldType, VARIANT * SortOrder, VARIANT * CaseSensitive, VARIANT * BidiSort, VARIANT * IgnoreThe, VARIANT * IgnoreKashida, VARIANT * IgnoreDiacritics, VARIANT * IgnoreHe, VARIANT * LanguageID) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0xcc, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, ExcludeHeader, SortFieldType, SortOrder, CaseSensitive, BidiSort, IgnoreThe, IgnoreKashida, IgnoreDiacritics, IgnoreHe, LanguageID); +} +long WColumn::get_NestingLevel() { + long result; + InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +float WColumn::get_PreferredWidth() { + float result; + InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WColumn::put_PreferredWidth(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x6a, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WColumn::get_PreferredWidthType() { + long result; + InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WColumn::put_PreferredWidthType(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x6b, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +} // namespace MSO::Word + +#pragma warning( pop ) \ No newline at end of file diff --git a/src/word/WColumns.cpp b/src/word/WColumns.cpp new file mode 100644 index 0000000..a75ba10 --- /dev/null +++ b/src/word/WColumns.cpp @@ -0,0 +1,125 @@ +#include "stdafx.h" + +#include "office/word/WColumns.h" + +#include "office/word/WApplication.h" +#include "office/word/WColumn.h" + +#pragma warning( push ) +#pragma warning( disable : 26493 26485 26494 ) + +namespace MSO::Word { + +LPUNKNOWN WColumns::get_NewEnum() { + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, nullptr); + return result; +} +long WColumns::get_Count() { + long result; + InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +WApplication WColumns::get_Application() { + LPDISPATCH result; + InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long WColumns::get_Creator() { + long result; + InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +LPDISPATCH WColumns::get_Parent() { + LPDISPATCH result; + InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +WColumn WColumns::get_First() { + LPDISPATCH result; + InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +WColumn WColumns::get_Last() { + LPDISPATCH result; + InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +float WColumns::get_Width() { + float result; + InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WColumns::put_Width(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WColumns::get_Borders() { + LPDISPATCH result; + InvokeHelper(0x44c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void WColumns::put_Borders(LPDISPATCH newValue) { + static BYTE parms[] = VTS_DISPATCH; + InvokeHelper(0x44c, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WColumns::get_Shading() { + LPDISPATCH result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +WColumn WColumns::get_Item(long IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_I4; + InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, IndexType); + return result; +} +WColumn WColumns::Add(VARIANT * BeforeColumn) { + LPDISPATCH result; + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, BeforeColumn); + return result; +} +void WColumns::Select() { + InvokeHelper(0xc7, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WColumns::Delete() { + InvokeHelper(0xc8, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WColumns::SetWidth(float ColumnWidth, long RulerStyle) { + static BYTE parms[] = VTS_R4 VTS_I4; + InvokeHelper(0xc9, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, ColumnWidth, RulerStyle); +} +void WColumns::AutoFit() { + InvokeHelper(0xca, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WColumns::DistributeWidth() { + InvokeHelper(0xcb, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +long WColumns::get_NestingLevel() { + long result; + InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +float WColumns::get_PreferredWidth() { + float result; + InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WColumns::put_PreferredWidth(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x69, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WColumns::get_PreferredWidthType() { + long result; + InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WColumns::put_PreferredWidthType(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x6a, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +} // namespace MSO::Word + +#pragma warning( pop ) \ No newline at end of file diff --git a/src/word/WComment.cpp b/src/word/WComment.cpp new file mode 100644 index 0000000..b8e1dd4 --- /dev/null +++ b/src/word/WComment.cpp @@ -0,0 +1,120 @@ +#include "stdafx.h" + +#include "office/word/WComment.h" + +#include "office/word/WApplication.h" + +#pragma warning( push ) +#pragma warning( disable : 26493 26485 26494 ) + +namespace MSO::Word { + +LPDISPATCH WComment::get_Application() { + LPDISPATCH result; + InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long WComment::get_Creator() { + long result; + InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +LPDISPATCH WComment::get_Parent() { + LPDISPATCH result; + InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WComment::get_Range() { + LPDISPATCH result; + InvokeHelper(0x3eb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WComment::get_Reference() { + LPDISPATCH result; + InvokeHelper(0x3ec, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WComment::get_Scope() { + LPDISPATCH result; + InvokeHelper(0x3ed, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long WComment::get_Index() { + long result; + InvokeHelper(0x3ee, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +CString WComment::get_Author() { + CString result; + InvokeHelper(0x3ef, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void WComment::put_Author(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x3ef, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +CString WComment::get_Initial() { + CString result; + InvokeHelper(0x3f0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void WComment::put_Initial(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x3f0, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WComment::get_ShowTip() { + BOOL result; + InvokeHelper(0x3f1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WComment::put_ShowTip(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x3f1, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +void WComment::Delete() { + InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WComment::Edit() { + InvokeHelper(0x3f3, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +DATE WComment::get_Date() { + DATE result; + InvokeHelper(0x3f2, DISPATCH_PROPERTYGET, VT_DATE, (void*)&result, nullptr); + return result; +} +BOOL WComment::get_IsInk() { + BOOL result; + InvokeHelper(0x3f4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +BOOL WComment::get_Done() { + BOOL result; + InvokeHelper(0x3f5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WComment::put_Done(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x3f5, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WComment::get_Ancestor() { + LPDISPATCH result; + InvokeHelper(0x3f6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WComment::get_Contact() { + LPDISPATCH result; + InvokeHelper(0x3f7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void WComment::DeleteRecursively() { + InvokeHelper(0x3f8, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +LPDISPATCH WComment::get_Replies() { + LPDISPATCH result; + InvokeHelper(0x3f9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +} // namespace MSO::Word + +#pragma warning( pop ) \ No newline at end of file diff --git a/src/word/WComments.cpp b/src/word/WComments.cpp new file mode 100644 index 0000000..cb494e4 --- /dev/null +++ b/src/word/WComments.cpp @@ -0,0 +1,62 @@ +#include "stdafx.h" + +#include "office/word/WComments.h" + +#include "office/word/WApplication.h" +#include "office/word/WRange.h" + +#pragma warning( push ) +#pragma warning( disable : 26493 26485 26494 ) + +namespace MSO::Word { + +LPUNKNOWN WComments::get_NewEnum() { + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, nullptr); + return result; +} +long WComments::get_Count() { + long result; + InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +LPDISPATCH WComments::get_Application() { + LPDISPATCH result; + InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long WComments::get_Creator() { + long result; + InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +LPDISPATCH WComments::get_Parent() { + LPDISPATCH result; + InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +CString WComments::get_ShowBy() { + CString result; + InvokeHelper(0x3eb, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void WComments::put_ShowBy(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x3eb, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WComments::get_Item(long IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_I4; + InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, IndexType); + return result; +} +LPDISPATCH WComments::Add(WRange Range, VARIANT * Text) { + LPDISPATCH result; + static BYTE parms[] = VTS_DISPATCH VTS_PVARIANT; + InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Range.m_lpDispatch, Text); + return result; +} + +} // namespace MSO::Word + +#pragma warning( pop ) \ No newline at end of file diff --git a/src/word/WDocument.cpp b/src/word/WDocument.cpp new file mode 100644 index 0000000..7c6d7db --- /dev/null +++ b/src/word/WDocument.cpp @@ -0,0 +1,1957 @@ +#include "stdafx.h" + +#include "office/word/WDocument.h" + +#include "office/word/WApplication.h" +#include "office/word/WBookmarks.h" +#include "office/word/WTables.h" + +#pragma warning( push ) +#pragma warning( disable : 26493 26485 26494 ) + +namespace MSO::Word { + +CString WDocument::get_Name() { + CString result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +WApplication WDocument::get_Application() { + LPDISPATCH result; + InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long WDocument::get_Creator() { + long result; + InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_Parent() { + LPDISPATCH result; + InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_BuiltInDocumentProperties() { + LPDISPATCH result; + InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_CustomDocumentProperties() { + LPDISPATCH result; + InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +CString WDocument::get_Path() { + CString result; + InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +WBookmarks WDocument::get_Bookmarks() { + LPDISPATCH result; + InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +WTables WDocument::get_Tables() { + LPDISPATCH result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_Footnotes() { + LPDISPATCH result; + InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_Endnotes() { + LPDISPATCH result; + InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_Comments() { + LPDISPATCH result; + InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long WDocument::get_Type() { + long result; + InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +BOOL WDocument::get_AutoHyphenation() { + BOOL result; + InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_AutoHyphenation(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0xb, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_HyphenateCaps() { + BOOL result; + InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_HyphenateCaps(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WDocument::get_HyphenationZone() { + long result; + InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WDocument::put_HyphenationZone(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0xd, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WDocument::get_ConsecutiveHyphensLimit() { + long result; + InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WDocument::put_ConsecutiveHyphensLimit(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0xe, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WDocument::get_Sections() { + LPDISPATCH result; + InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_Paragraphs() { + LPDISPATCH result; + InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_Words() { + LPDISPATCH result; + InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_Sentences() { + LPDISPATCH result; + InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_Characters() { + LPDISPATCH result; + InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_Fields() { + LPDISPATCH result; + InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_FormFields() { + LPDISPATCH result; + InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_Styles() { + LPDISPATCH result; + InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_Frames() { + LPDISPATCH result; + InvokeHelper(0x17, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_TablesOfFigures() { + LPDISPATCH result; + InvokeHelper(0x19, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_Variables() { + LPDISPATCH result; + InvokeHelper(0x1a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_MailMerge() { + LPDISPATCH result; + InvokeHelper(0x1b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_Envelope() { + LPDISPATCH result; + InvokeHelper(0x1c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +CString WDocument::get_FullName() { + CString result; + InvokeHelper(0x1d, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_Revisions() { + LPDISPATCH result; + InvokeHelper(0x1e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_TablesOfContents() { + LPDISPATCH result; + InvokeHelper(0x1f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_TablesOfAuthorities() { + LPDISPATCH result; + InvokeHelper(0x20, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_PageSetup() { + LPDISPATCH result; + InvokeHelper(0x44d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void WDocument::put_PageSetup(LPDISPATCH newValue) { + static BYTE parms[] = VTS_DISPATCH; + InvokeHelper(0x44d, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WDocument::get_Windows() { + LPDISPATCH result; + InvokeHelper(0x22, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL WDocument::get_HasRoutingSlip() { + BOOL result; + InvokeHelper(0x23, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_HasRoutingSlip(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x23, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WDocument::get_RoutingSlip() { + LPDISPATCH result; + InvokeHelper(0x24, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL WDocument::get_Routed() { + BOOL result; + InvokeHelper(0x25, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_TablesOfAuthoritiesCategories() { + LPDISPATCH result; + InvokeHelper(0x26, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_Indexes() { + LPDISPATCH result; + InvokeHelper(0x27, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL WDocument::get_Saved() { + BOOL result; + InvokeHelper(0x28, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_Saved(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x28, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WDocument::get_Content() { + LPDISPATCH result; + InvokeHelper(0x29, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_ActiveWindow() { + LPDISPATCH result; + InvokeHelper(0x2a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long WDocument::get_Kind() { + long result; + InvokeHelper(0x2b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WDocument::put_Kind(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x2b, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_ReadOnly() { + BOOL result; + InvokeHelper(0x2c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_Subdocuments() { + LPDISPATCH result; + InvokeHelper(0x2d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL WDocument::get_IsMasterDocument() { + BOOL result; + InvokeHelper(0x2e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +float WDocument::get_DefaultTabStop() { + float result; + InvokeHelper(0x30, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WDocument::put_DefaultTabStop(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x30, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_EmbedTrueTypeFonts() { + BOOL result; + InvokeHelper(0x32, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_EmbedTrueTypeFonts(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x32, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_SaveFormsData() { + BOOL result; + InvokeHelper(0x33, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_SaveFormsData(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x33, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_ReadOnlyRecommended() { + BOOL result; + InvokeHelper(0x34, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_ReadOnlyRecommended(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x34, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_SaveSubsetFonts() { + BOOL result; + InvokeHelper(0x35, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_SaveSubsetFonts(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x35, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_Compatibility(long Type) { + BOOL result; + static BYTE parms[] = VTS_I4; + InvokeHelper(0x37, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms, Type); + return result; +} +void WDocument::put_Compatibility(long Type, BOOL newValue) { + static BYTE parms[] = VTS_I4 VTS_BOOL; + InvokeHelper(0x37, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, Type, newValue); +} +LPDISPATCH WDocument::get_StoryRanges() { + LPDISPATCH result; + InvokeHelper(0x38, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_CommandBars() { + LPDISPATCH result; + InvokeHelper(0x39, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL WDocument::get_IsSubdocument() { + BOOL result; + InvokeHelper(0x3a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +long WDocument::get_SaveFormat() { + long result; + InvokeHelper(0x3b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +long WDocument::get_ProtectionType() { + long result; + InvokeHelper(0x3c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_Hyperlinks() { + LPDISPATCH result; + InvokeHelper(0x3d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_Shapes() { + LPDISPATCH result; + InvokeHelper(0x3e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_ListTemplates() { + LPDISPATCH result; + InvokeHelper(0x3f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_Lists() { + LPDISPATCH result; + InvokeHelper(0x40, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL WDocument::get_UpdateStylesOnOpen() { + BOOL result; + InvokeHelper(0x42, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_UpdateStylesOnOpen(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x42, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +VARIANT WDocument::get_AttachedTemplate() { + VARIANT result; + InvokeHelper(0x43, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void WDocument::put_AttachedTemplate(VARIANT * newValue) { + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0x43, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WDocument::get_InlineShapes() { + LPDISPATCH result; + InvokeHelper(0x44, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_Background() { + LPDISPATCH result; + InvokeHelper(0x45, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void WDocument::put_Background(LPDISPATCH newValue) { + static BYTE parms[] = VTS_DISPATCH; + InvokeHelper(0x45, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_GrammarChecked() { + BOOL result; + InvokeHelper(0x46, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_GrammarChecked(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x46, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_SpellingChecked() { + BOOL result; + InvokeHelper(0x47, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_SpellingChecked(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x47, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_ShowGrammaticalErrors() { + BOOL result; + InvokeHelper(0x48, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_ShowGrammaticalErrors(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x48, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_ShowSpellingErrors() { + BOOL result; + InvokeHelper(0x49, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_ShowSpellingErrors(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x49, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WDocument::get_Versions() { + LPDISPATCH result; + InvokeHelper(0x4b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL WDocument::get_ShowSummary() { + BOOL result; + InvokeHelper(0x4c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_ShowSummary(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x4c, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WDocument::get_SummaryViewMode() { + long result; + InvokeHelper(0x4d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WDocument::put_SummaryViewMode(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x4d, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WDocument::get_SummaryLength() { + long result; + InvokeHelper(0x4e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WDocument::put_SummaryLength(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x4e, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_PrintFractionalWidths() { + BOOL result; + InvokeHelper(0x4f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_PrintFractionalWidths(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x4f, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_PrintPostScriptOverText() { + BOOL result; + InvokeHelper(0x50, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_PrintPostScriptOverText(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x50, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WDocument::get_Container() { + LPDISPATCH result; + InvokeHelper(0x52, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL WDocument::get_PrintFormsData() { + BOOL result; + InvokeHelper(0x53, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_PrintFormsData(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x53, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WDocument::get_ListParagraphs() { + LPDISPATCH result; + InvokeHelper(0x54, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void WDocument::put_Password(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x55, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +void WDocument::put_WritePassword(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x56, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_HasPassword() { + BOOL result; + InvokeHelper(0x57, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +BOOL WDocument::get_WriteReserved() { + BOOL result; + InvokeHelper(0x58, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +CString WDocument::get_ActiveWritingStyle(VARIANT * LanguageID) { + CString result; + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0x5a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms, LanguageID); + return result; +} +void WDocument::put_ActiveWritingStyle(VARIANT * LanguageID, LPCTSTR newValue) { + static BYTE parms[] = VTS_PVARIANT VTS_BSTR; + InvokeHelper(0x5a, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, LanguageID, newValue); +} +BOOL WDocument::get_UserControl() { + BOOL result; + InvokeHelper(0x5c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_UserControl(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x5c, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_HasMailer() { + BOOL result; + InvokeHelper(0x5d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_HasMailer(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x5d, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WDocument::get_Mailer() { + LPDISPATCH result; + InvokeHelper(0x5e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_ReadabilityStatistics() { + LPDISPATCH result; + InvokeHelper(0x60, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_GrammaticalErrors() { + LPDISPATCH result; + InvokeHelper(0x61, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_SpellingErrors() { + LPDISPATCH result; + InvokeHelper(0x62, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_VBProject() { + LPDISPATCH result; + InvokeHelper(0x63, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL WDocument::get_FormsDesign() { + BOOL result; + InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +CString WDocument::get__CodeName() { + CString result; + InvokeHelper(0x80010000, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void WDocument::put__CodeName(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x80010000, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +CString WDocument::get_CodeName() { + CString result; + InvokeHelper(0x106, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +BOOL WDocument::get_SnapToGrid() { + BOOL result; + InvokeHelper(0x12c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_SnapToGrid(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x12c, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_SnapToShapes() { + BOOL result; + InvokeHelper(0x12d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_SnapToShapes(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x12d, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +float WDocument::get_GridDistanceHorizontal() { + float result; + InvokeHelper(0x12e, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WDocument::put_GridDistanceHorizontal(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x12e, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +float WDocument::get_GridDistanceVertical() { + float result; + InvokeHelper(0x12f, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WDocument::put_GridDistanceVertical(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x12f, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +float WDocument::get_GridOriginHorizontal() { + float result; + InvokeHelper(0x130, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WDocument::put_GridOriginHorizontal(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x130, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +float WDocument::get_GridOriginVertical() { + float result; + InvokeHelper(0x131, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WDocument::put_GridOriginVertical(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x131, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WDocument::get_GridSpaceBetweenHorizontalLines() { + long result; + InvokeHelper(0x132, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WDocument::put_GridSpaceBetweenHorizontalLines(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x132, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WDocument::get_GridSpaceBetweenVerticalLines() { + long result; + InvokeHelper(0x133, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WDocument::put_GridSpaceBetweenVerticalLines(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x133, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_GridOriginFromMargin() { + BOOL result; + InvokeHelper(0x134, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_GridOriginFromMargin(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x134, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_KerningByAlgorithm() { + BOOL result; + InvokeHelper(0x135, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_KerningByAlgorithm(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x135, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WDocument::get_JustificationMode() { + long result; + InvokeHelper(0x136, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WDocument::put_JustificationMode(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x136, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WDocument::get_FarEastLineBreakLevel() { + long result; + InvokeHelper(0x137, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WDocument::put_FarEastLineBreakLevel(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x137, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +CString WDocument::get_NoLineBreakBefore() { + CString result; + InvokeHelper(0x138, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void WDocument::put_NoLineBreakBefore(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x138, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +CString WDocument::get_NoLineBreakAfter() { + CString result; + InvokeHelper(0x139, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void WDocument::put_NoLineBreakAfter(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x139, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_TrackRevisions() { + BOOL result; + InvokeHelper(0x13a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_TrackRevisions(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x13a, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_PrintRevisions() { + BOOL result; + InvokeHelper(0x13b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_PrintRevisions(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x13b, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_ShowRevisions() { + BOOL result; + InvokeHelper(0x13c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_ShowRevisions(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x13c, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +void WDocument::Close(VARIANT * SaveChanges, VARIANT * OriginalFormat, VARIANT * RouteDocument) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x451, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, SaveChanges, OriginalFormat, RouteDocument); +} +void WDocument::SaveAs2000(VARIANT * FileName, VARIANT * FileFormat, VARIANT * LockComments, VARIANT * Password, VARIANT * AddToRecentFiles, VARIANT * WritePassword, VARIANT * ReadOnlyRecommended, VARIANT * EmbedTrueTypeFonts, VARIANT * SaveNativePictureFormat, VARIANT * SaveFormsData, VARIANT * SaveAsAOCELetter) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, FileName, FileFormat, LockComments, Password, AddToRecentFiles, WritePassword, ReadOnlyRecommended, EmbedTrueTypeFonts, SaveNativePictureFormat, SaveFormsData, SaveAsAOCELetter); +} +void WDocument::Repaginate() { + InvokeHelper(0x67, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::FitToPages() { + InvokeHelper(0x68, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::ManualHyphenation() { + InvokeHelper(0x69, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::Select() { + InvokeHelper(0xffff, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::DataForm() { + InvokeHelper(0x6a, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::Route() { + InvokeHelper(0x6b, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::Save() { + InvokeHelper(0x6c, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::PrintOutOld(VARIANT * Background, VARIANT * Append, VARIANT * Range, VARIANT * OutputFileName, VARIANT * From, VARIANT * To, VARIANT * Item, VARIANT * Copies, VARIANT * Pages, VARIANT * PageType, VARIANT * PrintToFile, VARIANT * Collate, VARIANT * ActivePrinterMacGX, VARIANT * ManualDuplexPrint) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x6d, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Background, Append, Range, OutputFileName, From, To, Item, Copies, Pages, PageType, PrintToFile, Collate, ActivePrinterMacGX, ManualDuplexPrint); +} +void WDocument::SendMail() { + InvokeHelper(0x6e, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +LPDISPATCH WDocument::Range(VARIANT * Start, VARIANT * End) { + LPDISPATCH result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x7d0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Start, End); + return result; +} +void WDocument::RunAutoMacro(long Which) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x70, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Which); +} +void WDocument::Activate() { + InvokeHelper(0x71, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::PrintPreview() { + InvokeHelper(0x72, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +LPDISPATCH WDocument::GoTo(VARIANT * What, VARIANT * Which, VARIANT * Count, VARIANT * Name) { + LPDISPATCH result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x73, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, What, Which, Count, Name); + return result; +} +BOOL WDocument::Undo(VARIANT * Times) { + BOOL result; + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0x74, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, Times); + return result; +} +BOOL WDocument::Redo(VARIANT * Times) { + BOOL result; + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0x75, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, Times); + return result; +} +long WDocument::ComputeStatistics(long Statistic, VARIANT * IncludeFootnotesAndEndnotes) { + long result; + static BYTE parms[] = VTS_I4 VTS_PVARIANT; + InvokeHelper(0x76, DISPATCH_METHOD, VT_I4, (void*)&result, parms, Statistic, IncludeFootnotesAndEndnotes); + return result; +} +void WDocument::MakeCompatibilityDefault() { + InvokeHelper(0x77, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::Protect2002(long Type, VARIANT * NoReset, VARIANT * Password) { + static BYTE parms[] = VTS_I4 VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x78, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Type, NoReset, Password); +} +void WDocument::Unprotect(VARIANT * Password) { + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0x79, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Password); +} +void WDocument::EditionOptions(long Type, long Option, LPCTSTR Name, VARIANT * Format) { + static BYTE parms[] = VTS_I4 VTS_I4 VTS_BSTR VTS_PVARIANT; + InvokeHelper(0x7a, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Type, Option, Name, Format); +} +void WDocument::RunLetterWizard(VARIANT * LetterContent, VARIANT * WizardMode) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x7b, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, LetterContent, WizardMode); +} +LPDISPATCH WDocument::GetLetterContent() { + LPDISPATCH result; + InvokeHelper(0x7c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void WDocument::SetLetterContent(VARIANT * LetterContent) { + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0x7d, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, LetterContent); +} +void WDocument::CopyStylesFromTemplate(LPCTSTR Template) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x7e, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Template); +} +void WDocument::UpdateStyles() { + InvokeHelper(0x7f, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::CheckGrammar() { + InvokeHelper(0x83, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::CheckSpelling(VARIANT * CustomDictionary, VARIANT * IgnoreUppercase, VARIANT * AlwaysSuggest, VARIANT * CustomDictionary2, VARIANT * CustomDictionary3, VARIANT * CustomDictionary4, VARIANT * CustomDictionary5, VARIANT * CustomDictionary6, VARIANT * CustomDictionary7, VARIANT * CustomDictionary8, VARIANT * CustomDictionary9, VARIANT * CustomDictionary10) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x84, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, CustomDictionary, IgnoreUppercase, AlwaysSuggest, CustomDictionary2, CustomDictionary3, CustomDictionary4, CustomDictionary5, CustomDictionary6, CustomDictionary7, CustomDictionary8, CustomDictionary9, CustomDictionary10); +} +void WDocument::FollowHyperlink(VARIANT * Address, VARIANT * SubAddress, VARIANT * NewWindow, VARIANT * AddHistory, VARIANT * ExtraInfo, VARIANT * Method, VARIANT * HeaderInfo) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x87, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Address, SubAddress, NewWindow, AddHistory, ExtraInfo, Method, HeaderInfo); +} +void WDocument::AddToFavorites() { + InvokeHelper(0x88, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::Reload() { + InvokeHelper(0x89, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +LPDISPATCH WDocument::AutoSummarize(VARIANT * Length, VARIANT * Mode, VARIANT * UpdateProperties) { + LPDISPATCH result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x8a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Length, Mode, UpdateProperties); + return result; +} +void WDocument::RemoveNumbers(VARIANT * NumberType) { + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0x8c, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, NumberType); +} +void WDocument::ConvertNumbersToText(VARIANT * NumberType) { + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0x8d, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, NumberType); +} +long WDocument::CountNumberedItems(VARIANT * NumberType, VARIANT * Level) { + long result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x8e, DISPATCH_METHOD, VT_I4, (void*)&result, parms, NumberType, Level); + return result; +} +void WDocument::Post() { + InvokeHelper(0x8f, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::ToggleFormsDesign() { + InvokeHelper(0x90, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::Compare2000(LPCTSTR Name) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x91, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Name); +} +void WDocument::UpdateSummaryProperties() { + InvokeHelper(0x92, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +VARIANT WDocument::GetCrossReferenceItems(VARIANT * ReferenceType) { + VARIANT result; + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0x93, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, ReferenceType); + return result; +} +void WDocument::AutoFormat() { + InvokeHelper(0x94, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::ViewCode() { + InvokeHelper(0x95, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::ViewPropertyBrowser() { + InvokeHelper(0x96, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::ForwardMailer() { + InvokeHelper(0xfa, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::Reply() { + InvokeHelper(0xfb, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::ReplyAll() { + InvokeHelper(0xfc, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::SendMailer(VARIANT * FileFormat, VARIANT * Priority) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0xfd, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, FileFormat, Priority); +} +void WDocument::UndoClear() { + InvokeHelper(0xfe, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::PresentIt() { + InvokeHelper(0xff, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::SendFax(LPCTSTR Address, VARIANT * Subject) { + static BYTE parms[] = VTS_BSTR VTS_PVARIANT; + InvokeHelper(0x100, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Address, Subject); +} +void WDocument::Merge2000(LPCTSTR FileName) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x101, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, FileName); +} +void WDocument::ClosePrintPreview() { + InvokeHelper(0x102, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::CheckConsistency() { + InvokeHelper(0x103, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +LPDISPATCH WDocument::CreateLetterContent(LPCTSTR DateFormat, BOOL IncludeHeaderFooter, LPCTSTR PageDesign, long LetterStyle, BOOL Letterhead, long LetterheadLocation, float LetterheadSize, LPCTSTR RecipientName, LPCTSTR RecipientAddress, LPCTSTR Salutation, long SalutationType, LPCTSTR RecipientReference, LPCTSTR MailingInstructions, LPCTSTR AttentionLine, LPCTSTR Subject, LPCTSTR CCList, LPCTSTR ReturnAddress, LPCTSTR SenderName, LPCTSTR Closing, LPCTSTR SenderCompany, LPCTSTR SenderJobTitle, LPCTSTR SenderInitials, long EnclosureNumber, VARIANT * InfoBlock, VARIANT * RecipientCode, VARIANT * RecipientGender, VARIANT * ReturnAddressShortForm, VARIANT * SenderCity, VARIANT * SenderCode, VARIANT * SenderGender, VARIANT * SenderReference) { + LPDISPATCH result; + static BYTE parms[] = VTS_BSTR VTS_BOOL VTS_BSTR VTS_I4 VTS_BOOL VTS_I4 VTS_R4 VTS_BSTR VTS_BSTR VTS_BSTR VTS_I4 VTS_BSTR VTS_BSTR VTS_BSTR VTS_BSTR VTS_BSTR VTS_BSTR VTS_BSTR VTS_BSTR VTS_BSTR VTS_BSTR VTS_BSTR VTS_I4 VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x104, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, DateFormat, IncludeHeaderFooter, PageDesign, LetterStyle, Letterhead, LetterheadLocation, LetterheadSize, RecipientName, RecipientAddress, Salutation, SalutationType, RecipientReference, MailingInstructions, AttentionLine, Subject, CCList, ReturnAddress, SenderName, Closing, SenderCompany, SenderJobTitle, SenderInitials, EnclosureNumber, InfoBlock, RecipientCode, RecipientGender, ReturnAddressShortForm, SenderCity, SenderCode, SenderGender, SenderReference); + return result; +} +void WDocument::AcceptAllRevisions() { + InvokeHelper(0x13d, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::RejectAllRevisions() { + InvokeHelper(0x13e, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::DetectLanguage() { + InvokeHelper(0x97, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::ApplyTheme(LPCTSTR Name) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x142, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Name); +} +void WDocument::RemoveTheme() { + InvokeHelper(0x143, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::WebPagePreview() { + InvokeHelper(0x145, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::ReloadAs(long Encoding) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x14b, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Encoding); +} +CString WDocument::get_ActiveTheme() { + CString result; + InvokeHelper(0x21c, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +CString WDocument::get_ActiveThemeDisplayName() { + CString result; + InvokeHelper(0x21d, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_Email() { + LPDISPATCH result; + InvokeHelper(0x13f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_Scripts() { + LPDISPATCH result; + InvokeHelper(0x140, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL WDocument::get_LanguageDetected() { + BOOL result; + InvokeHelper(0x141, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_LanguageDetected(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x141, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WDocument::get_FarEastLineBreakLanguage() { + long result; + InvokeHelper(0x146, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WDocument::put_FarEastLineBreakLanguage(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x146, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WDocument::get_Frameset() { + LPDISPATCH result; + InvokeHelper(0x147, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +VARIANT WDocument::get_ClickAndTypeParagraphStyle() { + VARIANT result; + InvokeHelper(0x148, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +void WDocument::put_ClickAndTypeParagraphStyle(VARIANT * newValue) { + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0x148, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WDocument::get_HTMLProject() { + LPDISPATCH result; + InvokeHelper(0x149, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_WebOptions() { + LPDISPATCH result; + InvokeHelper(0x14a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long WDocument::get_OpenEncoding() { + long result; + InvokeHelper(0x14c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +long WDocument::get_SaveEncoding() { + long result; + InvokeHelper(0x14d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WDocument::put_SaveEncoding(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x14d, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_OptimizeForWord97() { + BOOL result; + InvokeHelper(0x14e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_OptimizeForWord97(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x14e, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_VBASigned() { + BOOL result; + InvokeHelper(0x14f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::PrintOut2000(VARIANT * Background, VARIANT * Append, VARIANT * Range, VARIANT * OutputFileName, VARIANT * From, VARIANT * To, VARIANT * Item, VARIANT * Copies, VARIANT * Pages, VARIANT * PageType, VARIANT * PrintToFile, VARIANT * Collate, VARIANT * ActivePrinterMacGX, VARIANT * ManualDuplexPrint, VARIANT * PrintZoomColumn, VARIANT * PrintZoomRow, VARIANT * PrintZoomPaperWidth, VARIANT * PrintZoomPaperHeight) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x1bc, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Background, Append, Range, OutputFileName, From, To, Item, Copies, Pages, PageType, PrintToFile, Collate, ActivePrinterMacGX, ManualDuplexPrint, PrintZoomColumn, PrintZoomRow, PrintZoomPaperWidth, PrintZoomPaperHeight); +} +void WDocument::sblt(LPCTSTR s) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x1bd, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, s); +} +void WDocument::ConvertVietDoc(long CodePageOrigin) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x1bf, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, CodePageOrigin); +} +void WDocument::PrintOut(VARIANT * Background, VARIANT * Append, VARIANT * Range, VARIANT * OutputFileName, VARIANT * From, VARIANT * To, VARIANT * Item, VARIANT * Copies, VARIANT * Pages, VARIANT * PageType, VARIANT * PrintToFile, VARIANT * Collate, VARIANT * ActivePrinterMacGX, VARIANT * ManualDuplexPrint, VARIANT * PrintZoomColumn, VARIANT * PrintZoomRow, VARIANT * PrintZoomPaperWidth, VARIANT * PrintZoomPaperHeight) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x1be, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Background, Append, Range, OutputFileName, From, To, Item, Copies, Pages, PageType, PrintToFile, Collate, ActivePrinterMacGX, ManualDuplexPrint, PrintZoomColumn, PrintZoomRow, PrintZoomPaperWidth, PrintZoomPaperHeight); +} +LPDISPATCH WDocument::get_MailEnvelope() { + LPDISPATCH result; + InvokeHelper(0x150, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL WDocument::get_DisableFeatures() { + BOOL result; + InvokeHelper(0x151, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_DisableFeatures(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x151, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_DoNotEmbedSystemFonts() { + BOOL result; + InvokeHelper(0x152, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_DoNotEmbedSystemFonts(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x152, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WDocument::get_Signatures() { + LPDISPATCH result; + InvokeHelper(0x153, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +CString WDocument::get_DefaultTargetFrame() { + CString result; + InvokeHelper(0x154, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void WDocument::put_DefaultTargetFrame(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x154, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WDocument::get_HTMLDivisions() { + LPDISPATCH result; + InvokeHelper(0x156, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long WDocument::get_DisableFeaturesIntroducedAfter() { + long result; + InvokeHelper(0x157, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WDocument::put_DisableFeaturesIntroducedAfter(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x157, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_RemovePersonalInformation() { + BOOL result; + InvokeHelper(0x158, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_RemovePersonalInformation(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x158, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WDocument::get_SmartTags() { + LPDISPATCH result; + InvokeHelper(0x15a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void WDocument::Compare2002(LPCTSTR Name, VARIANT * AuthorName, VARIANT * CompareTarget, VARIANT * DetectFormatChanges, VARIANT * IgnoreAllComparisonWarnings, VARIANT * AddToRecentFiles) { + static BYTE parms[] = VTS_BSTR VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x159, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Name, AuthorName, CompareTarget, DetectFormatChanges, IgnoreAllComparisonWarnings, AddToRecentFiles); +} +void WDocument::CheckIn(BOOL SaveChanges, VARIANT * Comments, BOOL MakePublic) { + static BYTE parms[] = VTS_BOOL VTS_PVARIANT VTS_BOOL; + InvokeHelper(0x15d, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, SaveChanges, Comments, MakePublic); +} +BOOL WDocument::CanCheckin() { + BOOL result; + InvokeHelper(0x15f, DISPATCH_METHOD, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::Merge(LPCTSTR FileName, VARIANT * MergeTarget, VARIANT * DetectFormatChanges, VARIANT * UseFormattingFrom, VARIANT * AddToRecentFiles) { + static BYTE parms[] = VTS_BSTR VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x16a, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, FileName, MergeTarget, DetectFormatChanges, UseFormattingFrom, AddToRecentFiles); +} +BOOL WDocument::get_EmbedSmartTags() { + BOOL result; + InvokeHelper(0x15b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_EmbedSmartTags(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x15b, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_SmartTagsAsXMLProps() { + BOOL result; + InvokeHelper(0x15c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_SmartTagsAsXMLProps(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x15c, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WDocument::get_TextEncoding() { + long result; + InvokeHelper(0x165, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WDocument::put_TextEncoding(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x165, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WDocument::get_TextLineEnding() { + long result; + InvokeHelper(0x166, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WDocument::put_TextLineEnding(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x166, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +void WDocument::SendForReview(VARIANT * Recipients, VARIANT * Subject, VARIANT * ShowMessage, VARIANT * IncludeAttachment) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x161, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Recipients, Subject, ShowMessage, IncludeAttachment); +} +void WDocument::ReplyWithChanges(VARIANT * ShowMessage) { + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0x162, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, ShowMessage); +} +void WDocument::EndReview() { + InvokeHelper(0x164, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +LPDISPATCH WDocument::get_StyleSheets() { + LPDISPATCH result; + InvokeHelper(0x168, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +VARIANT WDocument::get_DefaultTableStyle() { + VARIANT result; + InvokeHelper(0x16d, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} +CString WDocument::get_PasswordEncryptionProvider() { + CString result; + InvokeHelper(0x16f, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +CString WDocument::get_PasswordEncryptionAlgorithm() { + CString result; + InvokeHelper(0x170, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +long WDocument::get_PasswordEncryptionKeyLength() { + long result; + InvokeHelper(0x171, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +BOOL WDocument::get_PasswordEncryptionFileProperties() { + BOOL result; + InvokeHelper(0x172, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::SetPasswordEncryptionOptions(LPCTSTR PasswordEncryptionProvider, LPCTSTR PasswordEncryptionAlgorithm, long PasswordEncryptionKeyLength, VARIANT * PasswordEncryptionFileProperties) { + static BYTE parms[] = VTS_BSTR VTS_BSTR VTS_I4 VTS_PVARIANT; + InvokeHelper(0x169, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, PasswordEncryptionProvider, PasswordEncryptionAlgorithm, PasswordEncryptionKeyLength, PasswordEncryptionFileProperties); +} +void WDocument::RecheckSmartTags() { + InvokeHelper(0x16b, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::RemoveSmartTags() { + InvokeHelper(0x16c, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::SetDefaultTableStyle(VARIANT * Style, BOOL SetInTemplate) { + static BYTE parms[] = VTS_PVARIANT VTS_BOOL; + InvokeHelper(0x16e, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Style, SetInTemplate); +} +void WDocument::DeleteAllComments() { + InvokeHelper(0x173, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::AcceptAllRevisionsShown() { + InvokeHelper(0x174, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::RejectAllRevisionsShown() { + InvokeHelper(0x175, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::DeleteAllCommentsShown() { + InvokeHelper(0x176, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::ResetFormFields() { + InvokeHelper(0x177, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::SaveAs(VARIANT * FileName, VARIANT * FileFormat, VARIANT * LockComments, VARIANT * Password, VARIANT * AddToRecentFiles, VARIANT * WritePassword, VARIANT * ReadOnlyRecommended, VARIANT * EmbedTrueTypeFonts, VARIANT * SaveNativePictureFormat, VARIANT * SaveFormsData, VARIANT * SaveAsAOCELetter, VARIANT * Encoding, VARIANT * InsertLineBreaks, VARIANT * AllowSubstitutions, VARIANT * LineEnding, VARIANT * AddBiDiMarks) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x178, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, FileName, FileFormat, LockComments, Password, AddToRecentFiles, WritePassword, ReadOnlyRecommended, EmbedTrueTypeFonts, SaveNativePictureFormat, SaveFormsData, SaveAsAOCELetter, Encoding, InsertLineBreaks, AllowSubstitutions, LineEnding, AddBiDiMarks); +} +BOOL WDocument::get_EmbedLinguisticData() { + BOOL result; + InvokeHelper(0x179, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_EmbedLinguisticData(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x179, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_FormattingShowFont() { + BOOL result; + InvokeHelper(0x1c0, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_FormattingShowFont(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x1c0, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_FormattingShowClear() { + BOOL result; + InvokeHelper(0x1c1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_FormattingShowClear(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x1c1, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_FormattingShowParagraph() { + BOOL result; + InvokeHelper(0x1c2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_FormattingShowParagraph(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x1c2, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_FormattingShowNumbering() { + BOOL result; + InvokeHelper(0x1c3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_FormattingShowNumbering(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x1c3, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WDocument::get_FormattingShowFilter() { + long result; + InvokeHelper(0x1c4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WDocument::put_FormattingShowFilter(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x1c4, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +void WDocument::CheckNewSmartTags() { + InvokeHelper(0x17a, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +LPDISPATCH WDocument::get_Permission() { + LPDISPATCH result; + InvokeHelper(0x1c5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_XMLNodes() { + LPDISPATCH result; + InvokeHelper(0x1cc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_XMLSchemaReferences() { + LPDISPATCH result; + InvokeHelper(0x1cd, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_SmartDocument() { + LPDISPATCH result; + InvokeHelper(0x1ce, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_SharedWorkspace() { + LPDISPATCH result; + InvokeHelper(0x1cf, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_Sync() { + LPDISPATCH result; + InvokeHelper(0x1d2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL WDocument::get_EnforceStyle() { + BOOL result; + InvokeHelper(0x1d7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_EnforceStyle(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x1d7, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_AutoFormatOverride() { + BOOL result; + InvokeHelper(0x1d8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_AutoFormatOverride(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x1d8, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_XMLSaveDataOnly() { + BOOL result; + InvokeHelper(0x1d9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_XMLSaveDataOnly(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x1d9, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_XMLHideNamespaces() { + BOOL result; + InvokeHelper(0x1dd, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_XMLHideNamespaces(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x1dd, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_XMLShowAdvancedErrors() { + BOOL result; + InvokeHelper(0x1de, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_XMLShowAdvancedErrors(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x1de, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_XMLUseXSLTWhenSaving() { + BOOL result; + InvokeHelper(0x1da, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_XMLUseXSLTWhenSaving(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x1da, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +CString WDocument::get_XMLSaveThroughXSLT() { + CString result; + InvokeHelper(0x1db, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void WDocument::put_XMLSaveThroughXSLT(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x1db, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WDocument::get_DocumentLibraryVersions() { + LPDISPATCH result; + InvokeHelper(0x1dc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL WDocument::get_ReadingModeLayoutFrozen() { + BOOL result; + InvokeHelper(0x1e1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_ReadingModeLayoutFrozen(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x1e1, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_RemoveDateAndTime() { + BOOL result; + InvokeHelper(0x1e4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_RemoveDateAndTime(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x1e4, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +void WDocument::SendFaxOverInternet(VARIANT * Recipients, VARIANT * Subject, VARIANT * ShowMessage) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x1d0, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Recipients, Subject, ShowMessage); +} +void WDocument::TransformDocument(LPCTSTR Path, BOOL DataOnly) { + static BYTE parms[] = VTS_BSTR VTS_BOOL; + InvokeHelper(0x1f4, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Path, DataOnly); +} +void WDocument::Protect(long Type, VARIANT * NoReset, VARIANT * Password, VARIANT * UseIRM, VARIANT * EnforceStyleLock) { + static BYTE parms[] = VTS_I4 VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x1d3, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Type, NoReset, Password, UseIRM, EnforceStyleLock); +} +void WDocument::SelectAllEditableRanges(VARIANT * EditorID) { + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0x1d4, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, EditorID); +} +void WDocument::DeleteAllEditableRanges(VARIANT * EditorID) { + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0x1d5, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, EditorID); +} +void WDocument::DeleteAllInkAnnotations() { + InvokeHelper(0x1df, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::AddDocumentWorkspaceHeader(BOOL RichFormat, LPCTSTR Url, LPCTSTR Title, LPCTSTR Description, LPCTSTR ID) { + static BYTE parms[] = VTS_BOOL VTS_BSTR VTS_BSTR VTS_BSTR VTS_BSTR; + InvokeHelper(0x1e2, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, RichFormat, Url, Title, Description, ID); +} +void WDocument::RemoveDocumentWorkspaceHeader(LPCTSTR ID) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x1e3, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, ID); +} +void WDocument::Compare(LPCTSTR Name, VARIANT * AuthorName, VARIANT * CompareTarget, VARIANT * DetectFormatChanges, VARIANT * IgnoreAllComparisonWarnings, VARIANT * AddToRecentFiles, VARIANT * RemovePersonalInformation, VARIANT * RemoveDateAndTime) { + static BYTE parms[] = VTS_BSTR VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x1e5, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Name, AuthorName, CompareTarget, DetectFormatChanges, IgnoreAllComparisonWarnings, AddToRecentFiles, RemovePersonalInformation, RemoveDateAndTime); +} +void WDocument::RemoveLockedStyles() { + InvokeHelper(0x1e7, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +LPDISPATCH WDocument::get_ChildNodeSuggestions() { + LPDISPATCH result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::SelectSingleNode(LPCTSTR XPath, LPCTSTR PrefixMapping, BOOL FastSearchSkippingTextNodes) { + LPDISPATCH result; + static BYTE parms[] = VTS_BSTR VTS_BSTR VTS_BOOL; + InvokeHelper(0x1e8, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, XPath, PrefixMapping, FastSearchSkippingTextNodes); + return result; +} +LPDISPATCH WDocument::SelectNodes(LPCTSTR XPath, LPCTSTR PrefixMapping, BOOL FastSearchSkippingTextNodes) { + LPDISPATCH result; + static BYTE parms[] = VTS_BSTR VTS_BSTR VTS_BOOL; + InvokeHelper(0x1e9, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, XPath, PrefixMapping, FastSearchSkippingTextNodes); + return result; +} +LPDISPATCH WDocument::get_XMLSchemaViolations() { + LPDISPATCH result; + InvokeHelper(0x1ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long WDocument::get_ReadingLayoutSizeX() { + long result; + InvokeHelper(0x1eb, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WDocument::put_ReadingLayoutSizeX(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x1eb, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WDocument::get_ReadingLayoutSizeY() { + long result; + InvokeHelper(0x1ec, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WDocument::put_ReadingLayoutSizeY(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x1ec, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WDocument::get_StyleSortMethod() { + long result; + InvokeHelper(0x1ed, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WDocument::put_StyleSortMethod(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x1ed, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WDocument::get_ContentTypeProperties() { + LPDISPATCH result; + InvokeHelper(0x1f0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL WDocument::get_TrackMoves() { + BOOL result; + InvokeHelper(0x1f3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_TrackMoves(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x1f3, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_TrackFormatting() { + BOOL result; + InvokeHelper(0x1f6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_TrackFormatting(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x1f6, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +void WDocument::get_Dummy1() { + InvokeHelper(0x1f7, DISPATCH_PROPERTYGET, VT_EMPTY, nullptr, nullptr); +} +LPDISPATCH WDocument::get_OMaths() { + LPDISPATCH result; + InvokeHelper(0x1f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void WDocument::RemoveDocumentInformation(long RemoveDocInfoType) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x1ef, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, RemoveDocInfoType); +} +void WDocument::CheckInWithVersion(BOOL SaveChanges, VARIANT * Comments, BOOL MakePublic, VARIANT * VersionType) { + static BYTE parms[] = VTS_BOOL VTS_PVARIANT VTS_BOOL VTS_PVARIANT; + InvokeHelper(0x1f5, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, SaveChanges, Comments, MakePublic, VersionType); +} +void WDocument::Dummy2() { + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::get_Dummy3() { + InvokeHelper(0x1fa, DISPATCH_PROPERTYGET, VT_EMPTY, nullptr, nullptr); +} +LPDISPATCH WDocument::get_ServerPolicy() { + LPDISPATCH result; + InvokeHelper(0x1fb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_ContentControls() { + LPDISPATCH result; + InvokeHelper(0x1fc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_DocumentInspectors() { + LPDISPATCH result; + InvokeHelper(0x1fe, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void WDocument::LockServerFile() { + InvokeHelper(0x1fd, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +LPDISPATCH WDocument::GetWorkflowTasks() { + LPDISPATCH result; + InvokeHelper(0x1ff, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::GetWorkflowTemplates() { + LPDISPATCH result; + InvokeHelper(0x200, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void WDocument::Dummy4() { + InvokeHelper(0x202, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::AddMeetingWorkspaceHeader(BOOL SkipIfAbsent, LPCTSTR Url, LPCTSTR Title, LPCTSTR Description, LPCTSTR ID) { + static BYTE parms[] = VTS_BOOL VTS_BSTR VTS_BSTR VTS_BSTR VTS_BSTR; + InvokeHelper(0x203, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, SkipIfAbsent, Url, Title, Description, ID); +} +LPDISPATCH WDocument::get_Bibliography() { + LPDISPATCH result; + InvokeHelper(0x204, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL WDocument::get_LockTheme() { + BOOL result; + InvokeHelper(0x205, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_LockTheme(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x205, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_LockQuickStyleSet() { + BOOL result; + InvokeHelper(0x206, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_LockQuickStyleSet(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x206, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +CString WDocument::get_OriginalDocumentTitle() { + CString result; + InvokeHelper(0x207, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +CString WDocument::get_RevisedDocumentTitle() { + CString result; + InvokeHelper(0x208, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_CustomXMLParts() { + LPDISPATCH result; + InvokeHelper(0x209, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL WDocument::get_FormattingShowNextLevel() { + BOOL result; + InvokeHelper(0x20a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_FormattingShowNextLevel(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x20a, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_FormattingShowUserStyleName() { + BOOL result; + InvokeHelper(0x20b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_FormattingShowUserStyleName(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x20b, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +void WDocument::SaveAsQuickStyleSet(LPCTSTR FileName) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x20c, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, FileName); +} +void WDocument::ApplyQuickStyleSet(LPCTSTR Name) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x20d, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Name); +} +LPDISPATCH WDocument::get_Research() { + LPDISPATCH result; + InvokeHelper(0x20e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +BOOL WDocument::get_Final() { + BOOL result; + InvokeHelper(0x20f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_Final(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x20f, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WDocument::get_OMathBreakBin() { + long result; + InvokeHelper(0x210, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WDocument::put_OMathBreakBin(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x210, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WDocument::get_OMathBreakSub() { + long result; + InvokeHelper(0x211, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WDocument::put_OMathBreakSub(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x211, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WDocument::get_OMathJc() { + long result; + InvokeHelper(0x212, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WDocument::put_OMathJc(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x212, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +float WDocument::get_OMathLeftMargin() { + float result; + InvokeHelper(0x213, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WDocument::put_OMathLeftMargin(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x213, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +float WDocument::get_OMathRightMargin() { + float result; + InvokeHelper(0x214, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WDocument::put_OMathRightMargin(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x214, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +float WDocument::get_OMathWrap() { + float result; + InvokeHelper(0x217, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WDocument::put_OMathWrap(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x217, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_OMathIntSubSupLim() { + BOOL result; + InvokeHelper(0x218, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_OMathIntSubSupLim(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x218, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_OMathNarySupSubLim() { + BOOL result; + InvokeHelper(0x219, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_OMathNarySupSubLim(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x219, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_OMathSmallFrac() { + BOOL result; + InvokeHelper(0x21b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_OMathSmallFrac(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x21b, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +CString WDocument::get_WordOpenXML() { + CString result; + InvokeHelper(0x21e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::get_DocumentTheme() { + LPDISPATCH result; + InvokeHelper(0x221, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void WDocument::ApplyDocumentTheme(LPCTSTR FileName) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x222, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, FileName); +} +BOOL WDocument::get_HasVBProject() { + BOOL result; + InvokeHelper(0x224, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocument::SelectLinkedControls(LPDISPATCH Node) { + LPDISPATCH result; + static BYTE parms[] = VTS_DISPATCH; + InvokeHelper(0x225, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Node); + return result; +} +LPDISPATCH WDocument::SelectUnlinkedControls(LPDISPATCH Stream) { + LPDISPATCH result; + static BYTE parms[] = VTS_DISPATCH; + InvokeHelper(0x226, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Stream); + return result; +} +LPDISPATCH WDocument::SelectContentControlsByTitle(LPCTSTR Title) { + LPDISPATCH result; + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x227, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Title); + return result; +} +void WDocument::ExportAsFixedFormat(LPCTSTR OutputFileName, long ExportFormat, BOOL OpenAfterExport, long OptimizeFor, long Range, long From, long To, long Item, BOOL IncludeDocProps, BOOL KeepIRM, long CreateBookmarks, BOOL DocStructureTags, BOOL BitmapMissingFonts, BOOL UseISO19005_1, VARIANT * FixedFormatExtClassPtr) { + static BYTE parms[] = VTS_BSTR VTS_I4 VTS_BOOL VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_BOOL VTS_BOOL VTS_I4 VTS_BOOL VTS_BOOL VTS_BOOL VTS_PVARIANT; + InvokeHelper(0x228, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, OutputFileName, ExportFormat, OpenAfterExport, OptimizeFor, Range, From, To, Item, IncludeDocProps, KeepIRM, CreateBookmarks, DocStructureTags, BitmapMissingFonts, UseISO19005_1, FixedFormatExtClassPtr); +} +void WDocument::FreezeLayout() { + InvokeHelper(0x229, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WDocument::UnfreezeLayout() { + InvokeHelper(0x22a, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +CString WDocument::get_OMathFontName() { + CString result; + InvokeHelper(0x22b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void WDocument::put_OMathFontName(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x22b, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +void WDocument::DowngradeDocument() { + InvokeHelper(0x22e, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +CString WDocument::get_EncryptionProvider() { + CString result; + InvokeHelper(0x22f, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void WDocument::put_EncryptionProvider(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x22f, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_UseMathDefaults() { + BOOL result; + InvokeHelper(0x230, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_UseMathDefaults(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x230, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WDocument::get_CurrentRsid() { + long result; + InvokeHelper(0x233, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WDocument::Convert() { + InvokeHelper(0x231, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +LPDISPATCH WDocument::SelectContentControlsByTag(LPCTSTR Tag) { + LPDISPATCH result; + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x232, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Tag); + return result; +} +void WDocument::ConvertAutoHyphens() { + InvokeHelper(0x28a, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +long WDocument::get_DocID() { + long result; + InvokeHelper(0x234, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WDocument::ApplyQuickStyleSet2(VARIANT * Style) { + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0x236, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Style); +} +long WDocument::get_CompatibilityMode() { + long result; + InvokeHelper(0x237, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WDocument::SaveAs2(VARIANT * FileName, VARIANT * FileFormat, VARIANT * LockComments, VARIANT * Password, VARIANT * AddToRecentFiles, VARIANT * WritePassword, VARIANT * ReadOnlyRecommended, VARIANT * EmbedTrueTypeFonts, VARIANT * SaveNativePictureFormat, VARIANT * SaveFormsData, VARIANT * SaveAsAOCELetter, VARIANT * Encoding, VARIANT * InsertLineBreaks, VARIANT * AllowSubstitutions, VARIANT * LineEnding, VARIANT * AddBiDiMarks, VARIANT * CompatibilityMode) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x238, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, FileName, FileFormat, LockComments, Password, AddToRecentFiles, WritePassword, ReadOnlyRecommended, EmbedTrueTypeFonts, SaveNativePictureFormat, SaveFormsData, SaveAsAOCELetter, Encoding, InsertLineBreaks, AllowSubstitutions, LineEnding, AddBiDiMarks, CompatibilityMode); +} +LPDISPATCH WDocument::get_CoAuthoring() { + LPDISPATCH result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void WDocument::SetCompatibilityMode(long Mode) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x23b, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Mode); +} +LPDISPATCH WDocument::get_Broadcast() { + LPDISPATCH result; + InvokeHelper(0x262, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long WDocument::ReturnToLastReadPosition() { + long result; + InvokeHelper(0x23c, DISPATCH_METHOD, VT_I4, (void*)&result, nullptr); + return result; +} +BOOL WDocument::get_ChartDataPointTrack() { + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::put_ChartDataPointTrack(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WDocument::get_IsInAutosave() { + BOOL result; + InvokeHelper(0x26b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WDocument::SaveCopyAs(VARIANT * FileName, VARIANT * FileFormat, VARIANT * LockComments, VARIANT * Password, VARIANT * AddToRecentFiles, VARIANT * WritePassword, VARIANT * ReadOnlyRecommended, VARIANT * EmbedTrueTypeFonts, VARIANT * SaveNativePictureFormat, VARIANT * SaveFormsData, VARIANT * SaveAsAOCELetter, VARIANT * Encoding, VARIANT * InsertLineBreaks, VARIANT * AllowSubstitutions, VARIANT * LineEnding, VARIANT * AddBiDiMarks, VARIANT * CompatibilityMode) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x26d, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, FileName, FileFormat, LockComments, Password, AddToRecentFiles, WritePassword, ReadOnlyRecommended, EmbedTrueTypeFonts, SaveNativePictureFormat, SaveFormsData, SaveAsAOCELetter, Encoding, InsertLineBreaks, AllowSubstitutions, LineEnding, AddBiDiMarks, CompatibilityMode); +} +void WDocument::InsertAppForOfficeTest(LPCTSTR ID, long Type, LPCTSTR Version, long StoreType, LPCTSTR StoreId, LPCTSTR AssetId, LPCTSTR AssetStoreId, long Width, long Height) { + static BYTE parms[] = VTS_BSTR VTS_I4 VTS_BSTR VTS_I4 VTS_BSTR VTS_BSTR VTS_BSTR VTS_I4 VTS_I4; + InvokeHelper(0x26e, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, ID, Type, Version, StoreType, StoreId, AssetId, AssetStoreId, Width, Height); +} + +} // namespace MSO::Word + +#pragma warning( pop ) \ No newline at end of file diff --git a/src/word/WDocuments.cpp b/src/word/WDocuments.cpp new file mode 100644 index 0000000..6215e11 --- /dev/null +++ b/src/word/WDocuments.cpp @@ -0,0 +1,113 @@ +#include "stdafx.h" + +#include "office/word/WDocuments.h" + +#include "office/word/WDocument.h" +#include "office/word/WApplication.h" + +#pragma warning( push ) +#pragma warning( disable : 26493 26485 26494 ) + +namespace MSO::Word { + +LPUNKNOWN WDocuments::get_NewEnum() { + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, nullptr); + return result; +} +long WDocuments::get_Count() { + long result; + InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +WApplication WDocuments::get_Application() { + LPDISPATCH result; + InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long WDocuments::get_Creator() { + long result; + InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +LPDISPATCH WDocuments::get_Parent() { + LPDISPATCH result; + InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +WDocument WDocuments::get_Item(VARIANT IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, &IndexType); + return result; +} +void WDocuments::Close(VARIANT * SaveChanges, VARIANT * OriginalFormat, VARIANT * RouteDocument) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x451, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, SaveChanges, OriginalFormat, RouteDocument); +} +WDocument WDocuments::AddOld(VARIANT * Template, VARIANT * NewTemplate) { + LPDISPATCH result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0xb, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Template, NewTemplate); + return result; +} +WDocument WDocuments::OpenOld(VARIANT * FileName, VARIANT * ConfirmConversions, VARIANT * ReadOnly, VARIANT * AddToRecentFiles, VARIANT * PasswordDocument, VARIANT * PasswordTemplate, VARIANT * Revert, VARIANT * WritePasswordDocument, VARIANT * WritePasswordTemplate, VARIANT * Format) { + LPDISPATCH result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0xc, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, FileName, ConfirmConversions, ReadOnly, AddToRecentFiles, PasswordDocument, PasswordTemplate, Revert, WritePasswordDocument, WritePasswordTemplate, Format); + return result; +} +void WDocuments::Save(VARIANT * NoPrompt, VARIANT * OriginalFormat) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, NoPrompt, OriginalFormat); +} +WDocument WDocuments::Add(VARIANT * Template, VARIANT * NewTemplate, VARIANT * DocumentType, VARIANT * Visible) { + LPDISPATCH result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0xe, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Template, NewTemplate, DocumentType, Visible); + return result; +} +WDocument WDocuments::Open2000(VARIANT * FileName, VARIANT * ConfirmConversions, VARIANT * ReadOnly, VARIANT * AddToRecentFiles, VARIANT * PasswordDocument, VARIANT * PasswordTemplate, VARIANT * Revert, VARIANT * WritePasswordDocument, VARIANT * WritePasswordTemplate, VARIANT * Format, VARIANT * Encoding, VARIANT * Visible) { + LPDISPATCH result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0xf, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, FileName, ConfirmConversions, ReadOnly, AddToRecentFiles, PasswordDocument, PasswordTemplate, Revert, WritePasswordDocument, WritePasswordTemplate, Format, Encoding, Visible); + return result; +} +void WDocuments::CheckOut(LPCTSTR FileName) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, FileName); +} +BOOL WDocuments::CanCheckOut(LPCTSTR FileName) { + BOOL result; + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x11, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, FileName); + return result; +} +WDocument WDocuments::Open2002(VARIANT * FileName, VARIANT * ConfirmConversions, VARIANT * ReadOnly, VARIANT * AddToRecentFiles, VARIANT * PasswordDocument, VARIANT * PasswordTemplate, VARIANT * Revert, VARIANT * WritePasswordDocument, VARIANT * WritePasswordTemplate, VARIANT * Format, VARIANT * Encoding, VARIANT * Visible, VARIANT * OpenAndRepair, VARIANT * DocumentDirection, VARIANT * NoEncodingDialog) { + LPDISPATCH result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x12, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, FileName, ConfirmConversions, ReadOnly, AddToRecentFiles, PasswordDocument, PasswordTemplate, Revert, WritePasswordDocument, WritePasswordTemplate, Format, Encoding, Visible, OpenAndRepair, DocumentDirection, NoEncodingDialog); + return result; +} +WDocument WDocuments::Open(VARIANT * FileName, VARIANT * ConfirmConversions, VARIANT * ReadOnly, VARIANT * AddToRecentFiles, VARIANT * PasswordDocument, VARIANT * PasswordTemplate, VARIANT * Revert, VARIANT * WritePasswordDocument, VARIANT * WritePasswordTemplate, VARIANT * Format, VARIANT * Encoding, VARIANT * Visible, VARIANT * OpenAndRepair, VARIANT * DocumentDirection, VARIANT * NoEncodingDialog, VARIANT * XMLTransform) { + LPDISPATCH result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x13, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, FileName, ConfirmConversions, ReadOnly, AddToRecentFiles, PasswordDocument, PasswordTemplate, Revert, WritePasswordDocument, WritePasswordTemplate, Format, Encoding, Visible, OpenAndRepair, DocumentDirection, NoEncodingDialog, XMLTransform); + return result; +} +WDocument WDocuments::OpenNoRepairDialog(VARIANT * FileName, VARIANT * ConfirmConversions, VARIANT * ReadOnly, VARIANT * AddToRecentFiles, VARIANT * PasswordDocument, VARIANT * PasswordTemplate, VARIANT * Revert, VARIANT * WritePasswordDocument, VARIANT * WritePasswordTemplate, VARIANT * Format, VARIANT * Encoding, VARIANT * Visible, VARIANT * OpenAndRepair, VARIANT * DocumentDirection, VARIANT * NoEncodingDialog, VARIANT * XMLTransform) { + LPDISPATCH result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x14, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, FileName, ConfirmConversions, ReadOnly, AddToRecentFiles, PasswordDocument, PasswordTemplate, Revert, WritePasswordDocument, WritePasswordTemplate, Format, Encoding, Visible, OpenAndRepair, DocumentDirection, NoEncodingDialog, XMLTransform); + return result; +} +LPDISPATCH WDocuments::AddBlogDocument(LPCTSTR ProviderID, LPCTSTR PostURL, LPCTSTR BlogName, LPCTSTR PostID) { + LPDISPATCH result; + static BYTE parms[] = VTS_BSTR VTS_BSTR VTS_BSTR VTS_BSTR; + InvokeHelper(0x15, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, ProviderID, PostURL, BlogName, PostID); + return result; +} + +} // namespace MSO::Word + +#pragma warning( pop ) \ No newline at end of file diff --git a/src/word/WRange.cpp b/src/word/WRange.cpp new file mode 100644 index 0000000..f9b5f89 --- /dev/null +++ b/src/word/WRange.cpp @@ -0,0 +1,1241 @@ +#include "stdafx.h" + +#include "office/word/WRange.h" + +#include "office/word/WApplication.h" +#include "office/word/WComments.h" +#include "office/word/WTables.h" + +#pragma warning( push ) +#pragma warning( disable : 26493 26485 26494 ) + +namespace MSO::Word { + +CString WRange::get_Text() { + CString result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +void WRange::put_Text(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH WRange::get_FormattedText() { + LPDISPATCH result; + InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +void WRange::put_FormattedText(LPDISPATCH newValue) { + static BYTE parms[] = VTS_DISPATCH; + InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long WRange::get_Start() { + long result; + InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void WRange::put_Start(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long WRange::get_End() { + long result; + InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void WRange::put_End(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH WRange::get_Font() { + LPDISPATCH result; + InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +void WRange::put_Font(LPDISPATCH newValue) { + static BYTE parms[] = VTS_DISPATCH; + InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH WRange::get_Duplicate() { + LPDISPATCH result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +long WRange::get_StoryType() { + long result; + InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +WTables WRange::get_Tables() { + LPDISPATCH result; + InvokeHelper(0x32, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_Words() { + LPDISPATCH result; + InvokeHelper(0x33, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_Sentences() { + LPDISPATCH result; + InvokeHelper(0x34, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_Characters() { + LPDISPATCH result; + InvokeHelper(0x35, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_Footnotes() { + LPDISPATCH result; + InvokeHelper(0x36, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_Endnotes() { + LPDISPATCH result; + InvokeHelper(0x37, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +WComments WRange::get_Comments() { + LPDISPATCH result; + InvokeHelper(0x38, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_Cells() { + LPDISPATCH result; + InvokeHelper(0x39, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_Sections() { + LPDISPATCH result; + InvokeHelper(0x3a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_Paragraphs() { + LPDISPATCH result; + InvokeHelper(0x3b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_Borders() { + LPDISPATCH result; + InvokeHelper(0x44c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +void WRange::put_Borders(LPDISPATCH newValue) { + static BYTE parms[] = VTS_DISPATCH; + InvokeHelper(0x44c, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH WRange::get_Shading() { + LPDISPATCH result; + InvokeHelper(0x3d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_TextRetrievalMode() { + LPDISPATCH result; + InvokeHelper(0x3e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +void WRange::put_TextRetrievalMode(LPDISPATCH newValue) { + static BYTE parms[] = VTS_DISPATCH; + InvokeHelper(0x3e, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH WRange::get_Fields() { + LPDISPATCH result; + InvokeHelper(0x40, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_FormFields() { + LPDISPATCH result; + InvokeHelper(0x41, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_Frames() { + LPDISPATCH result; + InvokeHelper(0x42, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_ParagraphFormat() { + LPDISPATCH result; + InvokeHelper(0x44e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +void WRange::put_ParagraphFormat(LPDISPATCH newValue) { + static BYTE parms[] = VTS_DISPATCH; + InvokeHelper(0x44e, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH WRange::get_ListFormat() { + LPDISPATCH result; + InvokeHelper(0x44, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_Bookmarks() { + LPDISPATCH result; + InvokeHelper(0x4b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +WApplication WRange::get_Application() { + LPDISPATCH result; + InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +long WRange::get_Creator() { + long result; + InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_Parent() { + LPDISPATCH result; + InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +long WRange::get_Bold() { + long result; + InvokeHelper(0x82, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void WRange::put_Bold(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x82, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long WRange::get_Italic() { + long result; + InvokeHelper(0x83, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void WRange::put_Italic(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x83, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long WRange::get_Underline() { + long result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void WRange::put_Underline(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long WRange::get_EmphasisMark() { + long result; + InvokeHelper(0x8c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void WRange::put_EmphasisMark(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x8c, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL WRange::get_DisableCharacterSpaceGrid() { + BOOL result; + InvokeHelper(0x8d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void WRange::put_DisableCharacterSpaceGrid(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x8d, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH WRange::get_Revisions() { + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +VARIANT WRange::get_Style() { + VARIANT result; + InvokeHelper(0x97, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} + +void WRange::put_Style(VARIANT * newValue) { + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0x97, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long WRange::get_StoryLength() { + long result; + InvokeHelper(0x98, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +long WRange::get_LanguageID() { + long result; + InvokeHelper(0x99, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void WRange::put_LanguageID(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x99, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH WRange::get_SynonymInfo() { + LPDISPATCH result; + InvokeHelper(0x9b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_Hyperlinks() { + LPDISPATCH result; + InvokeHelper(0x9c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_ListParagraphs() { + LPDISPATCH result; + InvokeHelper(0x9d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_Subdocuments() { + LPDISPATCH result; + InvokeHelper(0x9f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +BOOL WRange::get_GrammarChecked() { + BOOL result; + InvokeHelper(0x104, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void WRange::put_GrammarChecked(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x104, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL WRange::get_SpellingChecked() { + BOOL result; + InvokeHelper(0x105, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void WRange::put_SpellingChecked(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x105, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long WRange::get_HighlightColorIndex() { + long result; + InvokeHelper(0x12d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void WRange::put_HighlightColorIndex(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x12d, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH WRange::get_Columns() { + LPDISPATCH result; + InvokeHelper(0x12e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_Rows() { + LPDISPATCH result; + InvokeHelper(0x12f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +long WRange::get_CanEdit() { + long result; + InvokeHelper(0x130, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +long WRange::get_CanPaste() { + long result; + InvokeHelper(0x131, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +BOOL WRange::get_IsEndOfRowMark() { + BOOL result; + InvokeHelper(0x133, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +long WRange::get_BookmarkID() { + long result; + InvokeHelper(0x134, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +long WRange::get_PreviousBookmarkID() { + long result; + InvokeHelper(0x135, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_Find() { + LPDISPATCH result; + InvokeHelper(0x106, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_PageSetup() { + LPDISPATCH result; + InvokeHelper(0x44d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +void WRange::put_PageSetup(LPDISPATCH newValue) { + static BYTE parms[] = VTS_DISPATCH; + InvokeHelper(0x44d, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH WRange::get_ShapeRange() { + LPDISPATCH result; + InvokeHelper(0x137, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +long WRange::get_Case() { + long result; + InvokeHelper(0x138, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void WRange::put_Case(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x138, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +VARIANT WRange::get_Information(long Type) { + VARIANT result; + static BYTE parms[] = VTS_I4; + InvokeHelper(0x139, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, Type); + return result; +} + +LPDISPATCH WRange::get_ReadabilityStatistics() { + LPDISPATCH result; + InvokeHelper(0x13a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_GrammaticalErrors() { + LPDISPATCH result; + InvokeHelper(0x13b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_SpellingErrors() { + LPDISPATCH result; + InvokeHelper(0x13c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +long WRange::get_Orientation() { + long result; + InvokeHelper(0x13d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void WRange::put_Orientation(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x13d, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH WRange::get_InlineShapes() { + LPDISPATCH result; + InvokeHelper(0x13f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_NextStoryRange() { + LPDISPATCH result; + InvokeHelper(0x140, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +long WRange::get_LanguageIDFarEast() { + long result; + InvokeHelper(0x141, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void WRange::put_LanguageIDFarEast(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x141, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long WRange::get_LanguageIDOther() { + long result; + InvokeHelper(0x142, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void WRange::put_LanguageIDOther(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x142, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +void WRange::Select() { + InvokeHelper(0xffff, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +void WRange::SetRange(long Start, long End) { + static BYTE parms[] = VTS_I4 VTS_I4; + InvokeHelper(0x64, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Start, End); +} + +void WRange::Collapse(VARIANT * Direction) { + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Direction); +} + +void WRange::InsertBefore(LPCTSTR Text) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Text); +} + +void WRange::InsertAfter(LPCTSTR Text) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x68, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Text); +} + +LPDISPATCH WRange::Next(VARIANT * Unit, VARIANT * Count) { + LPDISPATCH result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x69, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Unit, Count); + return result; +} + +LPDISPATCH WRange::Previous(VARIANT * Unit, VARIANT * Count) { + LPDISPATCH result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x6a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Unit, Count); + return result; +} + +long WRange::StartOf(VARIANT * Unit, VARIANT * Extend) { + long result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x6b, DISPATCH_METHOD, VT_I4, (void*)&result, parms, Unit, Extend); + return result; +} + +long WRange::EndOf(VARIANT * Unit, VARIANT * Extend) { + long result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x6c, DISPATCH_METHOD, VT_I4, (void*)&result, parms, Unit, Extend); + return result; +} + +long WRange::Move(VARIANT * Unit, VARIANT * Count) { + long result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x6d, DISPATCH_METHOD, VT_I4, (void*)&result, parms, Unit, Count); + return result; +} + +long WRange::MoveStart(VARIANT * Unit, VARIANT * Count) { + long result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x6e, DISPATCH_METHOD, VT_I4, (void*)&result, parms, Unit, Count); + return result; +} + +long WRange::MoveEnd(VARIANT * Unit, VARIANT * Count) { + long result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x6f, DISPATCH_METHOD, VT_I4, (void*)&result, parms, Unit, Count); + return result; +} + +long WRange::MoveWhile(VARIANT * Cset, VARIANT * Count) { + long result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x70, DISPATCH_METHOD, VT_I4, (void*)&result, parms, Cset, Count); + return result; +} + +long WRange::MoveStartWhile(VARIANT * Cset, VARIANT * Count) { + long result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x71, DISPATCH_METHOD, VT_I4, (void*)&result, parms, Cset, Count); + return result; +} + +long WRange::MoveEndWhile(VARIANT * Cset, VARIANT * Count) { + long result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x72, DISPATCH_METHOD, VT_I4, (void*)&result, parms, Cset, Count); + return result; +} + +long WRange::MoveUntil(VARIANT * Cset, VARIANT * Count) { + long result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x73, DISPATCH_METHOD, VT_I4, (void*)&result, parms, Cset, Count); + return result; +} + +long WRange::MoveStartUntil(VARIANT * Cset, VARIANT * Count) { + long result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x74, DISPATCH_METHOD, VT_I4, (void*)&result, parms, Cset, Count); + return result; +} + +long WRange::MoveEndUntil(VARIANT * Cset, VARIANT * Count) { + long result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x75, DISPATCH_METHOD, VT_I4, (void*)&result, parms, Cset, Count); + return result; +} + +void WRange::Cut() { + InvokeHelper(0x77, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +void WRange::Copy() { + InvokeHelper(0x78, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +void WRange::Paste() { + InvokeHelper(0x79, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +void WRange::InsertBreak(VARIANT * Type) { + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0x7a, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Type); +} + +void WRange::InsertFile(LPCTSTR FileName, VARIANT * Range, VARIANT * ConfirmConversions, VARIANT * Link, VARIANT * Attachment) { + static BYTE parms[] = VTS_BSTR VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x7b, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, FileName, Range, ConfirmConversions, Link, Attachment); +} + +BOOL WRange::InStory(LPDISPATCH Range) { + BOOL result; + static BYTE parms[] = VTS_DISPATCH; + InvokeHelper(0x7d, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, Range); + return result; +} + +BOOL WRange::InRange(LPDISPATCH Range) { + BOOL result; + static BYTE parms[] = VTS_DISPATCH; + InvokeHelper(0x7e, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, Range); + return result; +} + +long WRange::Delete(VARIANT * Unit, VARIANT * Count) { + long result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x7f, DISPATCH_METHOD, VT_I4, (void*)&result, parms, Unit, Count); + return result; +} + +void WRange::WholeStory() { + InvokeHelper(0x80, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +long WRange::Expand(VARIANT * Unit) { + long result; + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0x81, DISPATCH_METHOD, VT_I4, (void*)&result, parms, Unit); + return result; +} + +void WRange::InsertParagraph() { + InvokeHelper(0xa0, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +void WRange::InsertParagraphAfter() { + InvokeHelper(0xa1, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +LPDISPATCH WRange::ConvertToTableOld(VARIANT * Separator, VARIANT * NumRows, VARIANT * NumColumns, VARIANT * InitialColumnWidth, VARIANT * Format, VARIANT * ApplyBorders, VARIANT * ApplyShading, VARIANT * ApplyFont, VARIANT * ApplyColor, VARIANT * ApplyHeadingRows, VARIANT * ApplyLastRow, VARIANT * ApplyFirstColumn, VARIANT * ApplyLastColumn, VARIANT * AutoFit) { + LPDISPATCH result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0xa2, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Separator, NumRows, NumColumns, InitialColumnWidth, Format, ApplyBorders, ApplyShading, ApplyFont, ApplyColor, ApplyHeadingRows, ApplyLastRow, ApplyFirstColumn, ApplyLastColumn, AutoFit); + return result; +} + +void WRange::InsertDateTimeOld(VARIANT * DateTimeFormat, VARIANT * InsertAsField, VARIANT * InsertAsFullWidth) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0xa3, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, DateTimeFormat, InsertAsField, InsertAsFullWidth); +} + +void WRange::InsertSymbol(long CharacterNumber, VARIANT * Font, VARIANT * Unicode, VARIANT * Bias) { + static BYTE parms[] = VTS_I4 VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0xa4, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, CharacterNumber, Font, Unicode, Bias); +} + +void WRange::InsertCrossReference_2002(VARIANT * ReferenceType, long ReferenceKind, VARIANT * ReferenceItem, VARIANT * InsertAsHyperlink, VARIANT * IncludePosition) { + static BYTE parms[] = VTS_PVARIANT VTS_I4 VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0xa5, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, ReferenceType, ReferenceKind, ReferenceItem, InsertAsHyperlink, IncludePosition); +} + +void WRange::InsertCaptionXP(VARIANT * Label, VARIANT * Title, VARIANT * TitleAutoText, VARIANT * Position) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0xa6, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Label, Title, TitleAutoText, Position); +} + +void WRange::CopyAsPicture() { + InvokeHelper(0xa7, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +void WRange::SortOld(VARIANT * ExcludeHeader, VARIANT * FieldNumber, VARIANT * SortFieldType, VARIANT * SortOrder, VARIANT * FieldNumber2, VARIANT * SortFieldType2, VARIANT * SortOrder2, VARIANT * FieldNumber3, VARIANT * SortFieldType3, VARIANT * SortOrder3, VARIANT * SortColumn, VARIANT * Separator, VARIANT * CaseSensitive, VARIANT * LanguageID) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0xa8, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, ExcludeHeader, FieldNumber, SortFieldType, SortOrder, FieldNumber2, SortFieldType2, SortOrder2, FieldNumber3, SortFieldType3, SortOrder3, SortColumn, Separator, CaseSensitive, LanguageID); +} + +void WRange::SortAscending() { + InvokeHelper(0xa9, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +void WRange::SortDescending() { + InvokeHelper(0xaa, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +BOOL WRange::IsEqual(LPDISPATCH Range) { + BOOL result; + static BYTE parms[] = VTS_DISPATCH; + InvokeHelper(0xab, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, Range); + return result; +} + +float WRange::Calculate() { + float result; + InvokeHelper(0xac, DISPATCH_METHOD, VT_R4, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::GoTo(VARIANT * What, VARIANT * Which, VARIANT * Count, VARIANT * Name) { + LPDISPATCH result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0xad, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, What, Which, Count, Name); + return result; +} + +LPDISPATCH WRange::GoToNext(long What) { + LPDISPATCH result; + static BYTE parms[] = VTS_I4; + InvokeHelper(0xae, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, What); + return result; +} + +LPDISPATCH WRange::GoToPrevious(long What) { + LPDISPATCH result; + static BYTE parms[] = VTS_I4; + InvokeHelper(0xaf, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, What); + return result; +} + +void WRange::PasteSpecial(VARIANT * IconIndex, VARIANT * Link, VARIANT * Placement, VARIANT * DisplayAsIcon, VARIANT * DataType, VARIANT * IconFileName, VARIANT * IconLabel) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0xb0, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, IconIndex, Link, Placement, DisplayAsIcon, DataType, IconFileName, IconLabel); +} + +void WRange::LookupNameProperties() { + InvokeHelper(0xb1, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +long WRange::ComputeStatistics(long Statistic) { + long result; + static BYTE parms[] = VTS_I4; + InvokeHelper(0xb2, DISPATCH_METHOD, VT_I4, (void*)&result, parms, Statistic); + return result; +} + +void WRange::Relocate(long Direction) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0xb3, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Direction); +} + +void WRange::CheckSynonyms() { + InvokeHelper(0xb4, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +void WRange::SubscribeTo(LPCTSTR Edition, VARIANT * Format) { + static BYTE parms[] = VTS_BSTR VTS_PVARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Edition, Format); +} + +void WRange::CreatePublisher(VARIANT * Edition, VARIANT * ContainsPICT, VARIANT * ContainsRTF, VARIANT * ContainsText) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0xb6, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Edition, ContainsPICT, ContainsRTF, ContainsText); +} + +void WRange::InsertAutoText() { + InvokeHelper(0xb7, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +void WRange::InsertDatabase(VARIANT * Format, VARIANT * Style, VARIANT * LinkToSource, VARIANT * Connection, VARIANT * SQLStatement, VARIANT * SQLStatement1, VARIANT * PasswordDocument, VARIANT * PasswordTemplate, VARIANT * WritePasswordDocument, VARIANT * WritePasswordTemplate, VARIANT * DataSource, VARIANT * From, VARIANT * To, VARIANT * IncludeFields) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0xc2, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Format, Style, LinkToSource, Connection, SQLStatement, SQLStatement1, PasswordDocument, PasswordTemplate, WritePasswordDocument, WritePasswordTemplate, DataSource, From, To, IncludeFields); +} + +void WRange::AutoFormat() { + InvokeHelper(0xc3, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +void WRange::CheckGrammar() { + InvokeHelper(0xcc, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +void WRange::CheckSpelling(VARIANT * CustomDictionary, VARIANT * IgnoreUppercase, VARIANT * AlwaysSuggest, VARIANT * CustomDictionary2, VARIANT * CustomDictionary3, VARIANT * CustomDictionary4, VARIANT * CustomDictionary5, VARIANT * CustomDictionary6, VARIANT * CustomDictionary7, VARIANT * CustomDictionary8, VARIANT * CustomDictionary9, VARIANT * CustomDictionary10) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0xcd, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, CustomDictionary, IgnoreUppercase, AlwaysSuggest, CustomDictionary2, CustomDictionary3, CustomDictionary4, CustomDictionary5, CustomDictionary6, CustomDictionary7, CustomDictionary8, CustomDictionary9, CustomDictionary10); +} + +LPDISPATCH WRange::GetSpellingSuggestions(VARIANT * CustomDictionary, VARIANT * IgnoreUppercase, VARIANT * MainDictionary, VARIANT * SuggestionMode, VARIANT * CustomDictionary2, VARIANT * CustomDictionary3, VARIANT * CustomDictionary4, VARIANT * CustomDictionary5, VARIANT * CustomDictionary6, VARIANT * CustomDictionary7, VARIANT * CustomDictionary8, VARIANT * CustomDictionary9, VARIANT * CustomDictionary10) { + LPDISPATCH result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0xd1, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, CustomDictionary, IgnoreUppercase, MainDictionary, SuggestionMode, CustomDictionary2, CustomDictionary3, CustomDictionary4, CustomDictionary5, CustomDictionary6, CustomDictionary7, CustomDictionary8, CustomDictionary9, CustomDictionary10); + return result; +} + +void WRange::InsertParagraphBefore() { + InvokeHelper(0xd4, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +void WRange::NextSubdocument() { + InvokeHelper(0xdb, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +void WRange::PreviousSubdocument() { + InvokeHelper(0xdc, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +void WRange::ConvertHangulAndHanja(VARIANT * ConversionsMode, VARIANT * FastConversion, VARIANT * CheckHangulEnding, VARIANT * EnableRecentOrdering, VARIANT * CustomDictionary) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0xdd, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, ConversionsMode, FastConversion, CheckHangulEnding, EnableRecentOrdering, CustomDictionary); +} + +void WRange::PasteAsNestedTable() { + InvokeHelper(0xde, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +void WRange::ModifyEnclosure(VARIANT * Style, VARIANT * Symbol, VARIANT * EnclosedText) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0xdf, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Style, Symbol, EnclosedText); +} + +void WRange::PhoneticGuide(LPCTSTR Text, long Alignment, long Raise, long FontSize, LPCTSTR FontName) { + static BYTE parms[] = VTS_BSTR VTS_I4 VTS_I4 VTS_I4 VTS_BSTR; + InvokeHelper(0xe0, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Text, Alignment, Raise, FontSize, FontName); +} + +void WRange::InsertDateTime(VARIANT * DateTimeFormat, VARIANT * InsertAsField, VARIANT * InsertAsFullWidth, VARIANT * DateLanguage, VARIANT * CalendarType) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x1bc, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, DateTimeFormat, InsertAsField, InsertAsFullWidth, DateLanguage, CalendarType); +} + +void WRange::Sort(VARIANT * ExcludeHeader, VARIANT * FieldNumber, VARIANT * SortFieldType, VARIANT * SortOrder, VARIANT * FieldNumber2, VARIANT * SortFieldType2, VARIANT * SortOrder2, VARIANT * FieldNumber3, VARIANT * SortFieldType3, VARIANT * SortOrder3, VARIANT * SortColumn, VARIANT * Separator, VARIANT * CaseSensitive, VARIANT * BidiSort, VARIANT * IgnoreThe, VARIANT * IgnoreKashida, VARIANT * IgnoreDiacritics, VARIANT * IgnoreHe, VARIANT * LanguageID) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x1e4, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, ExcludeHeader, FieldNumber, SortFieldType, SortOrder, FieldNumber2, SortFieldType2, SortOrder2, FieldNumber3, SortFieldType3, SortOrder3, SortColumn, Separator, CaseSensitive, BidiSort, IgnoreThe, IgnoreKashida, IgnoreDiacritics, IgnoreHe, LanguageID); +} + +void WRange::DetectLanguage() { + InvokeHelper(0xcb, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +LPDISPATCH WRange::ConvertToTable(VARIANT * Separator, VARIANT * NumRows, VARIANT * NumColumns, VARIANT * InitialColumnWidth, VARIANT * Format, VARIANT * ApplyBorders, VARIANT * ApplyShading, VARIANT * ApplyFont, VARIANT * ApplyColor, VARIANT * ApplyHeadingRows, VARIANT * ApplyLastRow, VARIANT * ApplyFirstColumn, VARIANT * ApplyLastColumn, VARIANT * AutoFit, VARIANT * AutoFitBehavior, VARIANT * DefaultTableBehavior) { + LPDISPATCH result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x1f2, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Separator, NumRows, NumColumns, InitialColumnWidth, Format, ApplyBorders, ApplyShading, ApplyFont, ApplyColor, ApplyHeadingRows, ApplyLastRow, ApplyFirstColumn, ApplyLastColumn, AutoFit, AutoFitBehavior, DefaultTableBehavior); + return result; +} + +void WRange::TCSCConverter(long WdTCSCConverterDirection, BOOL CommonTerms, BOOL UseVariants) { + static BYTE parms[] = VTS_I4 VTS_BOOL VTS_BOOL; + InvokeHelper(0x1f3, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, WdTCSCConverterDirection, CommonTerms, UseVariants); +} + +BOOL WRange::get_LanguageDetected() { + BOOL result; + InvokeHelper(0x107, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void WRange::put_LanguageDetected(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x107, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +float WRange::get_FitTextWidth() { + float result; + InvokeHelper(0x108, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} + +void WRange::put_FitTextWidth(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x108, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long WRange::get_HorizontalInVertical() { + long result; + InvokeHelper(0x109, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void WRange::put_HorizontalInVertical(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x109, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long WRange::get_TwoLinesInOne() { + long result; + InvokeHelper(0x10a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void WRange::put_TwoLinesInOne(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x10a, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL WRange::get_CombineCharacters() { + BOOL result; + InvokeHelper(0x10b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void WRange::put_CombineCharacters(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x10b, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long WRange::get_NoProofing() { + long result; + InvokeHelper(0x143, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void WRange::put_NoProofing(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x143, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH WRange::get_TopLevelTables() { + LPDISPATCH result; + InvokeHelper(0x144, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_Scripts() { + LPDISPATCH result; + InvokeHelper(0x145, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +long WRange::get_CharacterWidth() { + long result; + InvokeHelper(0x146, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void WRange::put_CharacterWidth(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x146, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long WRange::get_Kana() { + long result; + InvokeHelper(0x147, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void WRange::put_Kana(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x147, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long WRange::get_BoldBi() { + long result; + InvokeHelper(0x190, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void WRange::put_BoldBi(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x190, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long WRange::get_ItalicBi() { + long result; + InvokeHelper(0x191, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void WRange::put_ItalicBi(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x191, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +CString WRange::get_ID() { + CString result; + InvokeHelper(0x195, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +void WRange::put_ID(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x195, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH WRange::get_HTMLDivisions() { + LPDISPATCH result; + InvokeHelper(0x196, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_SmartTags() { + LPDISPATCH result; + InvokeHelper(0x197, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +BOOL WRange::get_ShowAll() { + BOOL result; + InvokeHelper(0x198, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void WRange::put_ShowAll(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x198, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH WRange::get_Document() { + LPDISPATCH result; + InvokeHelper(0x199, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_FootnoteOptions() { + LPDISPATCH result; + InvokeHelper(0x19a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_EndnoteOptions() { + LPDISPATCH result; + InvokeHelper(0x19b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +void WRange::PasteAndFormat(long Type) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x19c, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Type); +} + +void WRange::PasteExcelTable(BOOL LinkedToExcel, BOOL WordFormatting, BOOL RTF) { + static BYTE parms[] = VTS_BOOL VTS_BOOL VTS_BOOL; + InvokeHelper(0x19d, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, LinkedToExcel, WordFormatting, RTF); +} + +void WRange::PasteAppendTable() { + InvokeHelper(0x19e, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +LPDISPATCH WRange::get_XMLNodes() { + LPDISPATCH result; + InvokeHelper(0x154, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_XMLParentNode() { + LPDISPATCH result; + InvokeHelper(0x155, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_Editors() { + LPDISPATCH result; + InvokeHelper(0x157, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +CString WRange::get_XML(BOOL DataOnly) { + CString result; + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x158, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms, DataOnly); + return result; +} + +VARIANT WRange::get_EnhMetaFileBits() { + VARIANT result; + InvokeHelper(0x159, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::GoToEditableRange(VARIANT * EditorID) { + LPDISPATCH result; + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0x19f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, EditorID); + return result; +} + +void WRange::InsertXML(LPCTSTR XML, VARIANT * Transform) { + static BYTE parms[] = VTS_BSTR VTS_PVARIANT; + InvokeHelper(0x1a0, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, XML, Transform); +} + +void WRange::InsertCaption(VARIANT * Label, VARIANT * Title, VARIANT * TitleAutoText, VARIANT * Position, VARIANT * ExcludeLabel) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x1a1, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Label, Title, TitleAutoText, Position, ExcludeLabel); +} + +void WRange::InsertCrossReference(VARIANT * ReferenceType, long ReferenceKind, VARIANT * ReferenceItem, VARIANT * InsertAsHyperlink, VARIANT * IncludePosition, VARIANT * SeparateNumbers, VARIANT * SeparatorString) { + static BYTE parms[] = VTS_PVARIANT VTS_I4 VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x1a2, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, ReferenceType, ReferenceKind, ReferenceItem, InsertAsHyperlink, IncludePosition, SeparateNumbers, SeparatorString); +} + +LPDISPATCH WRange::get_OMaths() { + LPDISPATCH result; + InvokeHelper(0x15a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +VARIANT WRange::get_CharacterStyle() { + VARIANT result; + InvokeHelper(0x1a4, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} + +VARIANT WRange::get_ParagraphStyle() { + VARIANT result; + InvokeHelper(0x1a5, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} + +VARIANT WRange::get_ListStyle() { + VARIANT result; + InvokeHelper(0x1a6, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} + +VARIANT WRange::get_TableStyle() { + VARIANT result; + InvokeHelper(0x1a7, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_ContentControls() { + LPDISPATCH result; + InvokeHelper(0x1a8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +void WRange::ExportFragment(LPCTSTR FileName, long Format) { + static BYTE parms[] = VTS_BSTR VTS_I4; + InvokeHelper(0x1a9, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, FileName, Format); +} + +CString WRange::get_WordOpenXML() { + CString result; + InvokeHelper(0x1aa, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +void WRange::SetListLevel(short Level) { + static BYTE parms[] = VTS_I2; + InvokeHelper(0x1ab, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Level); +} + +void WRange::InsertAlignmentTab(long Alignment, long RelativeTo) { + static BYTE parms[] = VTS_I4 VTS_I4; + InvokeHelper(0x1f4, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Alignment, RelativeTo); +} + +LPDISPATCH WRange::get_ParentContentControl() { + LPDISPATCH result; + InvokeHelper(0x1f5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +void WRange::ImportFragment(LPCTSTR FileName, BOOL MatchDestination) { + static BYTE parms[] = VTS_BSTR VTS_BOOL; + InvokeHelper(0x1f6, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, FileName, MatchDestination); +} + +void WRange::ExportAsFixedFormat(LPCTSTR OutputFileName, long ExportFormat, BOOL OpenAfterExport, long OptimizeFor, BOOL ExportCurrentPage, long Item, BOOL IncludeDocProps, BOOL KeepIRM, long CreateBookmarks, BOOL DocStructureTags, BOOL BitmapMissingFonts, BOOL UseISO19005_1, VARIANT * FixedFormatExtClassPtr) { + static BYTE parms[] = VTS_BSTR VTS_I4 VTS_BOOL VTS_I4 VTS_BOOL VTS_I4 VTS_BOOL VTS_BOOL VTS_I4 VTS_BOOL VTS_BOOL VTS_BOOL VTS_PVARIANT; + InvokeHelper(0x1f7, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, OutputFileName, ExportFormat, OpenAfterExport, OptimizeFor, ExportCurrentPage, Item, IncludeDocProps, KeepIRM, CreateBookmarks, DocStructureTags, BitmapMissingFonts, UseISO19005_1, FixedFormatExtClassPtr); +} + +LPDISPATCH WRange::get_Locks() { + LPDISPATCH result; + InvokeHelper(0x1f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_Updates() { + LPDISPATCH result; + InvokeHelper(0x1f9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WRange::get_Conflicts() { + LPDISPATCH result; + InvokeHelper(0x1fa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +long WRange::get_TextVisibleOnScreen() { + long result; + InvokeHelper(0x1fb, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void WRange::SortByHeadings(VARIANT * SortFieldType, VARIANT * SortOrder, VARIANT * CaseSensitive, VARIANT * BidiSort, VARIANT * IgnoreThe, VARIANT * IgnoreKashida, VARIANT * IgnoreDiacritics, VARIANT * IgnoreHe, VARIANT * LanguageID) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x1fc, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, SortFieldType, SortOrder, CaseSensitive, BidiSort, IgnoreThe, IgnoreKashida, IgnoreDiacritics, IgnoreHe, LanguageID); +} + +} // namespace MSO::Word + +#pragma warning( pop ) \ No newline at end of file diff --git a/src/word/WRow.cpp b/src/word/WRow.cpp new file mode 100644 index 0000000..f6f46a9 --- /dev/null +++ b/src/word/WRow.cpp @@ -0,0 +1,182 @@ +#include "stdafx.h" + +#include "office/word/WRow.h" + +#include "office/word/WApplication.h" + +#pragma warning( push ) +#pragma warning( disable : 26493 26485 26494 ) + +namespace MSO::Word { + +LPDISPATCH WRow::get_Range() { + LPDISPATCH result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WRow::get_Application() { + LPDISPATCH result; + InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long WRow::get_Creator() { + long result; + InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +LPDISPATCH WRow::get_Parent() { + LPDISPATCH result; + InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long WRow::get_AllowBreakAcrossPages() { + long result; + InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WRow::put_AllowBreakAcrossPages(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WRow::get_Alignment() { + long result; + InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WRow::put_Alignment(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WRow::get_HeadingFormat() { + long result; + InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WRow::put_HeadingFormat(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +float WRow::get_SpaceBetweenColumns() { + float result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WRow::put_SpaceBetweenColumns(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +float WRow::get_Height() { + float result; + InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WRow::put_Height(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WRow::get_HeightRule() { + long result; + InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WRow::put_HeightRule(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +float WRow::get_LeftIndent() { + float result; + InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WRow::put_LeftIndent(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WRow::get_IsLast() { + BOOL result; + InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +BOOL WRow::get_IsFirst() { + BOOL result; + InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +long WRow::get_Index() { + long result; + InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +LPDISPATCH WRow::get_Cells() { + LPDISPATCH result; + InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WRow::get_Borders() { + LPDISPATCH result; + InvokeHelper(0x44c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void WRow::put_Borders(LPDISPATCH newValue) { + static BYTE parms[] = VTS_DISPATCH; + InvokeHelper(0x44c, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WRow::get_Shading() { + LPDISPATCH result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WRow::get_Next() { + LPDISPATCH result; + InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WRow::get_Previous() { + LPDISPATCH result; + InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void WRow::Select() { + InvokeHelper(0xffff, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WRow::Delete() { + InvokeHelper(0xc8, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WRow::SetLeftIndent(float LeftIndent, long RulerStyle) { + static BYTE parms[] = VTS_R4 VTS_I4; + InvokeHelper(0xca, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, LeftIndent, RulerStyle); +} +void WRow::SetHeight(float RowHeight, long HeightRule) { + static BYTE parms[] = VTS_R4 VTS_I4; + InvokeHelper(0xcb, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, RowHeight, HeightRule); +} +LPDISPATCH WRow::ConvertToTextOld(VARIANT * Separator) { + LPDISPATCH result; + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0x10, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Separator); + return result; +} +LPDISPATCH WRow::ConvertToText(VARIANT * Separator, VARIANT * NestedTables) { + LPDISPATCH result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x12, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Separator, NestedTables); + return result; +} +long WRow::get_NestingLevel() { + long result; + InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +CString WRow::get_ID() { + CString result; + InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} +void WRow::put_ID(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x6b, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +} // namespace MSO::Word + +#pragma warning( pop ) \ No newline at end of file diff --git a/src/word/WRows.cpp b/src/word/WRows.cpp new file mode 100644 index 0000000..48d878d --- /dev/null +++ b/src/word/WRows.cpp @@ -0,0 +1,272 @@ +#include "stdafx.h" + +#include "office/word/WRows.h" + +#include "office/word/WApplication.h" + +#pragma warning( push ) +#pragma warning( disable : 26493 26485 26494 ) + +namespace MSO::Word { + +LPUNKNOWN WRows::get_NewEnum() { + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, nullptr); + return result; +} +long WRows::get_Count() { + long result; + InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +long WRows::get_AllowBreakAcrossPages() { + long result; + InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WRows::put_AllowBreakAcrossPages(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WRows::get_Alignment() { + long result; + InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WRows::put_Alignment(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WRows::get_HeadingFormat() { + long result; + InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WRows::put_HeadingFormat(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +float WRows::get_SpaceBetweenColumns() { + float result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WRows::put_SpaceBetweenColumns(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +float WRows::get_Height() { + float result; + InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WRows::put_Height(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WRows::get_HeightRule() { + long result; + InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WRows::put_HeightRule(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +float WRows::get_LeftIndent() { + float result; + InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WRows::put_LeftIndent(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WRows::get_First() { + LPDISPATCH result; + InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WRows::get_Last() { + LPDISPATCH result; + InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WRows::get_Application() { + LPDISPATCH result; + InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +long WRows::get_Creator() { + long result; + InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +LPDISPATCH WRows::get_Parent() { + LPDISPATCH result; + InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WRows::get_Borders() { + LPDISPATCH result; + InvokeHelper(0x44c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +void WRows::put_Borders(LPDISPATCH newValue) { + static BYTE parms[] = VTS_DISPATCH; + InvokeHelper(0x44c, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +LPDISPATCH WRows::get_Shading() { + LPDISPATCH result; + InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} +LPDISPATCH WRows::get_Item(long IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_I4; + InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, IndexType); + return result; +} +LPDISPATCH WRows::Add(VARIANT * BeforeRow) { + LPDISPATCH result; + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0x64, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, BeforeRow); + return result; +} +void WRows::Select() { + InvokeHelper(0xc7, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WRows::Delete() { + InvokeHelper(0xc8, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +void WRows::SetLeftIndent(float LeftIndent, long RulerStyle) { + static BYTE parms[] = VTS_R4 VTS_I4; + InvokeHelper(0xca, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, LeftIndent, RulerStyle); +} +void WRows::SetHeight(float RowHeight, long HeightRule) { + static BYTE parms[] = VTS_R4 VTS_I4; + InvokeHelper(0xcb, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, RowHeight, HeightRule); +} +LPDISPATCH WRows::ConvertToTextOld(VARIANT * Separator) { + LPDISPATCH result; + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0x10, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Separator); + return result; +} +void WRows::DistributeHeight() { + InvokeHelper(0xce, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} +LPDISPATCH WRows::ConvertToText(VARIANT * Separator, VARIANT * NestedTables) { + LPDISPATCH result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0xd2, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Separator, NestedTables); + return result; +} +long WRows::get_WrapAroundText() { + long result; + InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WRows::put_WrapAroundText(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +float WRows::get_DistanceTop() { + float result; + InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WRows::put_DistanceTop(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0xd, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +float WRows::get_DistanceBottom() { + float result; + InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WRows::put_DistanceBottom(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0xe, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +float WRows::get_DistanceLeft() { + float result; + InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WRows::put_DistanceLeft(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x14, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +float WRows::get_DistanceRight() { + float result; + InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WRows::put_DistanceRight(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x15, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +float WRows::get_HorizontalPosition() { + float result; + InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WRows::put_HorizontalPosition(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0xf, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +float WRows::get_VerticalPosition() { + float result; + InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} +void WRows::put_VerticalPosition(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x11, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WRows::get_RelativeHorizontalPosition() { + long result; + InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WRows::put_RelativeHorizontalPosition(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x12, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WRows::get_RelativeVerticalPosition() { + long result; + InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WRows::put_RelativeVerticalPosition(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x13, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WRows::get_AllowOverlap() { + long result; + InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WRows::put_AllowOverlap(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x16, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +long WRows::get_NestingLevel() { + long result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +long WRows::get_TableDirection() { + long result; + InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} +void WRows::put_TableDirection(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +} // namespace MSO::Word + +#pragma warning( pop ) \ No newline at end of file diff --git a/src/word/WTable.cpp b/src/word/WTable.cpp new file mode 100644 index 0000000..689cb31 --- /dev/null +++ b/src/word/WTable.cpp @@ -0,0 +1,392 @@ +#include "stdafx.h" + +#include "office/word/WTable.h" + +#include "office/word/WApplication.h" +#include "office/word/WTables.h" +#include "office/word/WRange.h" +#include "office/word/WRows.h" +#include "office/word/WColumns.h" +#include "office/word/WCell.h" + +#pragma warning( push ) +#pragma warning( disable : 26493 26485 26494 ) + +namespace MSO::Word { + +WRange WTable::get_Range() { + LPDISPATCH result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +WApplication WTable::get_Application() { + LPDISPATCH result; + InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +long WTable::get_Creator() { + long result; + InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WTable::get_Parent() { + LPDISPATCH result; + InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +WColumns WTable::get_Columns() { + LPDISPATCH result; + InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +WRows WTable::get_Rows() { + LPDISPATCH result; + InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WTable::get_Borders() { + LPDISPATCH result; + InvokeHelper(0x44c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +void WTable::put_Borders(LPDISPATCH newValue) { + static BYTE parms[] = VTS_DISPATCH; + InvokeHelper(0x44c, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +LPDISPATCH WTable::get_Shading() { + LPDISPATCH result; + InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +BOOL WTable::get_Uniform() { + BOOL result; + InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +long WTable::get_AutoFormatType() { + long result; + InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void WTable::Select() { + InvokeHelper(0xc8, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +void WTable::Delete() { + InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +void WTable::SortOld(VARIANT * ExcludeHeader, VARIANT * FieldNumber, VARIANT * SortFieldType, VARIANT * SortOrder, VARIANT * FieldNumber2, VARIANT * SortFieldType2, VARIANT * SortOrder2, VARIANT * FieldNumber3, VARIANT * SortFieldType3, VARIANT * SortOrder3, VARIANT * CaseSensitive, VARIANT * LanguageID) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, ExcludeHeader, FieldNumber, SortFieldType, SortOrder, FieldNumber2, SortFieldType2, SortOrder2, FieldNumber3, SortFieldType3, SortOrder3, CaseSensitive, LanguageID); +} + +void WTable::SortAscending() { + InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +void WTable::SortDescending() { + InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +void WTable::AutoFormat(VARIANT * Format, VARIANT * ApplyBorders, VARIANT * ApplyShading, VARIANT * ApplyFont, + VARIANT * ApplyColor, VARIANT * ApplyHeadingRows, VARIANT * ApplyLastRow, + VARIANT * ApplyFirstColumn, VARIANT * ApplyLastColumn, VARIANT * AutoFit) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Format, ApplyBorders, ApplyShading, ApplyFont, ApplyColor, ApplyHeadingRows, ApplyLastRow, ApplyFirstColumn, ApplyLastColumn, AutoFit); +} + +void WTable::UpdateAutoFormat() { + InvokeHelper(0xf, DISPATCH_METHOD, VT_EMPTY, nullptr, nullptr); +} + +LPDISPATCH WTable::ConvertToTextOld(VARIANT * Separator) { + LPDISPATCH result; + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0x10, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Separator); + return result; +} + +WCell WTable::Cell(long Row, long Column) { + LPDISPATCH result; + static BYTE parms[] = VTS_I4 VTS_I4; + InvokeHelper(0x11, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Row, Column); + return result; +} + +LPDISPATCH WTable::Split(VARIANT * BeforeRow) { + LPDISPATCH result; + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0x12, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, BeforeRow); + return result; +} + +LPDISPATCH WTable::ConvertToText(VARIANT * Separator, VARIANT * NestedTables) { + LPDISPATCH result; + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x13, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Separator, NestedTables); + return result; +} + +void WTable::AutoFitBehavior(long Behavior) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x14, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, Behavior); +} + +void WTable::Sort(VARIANT * ExcludeHeader, VARIANT * FieldNumber, VARIANT * SortFieldType, VARIANT * SortOrder, + VARIANT * FieldNumber2, VARIANT * SortFieldType2, VARIANT * SortOrder2, VARIANT * FieldNumber3, + VARIANT * SortFieldType3, VARIANT * SortOrder3, VARIANT * CaseSensitive, VARIANT * BidiSort, VARIANT * IgnoreThe, + VARIANT * IgnoreKashida, VARIANT * IgnoreDiacritics, VARIANT * IgnoreHe, VARIANT * LanguageID) { + static BYTE parms[] = VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0x17, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, ExcludeHeader, FieldNumber, SortFieldType, SortOrder, FieldNumber2, SortFieldType2, SortOrder2, FieldNumber3, SortFieldType3, SortOrder3, CaseSensitive, BidiSort, IgnoreThe, IgnoreKashida, IgnoreDiacritics, IgnoreHe, LanguageID); +} + +WTables WTable::get_Tables() { + LPDISPATCH result; + InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +long WTable::get_NestingLevel() { + long result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +BOOL WTable::get_AllowPageBreaks() { + BOOL result; + InvokeHelper(0x6d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void WTable::put_AllowPageBreaks(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x6d, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} +BOOL WTable::get_AllowAutoFit() { + BOOL result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} +void WTable::put_AllowAutoFit(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +float WTable::get_PreferredWidth() { + float result; + InvokeHelper(0x6f, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} + +void WTable::put_PreferredWidth(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x6f, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long WTable::get_PreferredWidthType() { + long result; + InvokeHelper(0x70, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void WTable::put_PreferredWidthType(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x70, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +float WTable::get_TopPadding() { + float result; + InvokeHelper(0x71, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} + +void WTable::put_TopPadding(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x71, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +float WTable::get_BottomPadding() { + float result; + InvokeHelper(0x72, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} + +void WTable::put_BottomPadding(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x72, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +float WTable::get_LeftPadding() { + float result; + InvokeHelper(0x73, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} + +void WTable::put_LeftPadding(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x73, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +float WTable::get_RightPadding() { + float result; + InvokeHelper(0x74, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} + +void WTable::put_RightPadding(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x74, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +float WTable::get_Spacing() { + float result; + InvokeHelper(0x75, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, nullptr); + return result; +} + +void WTable::put_Spacing(float newValue) { + static BYTE parms[] = VTS_R4; + InvokeHelper(0x75, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +long WTable::get_TableDirection() { + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +void WTable::put_TableDirection(long newValue) { + static BYTE parms[] = VTS_I4; + InvokeHelper(0x76, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +CString WTable::get_ID() { + CString result; + InvokeHelper(0x77, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +void WTable::put_ID(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0x77, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +VARIANT WTable::get_Style() { + VARIANT result; + InvokeHelper(0xc9, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, nullptr); + return result; +} + +void WTable::put_Style(VARIANT * newValue) { + static BYTE parms[] = VTS_PVARIANT; + InvokeHelper(0xc9, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL WTable::get_ApplyStyleHeadingRows() { + BOOL result; + InvokeHelper(0xca, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void WTable::put_ApplyStyleHeadingRows(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0xca, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL WTable::get_ApplyStyleLastRow() { + BOOL result; + InvokeHelper(0xcb, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void WTable::put_ApplyStyleLastRow(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0xcb, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL WTable::get_ApplyStyleFirstColumn() { + BOOL result; + InvokeHelper(0xcc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void WTable::put_ApplyStyleFirstColumn(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0xcc, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL WTable::get_ApplyStyleLastColumn() { + BOOL result; + InvokeHelper(0xcd, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void WTable::put_ApplyStyleLastColumn(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0xcd, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL WTable::get_ApplyStyleRowBands() { + BOOL result; + InvokeHelper(0xce, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void WTable::put_ApplyStyleRowBands(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0xce, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +BOOL WTable::get_ApplyStyleColumnBands() { + BOOL result; + InvokeHelper(0xcf, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, nullptr); + return result; +} + +void WTable::put_ApplyStyleColumnBands(BOOL newValue) { + static BYTE parms[] = VTS_BOOL; + InvokeHelper(0xcf, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +void WTable::ApplyStyleDirectFormatting(LPCTSTR StyleName) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0xd0, DISPATCH_METHOD, VT_EMPTY, nullptr, parms, StyleName); +} + +CString WTable::get_Title() { + CString result; + InvokeHelper(0xd1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +void WTable::put_Title(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0xd1, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +CString WTable::get_Descr() { + CString result; + InvokeHelper(0xd2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, nullptr); + return result; +} + +void WTable::put_Descr(LPCTSTR newValue) { + static BYTE parms[] = VTS_BSTR; + InvokeHelper(0xd2, DISPATCH_PROPERTYPUT, VT_EMPTY, nullptr, parms, newValue); +} + +} // namespace MSO::Word + +#pragma warning( pop ) \ No newline at end of file diff --git a/src/word/WTables.cpp b/src/word/WTables.cpp new file mode 100644 index 0000000..d715016 --- /dev/null +++ b/src/word/WTables.cpp @@ -0,0 +1,73 @@ +#include "stdafx.h" + +#include "office/word/WTables.h" + +#include "office/word/WApplication.h" +#include "office/word/WTable.h" +#include "office/word/WRange.h" + +#pragma warning( push ) +#pragma warning( disable : 26493 26485 26494 ) + +namespace MSO::Word { + +LPUNKNOWN WTables::get_NewEnum() { + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, nullptr); + return result; +} + +long WTables::get_Count() { + long result; + InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +WApplication WTables::get_Application() { + LPDISPATCH result; + InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +long WTables::get_Creator() { + long result; + InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +LPDISPATCH WTables::get_Parent() { + LPDISPATCH result; + InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, nullptr); + return result; +} + +WTable WTables::get_Item(long IndexType) { + LPDISPATCH result; + static BYTE parms[] = VTS_I4; + InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, IndexType); + return result; +} + +WTable WTables::AddOld(LPDISPATCH Range, long NumRows, long NumColumns) { + LPDISPATCH result; + static BYTE parms[] = VTS_DISPATCH VTS_I4 VTS_I4; + InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Range, NumRows, NumColumns); + return result; +} + +WTable WTables::Add(WRange Range, long NumRows, long NumColumns, VARIANT* DefaultTableBehavior, VARIANT* AutoFitBehavior) { + LPDISPATCH result; + static BYTE parms[] = VTS_DISPATCH VTS_I4 VTS_I4 VTS_PVARIANT VTS_PVARIANT; + InvokeHelper(0xc8, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Range.m_lpDispatch, NumRows, NumColumns, DefaultTableBehavior, AutoFitBehavior); + return result; +} + +long WTables::get_NestingLevel() { + long result; + InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, nullptr); + return result; +} + +} // namespace MSO::Word + +#pragma warning( pop ) \ No newline at end of file diff --git a/test/Data/WrapperNewTest.xltx b/test/Data/WrapperNewTest.xltx new file mode 100644 index 0000000000000000000000000000000000000000..23f81faa6067a09abd2790b63c27c5cbd76b3462 GIT binary patch literal 7912 zcmeHM^;=Y1+a4HFnxVU;yQM>r?o6Q=~5$O~}2?a@M7*Z+e?ht{YJHGM6 zd(P4G{RQv4=bF8K*!zC2z1DNz`+4@gbku=pBmfKm761TX1W>jaUt6I7058x001yBR z)m#zk;%VdJ2{!O^wefhs>+9^qkcWoKo&!Kd-v7Vjzjy^ol0Iv-^Ajqcs9q|r@TkpH z$YF_WhjtNj>dLghUv$0$?`x=EoM?QFBD__qQ~&hkga=}8LM*>$YSIZETXVO7f()1# z@;+2F&>|*bQazAQkY%;1qE(SYG}v0Osfnsjl!$-XF`>XddMPZ)L}Y=4j4^aQRg&dR zG=P&k&X6bho=+MKHu>9OxF*dTjm}@4vBNrkN@^u36{3CiuEG|KWekWomfx**@z23^#D%m?Wa~B(bi5YWJdO&64 zkroA$GxtJ-Pd%yh>P!*Zc_wkx@)AI{D#2}cG_{a0Q88)Z=E209*QNc;IPy%usEor0 z)nUw-yIa+Y)NXj6y3D(n%zvpy|D8CB5VE{*(9BbKxI zVjw+eJh|{2o@}&)#@5$V(ryoHyU8;DZYRd0Gb%%UdkKdR)>-b7On%@;PAvyY>CK=k ze;%!jZapSp;#0u^l`httqad?N;l0n9esD4D_Tui{p3qqOqB&%d`c)($GD)uvkSp>D zDH19G7K*PE-|sr{fx1Jip-{+=0`{k7P>@v&8RftGDAChYhw~FQ;#^1Z`=oo55>0yY zF>M)sC&22dmi2ZiU8o8=hs32b9?Nr11OzLmMNET&Jzd z$5{Ifm$sUI{gBrDbKF&$Vs*NABGUemo(xglD)d1dFpt%|)Oth2qNl<|FGutAKKJKC zgzZXC*XTSl)4x*Y`mPgw7Lo>oNXif(??6)K?_`OCX}V1F6Goh%KgJBbNMXvQh_sTB z8zkE+>}Jv&6Ben!Iv`*no&0=E)u@_~I8(%o9Rqyyf>c6iMGWCqTPIalZ7quI0H4X8B-sQfCi*NGHs(wYPE? zg~o`AzVr)4Cs3U+v_v20d8t(%d-4~x?F}W9t^t1kVSDuXhE48TDS0M}RNX*FFIAzw zcLNJ0ab3LkIiNtM1b67*@l)`?qnSWC^U^%+rXC!n@_Q?o%?*|r z+Q~KPcd30dvNF2~1J&+$3M5ga?w^?16>)un51zQ*OG<+C&UjB*zI;`{&OY4~za&Ep zw~ap0l~woZWKJ3x?CxK|r1?BUc#ub8EiprT_p~TioBRtQZ1{zD6@rUX?UHz1VhO!T zQ8qctGjm$LV-r>n46yf5Hb$p^S?+V{wmV^a|0y+I^JT!<$@#?*!6waceJk1H`;Zy< zgFeisPEBuL>u$K2bcQKl$z-O;E+5POdn)TkwaSrKnvj2z-&5&fZ{=?DNZ-@l!Ntzw zhxmo#1)jC>69S&Rz6h(57S~}2r+Fj(&B9fxMJ*Yw*ML8XC#fcR-Ac_a(X?=h1$JAt z7pBs`3b)8~dqn>>{OBDZ!l0{D-@I+{0#XO;SSoT0VBua2#eI2YLSd_0$I6=vqC7V9 zn6+|khym(}c8O!$rtC60;Ln59Dkcqn*VJ|La?O$(bz|xQ>wwON!?SOk@SZ^6g%|#s z?+;U;-%Lub%`XKQ$QqDmD?bFD%a=qerm74{6)9M6<)2cd0 z#7$vmxDId4IQK};ZEc+qaF8m4-VG6p)4=syw%^TKXi$Z8G96VHH}-N0v&p<#cL3G-B$R#t+xGjD!dtmUnCY% zW!7ip*ERrfrD*FfKN_$H-`%wgJV|-wOlmP$HThi$5349q5KJ-(+B3QtJzhq15!T9h}PD_U;cr{pL}< z6Tye#|2C=p4SRIty-Ek7fUI}Jofe@8_aO{a&F&9*9D40>hi+IQbMSk{Iy5=BZ|=7# zI5ds$^0eHXgFF0-?Y(vdThS%!NqSRRODSQwIjQe35y0^rfS=pxRcyP;M#p07(Dicu zRdxcMl=#%m(7rp?xEmEIc6QK3Pd0c?B}nRg^Q?W~($^GzbKV}+EOjzzdQ6)z>D1#w?VqZoYOm4 zEHdTH6>o_OQ5~$e478w~@$#H~)*+{xumW*g0*Hy*;qf+L)E3&1a?en{P6XFdkhqys zAkH6&xoy@~i*)C#DRlQwHBo|8`ZOc;BbZ^t5r;xeiqTP9_yx}%h}pB(t^`Ev=!~?C zKw$XWk|DyZW^b@hZ8r1??{81oE{i(4u1z0NO?o9hCrt56LJ+Q{>~YeuXPlaNySBw( zG(R)k(szHt-o{kMO6n`g6qj$5p!zMpj>EDU{SCNXXSTs*-m)F8d`sEKU+VqC{@8Aj zrr|g@n4edn!+m(uZ65|DfvJ^V%=rbE$c_00%#5s!o#`a;oj@Pl!cMK@IpSW%{T=^S)-9+XzVBHm(R$L48;KfZ>s`JlCr}u$jNp^ zq*TSQSH3tA1(-L_k0BOh!Ohyes|W9=h86Hc{HJQtd1WNLK=W_noQoNm#|yqKv(gwh zigKrgv}@$PVC0Kkgvcm}*Q#17hM^hL>ySdb#KV%Co$ijPu9Yx9738%d=KpLP$kyeX z?v|pE4`rKtm*wWfnrPy@oAtngy}tq^YFiQi-=1>HfU?-=iOX6HR+x0fJzeB%k51r@=vKHoPfndE2OJZ!hs zhb*Lv4A+ZMZn+r|ob!9PkFx;ZtIs~RCTl%1DhkKDFlPIRJ^oe|t_; zIA4vVa#yO;B3r_3$rP}Wc|P4%Uvd59%w&zV-gQQ`9`5qZq|u=tDmfXB^mYg#Z$A26 zN$__Ra?UlKh>Da*XOwZLLT|asmLmbF$ed6vw*!vuvg=9-JHM35$U1%JAuQ}$>xnVw zjOjYb8i$RcrV_IC-0I0ff<%To#=jDb9lD?$gjCq4 zL>Kq#x0wl=YagpIKi&DjlUyKc!>7kVa@D4*bC4BK_$DnW>=n(Hos^?vRbNn*yhTEx2q0Sk+#WQ_bWnWIN~cP$YED-_C_br7t&#T9*<^p` zcxIZtR$$=H?9=<*U&p_B4%lzq^H_`VaNk>w0LnLswTgKhmWg?Xl8YtQ(%<%+Ng0w+=d-1g6;G! zx1gbki8GMpNX{ zM#OP4QM!+7@j;I(-|-2mYtuW3(bsiuknA1`hc<+@RKCDW9j6M_p4{p&*XV82T5$h_ z-|E}5xE(A^_2?@p9#Uf}(;{3#2oDTv$}a=dPnIT8lZMq!{+b%%~_y?bpBIBC1(gFV%H&#I`)5{^Jyn(-@UByAQ( zl#v2n$`i5ARr$PqGnaOw>}iiJUxQGc{@;M4iVUb zcBErpZaX7*M!gjL!1-AL*8STh>ATgcQT95CF=LPVw)+z>n2NB+U2zXgjtNk$MY z_YBThX#m+i37M0lICsI$i*5Y|nJGajowAvhs_(17ZN?K8Dop4y|8C4M!{ObBf_rSs z!xLOf{Amd)A7g8yF=v)#AuVEB9}1sh%C#Zp2M9*`uUkl z@_!|=?kz3Xm&lKbc_f)Bekbyej|vZa8yim#zTbx5dbK#1He`mMumcehh?)C@8#*N% zUru{V-5x*UYmkpA-Ly4pe4?$-$N45^>ZrEk=V4ZN$1V@&UTk)eBjDK96%E_5m22&${FlWr5ERiTEt@^ho^6hs%dRV<{r_E+qfI!7sO)VM4~ zq4}Gb`aidpdtKTi-yqX>%=fRU)c7cED2q&`E;5xwNK4@n^r4PB)YXIUA=KUG4?p~W zP6Bf2{9(H4?ffJW^XNB&%W`>-ed zS35nd9h*7nE7Tdrr5r?kSZXcNMw}nHh9HevP~9b<7)-1*gqXH9-_R?-5bLwj_l3zS zvimvz@Cc=(oeCNDFeIH-HHwU+0^f4wjBrtrqQyb{j{#m1pz;vetS{`_K$#aMZ5({*f z4ie!4CtX&)NQG(7o8BOOiQk!wg35z5VE%ni@z2ctIsVHIqmKGN1N?LA<4@p^F%2n? zziov44E(1Z{C8k8@>&0XbNJ^tKYN6KMcPMhoBre&{sR8VmHG?Zcs( z{)&);^RE`r&jEh!tN#iRNc{UF{HM$Q8TxZ4^A}Ww^gmPorLXxp%0G+fUoijxVq^pL pOG*71{?E7J-{H}ee}n(=Zq!jnM`jlQxP|-$BdfL^(klZ1{tu$Wcu)WU literal 0 HcmV?d00001 diff --git a/test/Data/WrapperOpenTest.xlsx b/test/Data/WrapperOpenTest.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..f128953fa836c0982b848f1205ba30154271afae GIT binary patch literal 7910 zcmeHM^@ zXr#a6jrZQ`_4^mR?>?V7`-eHt`kcMjv(8%kSs)!OY)Sww03QGVumSA0vz)Cl0Dwen z000QU$Fx+1diXea_<)TAJsrI73I({kvF2f8^5g@BlhT&}VopOLA&q;i$2pct4A65H)_uJmxPj(F77 zU`Q1E0NH9{%^)S**}citLPMA2WnqrWrDRYNr2~WG9WwxFu$m4-3AF`f?NWMYDr$xB zrL4(rQ}Vg4I-)lgMKZ{#ws}3%S#s&#;$gC-A>fFs3vZD1{*s^;b}W0)G_{{~0f^1a zh}X`r&g=BKPO~>pt@x;oJ?5+kJh6#nrhg8%p;?MqSAxE>IOgDuMOPw(za`iz_E?#OE&n5G3{kb(xsQKnOySD*yJ!op#olGp+?7BVvx>UVU~# z;ypcDc6WjKg6?cJeHkgfh|t%_o?7Wv{VjXOV2{Efyk%_l?^l#ZhOttwqVOeD&!f}A++HG{y5u(Eq?B(F*EiClo z{=abiFOI>#Exj~JSHDAq2#(S`k47Gk&Lonl==dvZHn16ohHFieR>kLYGR(AGXCyPG zkHpdlYYIK@otlx0-$1e*ElQNeQc&LHsP->|KR<=};_-2NrQU*-E+EMLMh{1iUTA0s z^7u6+@RigSz0~QMd`?$55UI=a1;JLPW+)>5IZOo@*{iw88aB@6o$6)-#tnVb#)LTWKD#Z(IWmCepKWW zKEmvqCf`W$dp__^akGhs9?UWD)!#K6(-Fpk!UIu#-G0Y6NEWexhi&{tF%;PMfo`aq zIMBZRJ}i8@tup2a4ICiF=Ek>@EkcrXZ(yB55>gRQslnXfo}Ky<-cfBK~^B;IXGxaxy|_+HcY(<#_=Q&s1~# zq5=iN@zJq?qKu6BNCG-+V zcVyu`W9!)%gJme$EscAfuG@59Bo9)nnmqVT*TBu!Gh1mC#@+)40Z)dba<1HngCK~) zvtZq~2Wimt7oqXgkb|6|6X>tm8ddRBqYPaiP&580&VOU8kF$fjgYa*6(H|?^G}ng$ zH7Hx|Z1~e|G1*=Bd&I#=c~jDbjf@K(vlJjd%OuwDKArCRcX)e+Vab~h8wG|_I;193 znxI39=ExHwmtqUPU8++@M|TtgsL5)0Mb7Cqa5u0s_hqIyNIOAV|z!@?Ao9mkwNl06%Z(x2bASDl*Tgpce^_^rg>CilIr@^MRh>+@t(3x>#z zSV)ycpJ`zG0Kk*By}wLIJv-&duugQv95C_rePc#}Yw_YD;W>??Px%e{cvr#kPO%%T zXH{a6U_L=p(^aNM4D(=LT(C>2WJWB>Y`8!u40o>C*s`=X04s)0*WYn)^5vFae+cHf zclGu|VT|D76@ zF6Ce3BrwZKPhJh}dEt-4=&1;D!p?efz_S`*a;F<79Rue9=7_7)j_4M-lM&LW;Ee67 ziB-H7d4+(ZPK}nZ<3TJiRjp-|zq1Nwz4Fl@wZ09sOQd||6@UM&p~s@WJf1|2@}-u1 ze&JH^v=dL_MS4_qxZx6(HPf`O&&-ofC4+=z2y77`CGA8k)QDSK=s+bfP50_4xR#a@ zW=V@Wy(b0RsI9(%%w17I_D?p`0X6z`;YJTRk|-V?h&QV~iryqCcyd?DnWuI+H6t>stuKyClCGXBQ-|~uzE2a$(gKrFWGiXAe9SzV-_86y z+hcHBo|tSJc?I#bvzK#G1<10;<(npGuIJbB+O*)j26upF8a?K0IuPpD)cu3y-rD!a zB5yPg$H9^UeG6Tz5Y5;9S=B@*mwWN%<~`tRbMtta*=yTV$*Z6P&>Wgb144?cLQ9i#qRwcj zcW%gON)ar7aw8A1Y?&KF%`1Xi^n1VVznvUbA-)kjS(728Ama<1dmZOq!p1RPu)f5_ zc&ABHApJqd?U&Ekgku*V3M$gInl`GD*mqb!RM2ke$kZ0MTO*n)r5umNgls89K01bS zcL!v^(p2)H+!JrIVQySc&D?jg?^^TpR{|v+E8{<%%Ta&GrOPz^(q141G_AJCa+dUm zIOM1ECiRbTTjJ*Qdk|A!AB$4JS3brzwT`mHExUPJBkgH+bwk#Ex5rT4z^J-dmweKh zCMsx5!(r(atTe6zxx^v=yt!Qi$K^)f5%H_6E-iIf3J?+Bbj)o{Pr76zye_AZ`b0pG z`?}7MwS1AuY6-?Qm?`P0h+oGzC)Qh?nfrFsZHJ~sQN(9=xZe|u7fV4d-wAZ|#Z;Yr zf@jGl5)_ZUi*t8Q(+I?WH)2IWd$C$#Gqyh&9)B=CXlF|hu>c*$++3?qJvieuR(GN? z{UrDpW4R!il#+Z31|{{KP;#^NY#}lEqMx8$%OXmpd=*}z=1x9CAP|#=noxf00hv%f z&MjH+Hw+rS70|=VG`Ks)xLcv0(udYVQ8{>S1V3z_7g>J!LB=UC?E}2d$bAT(;M(fb z7#y|?Q0nc2rU-Kx#RdVLRBP;?MBfV_?u^W6i zqT!A^uID*b%F3<6r{V}MU&E^EsL8En50J8(;>R`!X_I8uq|vlwZWxrFP-nQEp5kt{ zw|z7{#ZxOfaC7Fd74q}=y3c^~rk3|gjJMbB*O}FcxGc*r6}}b2hiUXlM*%S#N6vCz zXuH#BygO-}8iQyUn{eN<;@;Le^IBlG5^GPk1-mNkS+3H5PH92su7B5JJ8!2sve9)| z9S#6M{6_-!33PM#Epxvz*7;G1&Cskd;crug*wv-7@fI!N<0oR`Bw@~crf>i*Xt1u2 zcntZ{)TwR{I?yyldgqgHO_(O;38u$Oi_{$1@t3kaBI|dC{Q0gyn4ZmVAf}&J1%QgX7`*xrt}^8U3mw8LOlKO~`~0KV&1=E^ zUjn}tpTuqB%haUfchzLcc)_dFnsRIs)5TAp zXoS($BBT}H#V}%sEb|(78wwJFK*Dow4EVw?pEBM4c1(jR;GPnR!J|2sw8<7qF1PV~ za`+`a8oya*@Cj& z+LR71>Z|@GHc?a9FCc4iC)%0mDAsnUFf@kr5!R%>CQCcVIEo0x>^H}PVrkh5RhUJE zwqhTGoGTos#ZDL&!|%F3DZsb7UYfB}tr_hMdKxo!uWzew!3mzQchjPx>Jf=GY9gyr zPz|2owVF~(>tp|xD2^`Exy&5iV)bd3b3c}SkGsunF<#GQlWW&)yEA`(BG{T!nKCns zNno0AtSp3jkCNKWRa&56``MOJqr#+^9H@M{wd&hftSz=a zrQt99iz4X>8t-FkAK^_eT`e)=hSK^$(>Yl51%b)pb*Ry1RaJfof)Pc|1w)sc3oLWf z=QO`0vcWYy&lL2bVh&Aa+TV%%<51!4?BL+zE&SW`TdfwCqz{=EA?rjv48?mHBmkY1 zh_7I}rsGWV@N<~IIrEeqSNu~)|Mzpv91PLzM~RWPx5my7W}j_z)1VLpc9pdBb^O}A zthAf%vwejI|dCm@VvBKJ>AgYS-S5vZ!<~vP0FI>h>QvIpMuX5ZV z&yFj}+uk9l_1(=&fI8ymqOQQYN+7Mw=TOIvpaEopU%Xsy#s&g$(xaYOEA_8M0EI=7-B3{E}gsc{9yTE)Bj+L~O!! ztJ8Dxb(~CM?b1X#72uqn3TQoezKPXbKr?@E1BYs7}Tz1W{$E9Qpmr+Q@Oln????eJ5g@5tc z)W&G+O}=_GT!pXlq8HLY+3AG*vSgeWd9Mv$?Q&A{?N(?-=)t+*0V+%?)Js0> z20u9Y{KK;sN&0ihRBYeijM;vV=l6O@ERM{{{X@mih}^f9*H$zeK8^E&Qzd{AD4F z@Ru6U&jx-jtp73)MDhD8{HM(R8TxZ6^A}W&>OV{WS7GzBm49Z@zigm2S9AsSublcb l{GVULzr*2le}n(=Z3OAypuGzKTti>s=(G(&i)8@7{{dq1Z@~Zn literal 0 HcmV?d00001